Como comparar ArrayList's !?

Programação Java
, , , ,
#1

Como faço para comparar se o conteúdo de uma ArrayList é igual a outra ArrayList (no meu caso é a mesma ArrayList só que em vetores diferentes, algo como if(S[x].toArray == S[x+1].toArray), pra verificar todo o conteúdo dela e ver se esta igual … Só que se por exemplo na primeira array tiver “2” e “4” e na segunda tiver “4” e “2” tem que dar como igual, oque eu quero é que o conteúdo seja o mesmo, não precisa ser a mesma ordem

#2

Modo braço, é um algoritmo de exaustão ( que na maioria das vezes é ineficiente, mas, funcional ) com um ajuste para quando não achar a primeira ocorrência já cai fora dos duas estruturas de repetição. Há pacotes para fazer isso, mas, se o intuito é aprender tá ai um código a ser estudado e modificado se assim achar solução a melhorar.

import java.util.*;
import java.lang.*;
import java.io.*;

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		int[] first = {5,2,3,1};
		int[] other = {3,2,1,5};
		boolean status = false;
		if (first.length == other.length)
		{
			for(int i = 0; i < first.length; i++)
			{
				status = false;
				for(int j = 0; j < other.length; j++)
				{
					if (other[j] == first[i])
					{
						status = true;
						break;
					}
				}
				if (!status)
				{
					break;
				}
			}
		}
		if (status)
		{
			System.out.println("Há correspondencia nos dois arrays");	
		}
		else
		{
			System.out.println("Não Há correspondencia nos dois arrays");	
		}
	}
}

Link de Teste

Nesse caso é com array simples,com ArrayList tem no site, a única coisa que você precisa fazer é ordernar os dois na mesma lógica.

ArrayList<Integer> first = new ArrayList();
first.add(1);
first.add(2);
first.add(3);
ArrayList<Integer> other = new ArrayList();
other.add(1);
other.add(2);
other.add(3);
	
System.out.println(first.equals(other)); // retornar verdade

Linq para verificação

ArrayList<Integer> first = new ArrayList();
first.add(1);]
first.add(2);
first.add(3);
ArrayList<Integer> other = new ArrayList();
other.add(1);
other.add(3);
other.add(2);
	
System.out.println(first.equals(other)); // retornar falso

Linq para verificação

Maneira com Ordenação:

import java.util.*;
import java.lang.*;
import java.io.*;    

class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		ArrayList<Integer> first = new ArrayList();
		first.add(3);
		first.add(1);
		first.add(2);
		ArrayList<Integer> other = new ArrayList();
		other.add(2);
		other.add(3);
		other.add(1);
 
		Collections.sort(first); // ordernando ...
		Collections.sort(other); // ordernando ...
 
		System.out.println(first.equals(other));
	}
}
1 curtida
#3

Pode usar o método abaixo:

public static <T extends Comparable<? super T>> boolean areEquals(List<T> primeira, List<T> segunda) {
    if (primeira == null && segunda == null) {
        return true;
    }
    if (primeira == null || segunda == null) {
        return false;
    }
    if (primeira.size() != segunda.size()) {
        return false;
    }
    primeira = new ArrayList<T>(primeira);
    segunda = new ArrayList<T>(segunda);
    Collections.sort(primeira);
    Collections.sort(segunda);
    return primeira.equals(segunda);
}

Aí basta comparar assim por exemplo:

boolean iguais = areEquals(minhaLista1, minhaLista2);
1 curtida
#4

Caso você precise que a quantidade do mesmo elemento também não importe, pode fazer algo assim:

    List<Integer> minhaLista1 = Arrays.asList(3, 3, 3, 3, 4); // lista com 3, 3, 3, 3 e 4
    List<Integer> minhaLista2 = Arrays.asList(4, 4, 4, 4, 3); // lista com 4, 4, 4, 4 e 3

    boolean saoIguais = new HashSet<>(minhaLista1).equals(new HashSet<>(minhaLista2));

    System.out.println("Resultado: " + saoIguais); // true

[3, 3, 3, 4] e [4, 4, 4, 3], por exemplo, vão ser iguais.

2 curtidas
#5

Entendi, dessa forma eu conseguiria, só tenho uma duvida quanto a primeira linha, no caso do:

Oque seria esse <T extends Comparable<? super T>> ? Que depois acabou usando ele como um tipo de objeto para a lista…

Desculpa se estiver sendo chato com essa pergunta, é que eu não quero pegar um código e usar no meu código sem entender como ele funciona… :confused:

#6

O tipo genérico das listas passadas por parâmetro.
Pra funcionar com List de qualquer tipo de dado que implemente Comparable.
Tipei dessa forma pra ficar igual à assinatura do método Collections.sort.
Se quiser, pode tirar a declaração do T e usar parâmetros do tipo List<Integer>, Mas aí o método só vai funcionar pra verificar List<Integer>.

#7

Entendi, obrigado pela explicação

#8

Na verdade você não entendeu a solução dele em nenhum momento, precisa parar e estudar pra entender isso mais relevante. Apesar que eu acho que você também não entendeu nenhum das soluções e você tem razão em indagar para não copiar e colar.

1 curtida