Comment puis-je comparer deux tableaux de tailles différentes et vérifier l'ordre des éléments?
1.La première vérification est ArrayList1 est un sous-ensemble de list2
2.La deuxième vérification est que ArrayList2 a le même ordre que List1, ignorer les éléments aléatoires
Iterator<String> List1_Iterator = List1.iterator();
while (List1_Iterator.hasNext()) {
}
Le test passera si List2 est dans cet ordre:
list1.contains(list2.get(i)))
Le test échouera si List 2 a un autre ordre comme:
"a", "is", "coding", "test", "this" , ou si l'un de ces 5 mots est manquant .
Le programme doit ignorer n'importe quel nombre de valeurs aléatoires (comme random1, random2 et random3) dans la liste 2.
Comment puis-je réaliser ce scénario?
J'ai essayé pour des boucles et des itérateurs. Cela n'a pas fonctionné, ils m'ont donné des éléments communs des deux ArrayList mais pas de "l'ordre". Que puis-je faire d'autre?
pour boucle en utilisant:
"this" "is" "a" "coding" "test"
Mais ceci ne compare que les valeurs et ne vérifie pas la commande.
Itérateur avec boucle while :
Arraylist1{"this", "is", "a", "coding", "test"};
Arraylist2{"this", "is", "random1", "a", "random2", "coding", "random3", "test"};
Cela ne vérifie pas non plus l'ordre des éléments.
5 Réponses :
Une façon de faire est de créer d'abord une copie de la liste 2 appelée list2Copy , puis de supprimer tous les éléments de list2Copy qui n'existent pas dans list1 . Il ne vous reste plus qu'à comparer si elles sont exactement égales l'une à l'autre.
if (list1.size() > list2.size()) {
// definitely not same order
return false;
}
int list1Index = 0;
for (int i = 0 ; i < list2.size() ; i++) {
if (Objects.equals(list2.get(i), list1.get(list1Index))) {
list1Index++;
if (list1Index == list1.size()) {
return true;
}
}
}
// at the end, list1Index should be the same as list1.size() if list2 is in the same order.
return false;
Voici une autre approche avec une complexité temporelle moindre:
List<Integer> list1 = Arrays.asList(1,3,5); List<Integer> list2 = Arrays.asList(1,2,3,4,5); ArrayList<Integer> list2Copy = new ArrayList<>(list2); list2Copy.removeIf(x -> !list1.contains(x)); return list1.equals(list2Copy);
p >
Désolé, list1 = {1}, list2 = {1,1} . Le résultat est false , mais doit être true . De plus: vous créez un tableau temporaire (ce n'est pas obligatoire pour cette tâche simple), et remove sur ArrayList ralentit les performances.
@ oleg.cherednik corrigé. Et oui, j’ai réalisé que la première n’était pas très rapide, c’est pourquoi j’ai ajouté la deuxième approche. Je crée la copie car list2 peut ne pas prendre en charge la suppression.
Eh bien, je comprends que nous comparons deux arraylists en utilisant le .equals () .. que fait object.equals? Désolé, j'apprends encore ... est-ce une méthode intégrée ou la passons-nous en paramètre comme: public boolean equals (Object object) {
@ oleg.cherednik il est intégré. J'aurais pu aussi écrire list2.get (I) .equals (list1.get (list1Index)) mais cela passera par une exception si list2.get (I) est nul.
list2.get (I) .equals (list1.get (list1Index)) me donne un index hors limites, avec index3, taille 3 .. Je ne sais pas pourquoi vérifie-t-il l'index 3. et comment éviter cela ..
Arraylist est indexé, vous pouvez donc boucler sur la plus petite liste, puis vérifier la non-concordance en comparant la valeur aux indices. Une méthode qui fait de même - ne retournera vrai que si les éléments sont dans le bon ordre dans les deux listes (une liste est un sous-ensemble de l'autre et les éléments sont égaux dans le même ordre), de manière efficace.
private boolean checkForEqualityInorder(List<String> list1, List<String> list2) {
for (int i=0, k=0; i <list1.size(); i++, k++){
if (list2.get(k).startsWith("random")) {
i--;
continue;
}
if(!list1.get(i).equals(list2.get(k))) {
return false;
}
}
return true;
}
La méthode ci-dessus accepte deux listes et ne retournera vrai que si l'une est un sous-ensemble de l'autre (cochée dans l'ordre).
Amélioration de la même méthode pour votre problème: p>
private boolean checkForEqualityInorder(List<String> list1, List<String> list2) {
if (list1.size() < list2.size()) {
for (int i=0; i <list1.size(); i++){
if( !list1.get(i).equals(list2.get(i))) {
return false;
}
}
} else {
for (int i=0; i <list2.size(); i++){
if( !list2.get(i).equals(list1.get(i))) {
return false;
}
}
}
return true;
}
Vous commencez par le premier élément de la première liste et vous essayez de le trouver dans la deuxième liste. Si / Lorsque vous le trouvez, vous affectez l'index de l'élément de la liste 2 à une variable locale (indexList2). Ensuite, vous allez au deuxième élément de la première liste et essayez de le trouver dans la liste 2 mais vous ne commencez pas à l'index 0 mais à l'indexList2. Vous continuez jusqu'à ce que vous ayez bouclé tous les éléments de la liste 1 (et les avez trouvés dans la liste 20 -> le test est réussi, sinon, le test est un échec
Vous pouvez également effectuer ce processus simple selon vos étapes. 1) Comparez les éléments. 2) comparez la commande.
import java.util.*;
class Stack1
{
public static void main(String args[])
{
ArrayList<String> list=new ArrayList<String>();
list.add("First");
list.add("name");
list.add("is");
list.add("Jay");
ArrayList<String> list2=new ArrayList<String>();
list2.add("First");
list2.add("name");
list2.add("is");
list2.add("Sudeep");
ArrayList<String> list3=new ArrayList<String>();
for(int i=0;i<list2.size();i++)
{
for(int j=0;j<list.size();j++)
{
if(list2.contains(list.get(j))==true)
{
if(list2.get(i)==list.get(j))
{
list3.add(list2.get(i));
}
}
else{ break; }
}
}
if(list.equals(list3))
{
System.out.println("true");
}
else{System.out.println("false");}
}
}
List<String> one = Arrays.asList("this", "is", "a", "coding", "test");
List<String> two = Arrays.asList("this", "is", "random1", "a", "random2", "coding", "random3", "test");
System.out.println("same order: " + isHasSameOrder.test(one, two)); // true
Bienvenue dans StackOverflow, lorsque vous posez des questions contenant des morceaux de code, veuillez le formater correctement, cela entraînera une question de meilleure qualité et vous donnera des réponses beaucoup plus rapidement.
Je comparerais les deux tableaux, puis supprimerais tout ce qui n'est pas le même de array2. Après cela, concattez les deux chaînes et comparez si elles sont exactement les mêmes.