[RESOLVIDO] Exceção java.util.ConcurrentModificationException, como resolver?

Altera para:

public static void calcularEspacoAmostral() {  
  	  
        /* 
         * Lista, numeros para armazenar os elementos usados para tirar os eventos. 
         * Lista espacoAmostral que contém todos os elementos. 
         * Lista sublist que contém um evento. 
         */  
        List<Integer> numeros = new ArrayList<Integer>();  
        List<List<Integer>> espacoAmostral = new ArrayList<List<Integer>>();  
        List<Integer> sublist;  
          
        //Criando os números  
        int n1 = 1;  
      
        while (n1 < 7) {  
            numeros.add(n1);  
            n1++;  
        }  
      
        long n2 = 0;  
        while (n2 < 15) {  
        	
            Collections.shuffle(numeros); //Embaralha  
            sublist = new ArrayList<Integer>(numeros.subList(0, 2)); //gera um novo elemento  
            Collections.sort(sublist); //ordena os elementos no novo elemento  
              
       
            if (espacoAmostral.contains(sublist)) {
                System.out.println("Já contém." + sublist.toString());
            } else {
                espacoAmostral.add(sublist);
                n2++;
            } 
      
            System.out.println("Lista de sorteios: " + espacoAmostral.toString());  
              
        }  
      
    }

Estava esquecendo do “ensinar a pescar”, esse erro ocorre quando uma lista está sendo “varrida” (iterada) e ocorre uma modificação na mesma (no caso um add), a implementação detecta essa alteração e lança o erro.

Outro detalhe: subList retorna uma mesma referencia para numeros, então é fundamental criar uma nova lista.

Sua solução tem um problema para espaços com muitos elementos, uma sugestão é gerar o espaço em ordem e fazer o embaralhamento no espaço.

A H Gusukuma:

Estava esquecendo do “ensinar a pescar”, esse erro ocorre quando uma lista está sendo “varrida” (iterada) e ocorre uma modificação na mesma (no caso um add), a implementação detecta essa alteração e lança o erro.

Outro detalhe: subList retorna uma mesma referencia para numeros, então é fundamental criar uma nova lista.

Sua solução tem um problema para espaços com muitos elementos, uma sugestão é gerar o espaço em ordem e fazer o embaralhamento no espaço.

Muito obrigado pela resposta! Agora eu entendi

Sobre a dica. Eu preciso do espaço ordenado. Com esse algoritmo ele está desordenado pois só foram ordenados as sublistas.
Já vi que o sort() não funciona depois do List<List>.

Se precisa ordenado, poderia gerar em ordem:

List<List<Integer>> espacoAmostral = new ArrayList<List<Integer>>(); for (int i = 1; i < 7 -1; i++) { for (int j = i + 1; j< 7; j++) { sublist = new ArrayList<Integer>(); sublist.add(i); sublist.add(j); espacoAmostral.add(sublist); } } System.out.println("Lista de sorteios: " + espacoAmostral.toString());

Essa última solução é válida, mas no meu caso meu algoritmo vai ser dinâmico, ou seja, quero poder informar a quantidade de elementos que quero sortear de uma determinada quantidade de elementos.

Essa parte de o algoritmo ser dinâmico eu já consegui desenvolver. Inclusive a questão do sort eu já conseguir resolver.
Mas estou com um último problema.

Vou postar um exemplo de como eu mapeei o algoritmo.

Classe de modelo (exemplo):

@Entity
@Table
//@NamedQuery(name="find.all", query="SELECT s FROM Espacoamostral s")
public class EspacoAmostral implements Serializable, Comparable<EspacoAmostral>{
	
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private long id;
	
	private int b_0,b_1;
	
	public EspacoAmostral() {}
	
	@Override
	public int compareTo(EspacoAmostral espacoAmostral) {
		if (this.b_1 < espacoAmostral.b_1) {
			return -1;
		} else {
			return 1;
		}
	}

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public int getB_0() {
		return b_0;
	}

	public void setB_0(int b_0) {
		this.b_0 = b_0;
	}

	public int getB_1() {
		return b_1;
	}

	public void setB_1(int b_1) {
		this.b_1 = b_1;
	}

}

Classe de negócio (implementação do método):

public void calcularEspacoAmostral() throws ClassNotFoundException,
			IllegalAccessException, IllegalArgumentException,
			InvocationTargetException, InstantiationException {

		int contador = 0;
		
		EspacoAmostral ea = new EspacoAmostral();
		
		/*
		 * Lista, numeros para armazenar os elementos usados para tirar os
		 * eventos. Lista espacoAmostral que contém todos os elementos. Lista
		 * sublist que contém um evento.
		 */
		List<EspacoAmostral> objetosAmostral = new ArrayList<EspacoAmostral>();
		List<Integer> numeros = new ArrayList<Integer>();
		List<Integer> sublistAtual = new ArrayList<Integer>();
		List<Integer> sublistAntiga = new ArrayList<Integer>();

                //Utilizando o pacote reflect
		Class c = Class.forName("com.ararazul.model.entidades.EspacoAmostral");
		EspacoAmostral espacoAmostral = (EspacoAmostral) c.newInstance();
		Method methods[] = c.getMethods();

		// Criando os números
		int n1 = 1;

		while (n1 < 7) {
			numeros.add(n1);
			n1++;
		}

		long n2 = 0;
		while (n2 < 15) {
			Collections.shuffle(numeros); //Embaralhando
			sublistAtual = new ArrayList<Integer>(numeros.subList(0, 2)); //Sorteando
			Collections.sort(sublistAtual); //Ordenando o sorteio

                        //Verificando se já existe, se não existir verifica e invoca o método adequado em tempo de execução
                        //passando cada valor da sublistAtual para cada método invocado.
			if (sublistAtual.equals(sublistAntiga)) {

				System.out.println("Já existe: " + sublistAtual);
				// continue;

			} else {

				for (int i = 0; i < sublistAtual.size(); i++) {

					System.out.println("i vale: " + i + " valor da posição: " + sublistAtual.get(i));
					
					for (Method m : c.getMethods()) {

						String[] split = m.getName().split("_");

						if (split.length > 1 && split[0].equals("setB")) {

							String s1 = split[0];
							int s2 = Integer.parseInt(split[1]);

							// invocação do método em tempo de execução.
							if (s2 == contador) {
								m.invoke(espacoAmostral, sublistAtual.get(contador));
								contador++;
							}
						}
						
					}
					
					contador = 0;
				}

				n2++;

			}
			objetosAmostral.add(espacoAmostral);
			sublistAntiga = sublistAtual;
			sublistAtual = null;
			System.out.println(objetosAmostral.size());
			Collections.sort(objetosAmostral);
			
		}
                
                //O problema está aqui.
                //O resultado impresso é sempre a última sublistAtual 15 vezes.
		for (EspacoAmostral e : objetosAmostral) {
			System.out.println(e.getB_0() + ", " + e.getB_1());
		}

	}

Defina a lista objetosAmostral fora do escopo do método, como está, sempre vai ser criado uma nova lista em cada invocação do método.

Vários problemas no teu código:
- Dizes que queres ter uma solução dinâmica mas tens uma class com duas variaveis b_0 e b_1. Isto não é dinâmico.
- Usas reflection para invocar uma instância da própria classe onde estás. Não vejo a necessidade.
- No sorteio apenas estás a comparar com a última sublist. Se for igual a uma que já saiu mas não a última, vai adicionar na mesma
- Se queres todos os casos possíveis não deves sequer fazer qualquer sorteio mas sim varrer todas as soluções.

O que tu precisas é de algo recursivo. Feito em cima do joelho, mas será mais ou menos assim:

public class EspacoAmostral {
    List<List<Integer>> espacoAmostral = new ArrayList<List<Integer>>();

    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6);  // lista de números 
        int n = 2; // número de elementos a sortear

        new EspacoAmostral().calcularEspacoAmostral(numeros, n);


    }

    public void calcularEspacoAmostral(List<Integer> numeros, int n) {

        recursiveIteration(new ArrayList<Integer>(), numeros, n);  //chama método recursivo dado que n é dinamico

        for (List<Integer> e : espacoAmostral) {
            System.out.print("=> ");
            for (Integer i : e) {
                System.out.print(i + " ");
            }
            System.out.println();
        }

    }

    void recursiveIteration(List<Integer> currentList, List<Integer> toCheck, int n) {
        if (currentList.size() == n) {     
            espacoAmostral.add(currentList);
            return;
        }

// aqui está a lógica necessária: varre os números da lista que ainda não verificou e cria uma cópia para cada um deles
        List<Integer> newToCheck = new ArrayList<Integer>(toCheck);
        for (Integer x : toCheck) {
            List<Integer> newList = new ArrayList<Integer>(currentList);
            newList.add(x);
            newToCheck.remove(x);

            recursiveIteration(newList, newToCheck, n);  // chama o próprio método até n ser igual ao tamanho da lista 
        }


    }
}

pmlm:

Vários problemas no teu código:

• Dizes que queres ter uma solução dinâmica mas tens uma class com duas variaveis b_0 e b_1. Isto não é dinâmico.

• Usas reflection para invocar uma instância da própria classe onde estás. Não vejo a necessidade.

• No sorteio apenas estás a comparar com a última sublist. Se for igual a uma que já saiu mas não a última, vai adicionar na mesma

• Se queres todos os casos possíveis não deves sequer fazer qualquer sorteio mas sim varrer todas as soluções.
  

Vou fazer os testes e ao chegar em casa eu edito esta mensagem com os resultados.

Precisas disso para o “dinamismo” que nunca terás assim. Agora tens b_1 e b_2. Dinâmico para ti será ter até b quanto? b_10, b_20?, b_100?
E eu sei bem o que é reflection, fui eu quem te “ensinou” há umas semanas atrás.

Quando resolveres o teu problema do print vais-me dar razão

guj1:

• Se queres todos os casos possíveis não deves sequer fazer qualquer sorteio mas sim varrer todas as soluções.
  Eu estou tratando de arranjos simples (gerar combinação sem repetição incluindo a ordem dos elementos).

Nota que o objetivo destes comentários não é “dizer mal” da tua solução mas apenas por-te a pensar pelo caminho correto a seguir. Acredita que a maneira que estás a fazer não é a correta e se fores avante com ela o único prejudicado serás tu e mais ninguém.

Bom, vamos lá, pmim.

Bom vou explicar exatamente o que estou fazendo ok?

Claro que você está falando por mal, eu entendo, eu sei ouvir uma boa crítica e discutir sem nenhum problema. Por isso, estou gostando muito das suas dicas e as do A H Gusukuma.

Explicando o que estou tentando fazer.

Eu vou preciso gerar 6 espaços amostrais, cada um deles possui uma natureza diferente. E eu sei exatamente a quantidade de elementos que cada um contém. Na casa de milhões.

Em suma o que eu preciso é gerar os arranjos simples e persistir num database.

Para isso eu pensei, vou gerar cara combinação com um Collections.shuffle ordeno e adiciono numa lista se ela não existir. Ao final eu ordeno a lista de arranjos. Para persistir num database eu crio uma entidade que contenha uma lista dos objetos (espaço amostral).
Por isso, eu teria que atribuir o valor de cada elemento de cada arranjo a cada atributo da entidade, daí o motivo de eu precisar chamar os métodos da entidade em tempo de execução para verificar o método correto pois ela possui outros como o id, toString e outros. Entendeu? Não sei se me expressei bem.

Ah! Eu não entendi muito bem a sua dica. (a que contém o código fonte)

A H Gusukuma:

Se precisa ordenado, poderia gerar em ordem:

List<List<Integer>> espacoAmostral = new ArrayList<List<Integer>>(); for (int i = 1; i < 7 -1; i++) { for (int j = i + 1; j< 7; j++) { sublist = new ArrayList<Integer>(); sublist.add(i); sublist.add(j); espacoAmostral.add(sublist); } } System.out.println("Lista de sorteios: " + espacoAmostral.toString());

Galera, não deu certo.

Uma pergunta, se os números fossem de 0 a 99 e eu quisesse sortear 10 números por vez, como a solução acima poderia ajudar?
Ficaria muito procedural não?
O que seria preciso modificar nela?

Se tu queres saber todas as combinações, não podes confiar na sorte e ir fazedo shuffle até ter todas. Em primeiro lugar porque não deves partir do pressuposto que sabes quanto são “todas”, logo não sabes quando parar. Depois, porque fazendo o shuflle, no limite podes nunca ter todas já que o sistema pode executar dias e nunca gerar uma delas.

guj1:

Ah! Eu não entendi muito bem a sua dica. (a que contém o código fonte)

guj1:

Ah! Eu não entendi muito bem a sua dica. (a que contém o código fonte)

Estudei e entendi a recursividade.
Mudei minha estratégia. Agora só vou usar o algoritmo uma vez. Mesmo usando recursividade não vai ficar performático.
Agora vou gerar apenas 4 espaços amostrais. Portanto, vou usar algo estático mesmo.

A H Gusukuma:

Se precisa ordenado, poderia gerar em ordem:

List<List<Integer>> espacoAmostral = new ArrayList<List<Integer>>(); for (int i = 1; i < 7 -1; i++) { for (int j = i + 1; j< 7; j++) { sublist = new ArrayList<Integer>(); sublist.add(i); sublist.add(j); espacoAmostral.add(sublist); } } System.out.println("Lista de sorteios: " + espacoAmostral.toString());

Sobre essa dica, no caso o número de elementos do espaço amostral é o número de for e todos os for internos devem inicializar um valor somando 1, certo?