L'aide contient une liste de tableaux avec des tableaux d'entiers

J'ai un ArrayList<int[]>, et j'ai ajouter un tableau.

ArrayList<int[]> j = new ArrayList<int[]>();
int[] w = {1,2};
j.add(w);

Supposons que je veux savoir si j contient un tableau qui a {1,2} sans l'aide de w, depuis que j'ai appeler à partir d'une autre classe. Donc, je crée un nouveau tableau avec {1,2} ...

int[] t = {1,2};
return j.contains(t);

...mais ce serait de retour faux, même si w a été ajouté à la liste, et w contient exactement le même tableau que t.

Est-il un moyen d'utiliser contient que j'ai juste vérifier pour voir si l'un des éléments de la ArrayList a le tableau de la valeur {1,2}?

OriginalL'auteur kamikaze_pilot | 2011-01-31

8

Tableaux ne peuvent être comparés avec les Tableaux.equals().

Vous voulez probablement une liste de tableaux de ArrayLists.
```
ArrayList<ArrayList<Integer>> j = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> w = new ArrayList<Integer>();
w.add(1); w.add(2);
j.add(w);
ArrayList<Integer> t = new ArrayList<Integer>();
t.add(1); t.add(2);
return j.contains(t); //should return true.
```
Qui ne résoudra pas le problème réel malheureusement. Que faire si w avait 1,2,3?
Je pensais que l'utilisateur voulait comparer l'exacte des tableaux, il ne mentionne pas une tranche de la matrice.
Vous avez raison, j'avais peut-être mal interpréter.

OriginalL'auteur Clement P

Le problème ici est que les tableaux ne pas remplacer de l'Objet.equals(Object), de Sorte que la comparaison entre les deux entrées de la liste qui se passe avec la valeur par défaut est égale à() de la mise en œuvre

//from Object.class
public boolean equals(Object obj) {
return (this == obj);
}

De sorte que vous avez à parcourir la liste et de vérifier toutes les entrées à l'aide de Tableaux.equals(int[], int[]). Voici une méthode d'assistance que ce n':

public static boolean isInList(
    final List<int[]> list, final int[] candidate){

    for(final int[] item : list){
        if(Arrays.equals(item, candidate)){
            return true;
        }
    }
    return false;
}

Mise à jour: depuis Java 8, c'est beaucoup plus simple:

public static boolean isInList(
        final List<int[]> list, final int[] candidate) {

    return list.stream().anyMatch(a -> Arrays.equals(a, candidate));
            // ^-- or you may want to use .parallelStream() here instead
}

OriginalL'auteur Sean Patrick Floyd

0

Vous avez besoin pour parcourir la liste et vérifier manuellement si un tableau correspondant à vos critères.
```
public static boolean containsSubArray(List<int[]> j, int[] sub) {
   for ( int[] arr : j ) {
      if (arr contains elements of sub) {
         return true;
      }
   }
   return false;
}
```
Si vous voulez une correspondance exacte, vous pouvez faire usage de Arrays.equals(). Je ne pense pas qu'il y est une fonction de la bibliothèque pour faire un contient tous sur un tableau, donc vous devez écrire vous-même si c'est ce que tu voulais.

OriginalL'auteur Mark Peters
0

"contient" contrat vérifie l'égalité. Si dans votre cas, qu'est-ce que l'échec est l'égalité des int[]. Depuis Array ne remplace pas la méthode equals de Object vous aurez besoin d'une solution de contournement pour vérifier l'enceinte de confinement.

Si vous avez besoin de vérifier pour le confinement à l'intérieur de la Array alors vous êtes de gauche avec pas le choix mais pour itérer sur la liste de tableaux et de faire la comparaison vous-même.

OriginalL'auteur Tushar Tarkas
0

à partir de l'api java:
```
public boolean contains(Object o)
```
Retourne true si cette liste contient les
l'élément spécifié. Plus formellement,
retourne true si et seulement si cette liste
contient au moins un élément de e tel
que (o==null ? e==null : o.equals(e)).

depuis int[] est un primitif, im assez sûr que non .méthode equals existe donc pour sa je pense qu'il serait toujours retourner false.

Je recommanderais une autre manière de stocker les données? peut-être avec une touche de la sorte?

int[] n'est pas vraiment une primitive. Tous les tableaux sont un Object et hériter de sa mise en œuvre de equals() qui renvoie true si les opérandes sont les mêmes exemple (==)
int[] n'est pas primitif. int. int[] s'étend de l'Objet, mais ne modifie pas equals()
ah mon b. j'essayais d'exprimer le fait qu'il ne modifie pas la méthode equals() et donc ne peut pas être utilisé pour contient.

OriginalL'auteur eosgood
0

Deux java tableau tableaux sont égaux ssi ils ont la même référence d'objet. Le contenu n'a pas d'importance.

Vous êtes à la recherche d'un moyen de vérifier si elles ont un contenu égal. Cela pourrait aider:
```
 Arrays.equals(new int[]{1,2}, new int[]{1,2});   //evaluates to true
 Arrays.equals(new int[]{1,2}, new int[]{2,1});   //evaluates to false (!)
```
Si l'ordre ne doit pas affecter l'égalité, alors vous aurez à mettre en œuvre une statique de la méthode equals par vous-même.

OriginalL'auteur Andreas_D
0

D'abord ils ne sont pas la même référence de l'Objet, de sorte qu'ils ne sont pas égaux. equals() retournera false.
Pour votre état, vous aurez besoin de mettre en œuvre une méthode permettant de comparer vous-même.

OriginalL'auteur Aardvocate Akintayo Olusegun

Vous devez vous connecter pour publier un commentaire.