Java, vérification simplifiée si le tableau int contient int

Fondamentalement, mon compagnon a dit que je pourrais raccourcir mon code en utilisant une manière différente de vérifier si un tableau int contient un int, bien qu'il ne me dise pas ce que c'est: P.

Actuel:

public boolean contains(final int[] array, final int key) {
    for (final int i : array) {
        if (i == key) {
            return true;
        }
    }
    return false;
}

J'ai également essayé cela, bien que cela renvoie toujours faux pour une raison quelconque.

public boolean contains(final int[] array, final int key) {
    return Arrays.asList(array).contains(key);
}

Quelqu'un pourrait m'aider?

Je vous remercie.

Voici la solution Java 8

public static boolean contains(final int[] arr, final int key) {
    return Arrays.stream(arr).anyMatch(i -> i == key);
}

Vous pouvez simplement utiliser ArrayUtils.containsde Apache Commons Lang library.

public boolean contains(final int[] array, final int key) {     
    return ArrayUtils.contains(array, key);
}

C'est parce que Arrays.asList(array)revenir List<int[]>. arrayL'argument est traité comme une valeur que vous souhaitez encapsuler (vous obtenez une liste de tableaux d'entiers), et non comme vararg.

Notez qu'il ne travail avec les types d'objet (pas primitives):

public boolean contains(final String[] array, final String key) {
    return Arrays.asList(array).contains(key);
}

ou même:

public <T>  boolean contains(final T[] array, final T key) {
    return Arrays.asList(array).contains(key);
}

Mais vous ne pouvez pas l'avoir List<int>et la boxe automatique ne fonctionne pas ici.

Guava propose des méthodes supplémentaires pour les types primitifs. Parmi eux, une méthode contient qui prend les mêmes arguments que le vôtre.

public boolean contains(final int[] array, final int key) {
    return Ints.contains(array, key);
}

Vous pouvez également importer statiquement la version goyave.

Voir les primitives de goyave expliquées

Une manière différente:

public boolean contains(final int[] array, final int key) {  
     Arrays.sort(array);  
     return Arrays.binarySearch(array, key) >= 0;  
}  

Cela modifie le tableau transmis. Vous auriez la possibilité de copier le tableau et de travailler sur le tableau d'origine, c'est-à-dire int[] sorted = array.clone();
mais ce n'est qu'un exemple de code court. Le runtime est O(NlogN)pendant que votre chemin estO(N)

Je sais qu'il est super tard, mais essayez à la Integer[]place int[].

1. utilisations ponctuelles

List<T> list=Arrays.asList(...)
list.contains(...)

2. utilisez HashSet pour des considérations de performances si vous en utilisez plusieurs fois.

Set <T>set =new HashSet<T>(Arrays.asList(...));
set.contains(...)

Essaye ça:

public static void arrayContains(){
    int myArray[]={2,2,5,4,8};

    int length=myArray.length;

    int toFind = 5;
    boolean found = false;

    for(int i = 0; i < length; i++) {
        if(myArray[i]==toFind) {
            found=true;
        }
    }

    System.out.println(myArray.length);
    System.out.println(found); 
}

Vous pouvez convertir votre tableau int primitif en un tableau d'entiers en utilisant le code Java 8 ci-dessous,

List<Integer> arrayElementsList = Arrays.stream(yourArray).boxed().collect(Collectors.toList());

Et puis utilisez la contains()méthode pour vérifier si la liste contient un élément particulier,

boolean containsElement = arrayElementsList.contains(key);

cela a fonctionné en java 8

public static boolean contains(final int[] array, final int key)
{
return Arrays.stream(array).anyMatch(n->n==key);
}

Vous pouvez utiliser la java.util.Arraysclasse pour transformer le tableau T[?]en un List<T>objet avec des méthodes telles que contains:

Arrays.asList(int[] array).contains(int key);

Selon la taille de votre tableau d'entiers, vous obtiendrez de bien meilleures performances si vous utilisez des collections et .containsplutôt que d'itérer sur le tableau un élément à la fois:

import static org.junit.Assert.assertTrue;
import java.util.HashSet;

import org.junit.Before;
import org.junit.Test;

public class IntLookupTest {

int numberOfInts = 500000;
int toFind = 200000;
int[] array;

HashSet<Integer> intSet;

@Before
public void initializeArrayAndSet() {
    array = new int[numberOfInts];
    intSet = new HashSet<Integer>();
    for(int i = 0; i < numberOfInts; i++) {
        array[i] = i;
        intSet.add(i);
    }
}

@Test
public void lookupUsingCollections() {
    assertTrue(intSet.contains(toFind));
}

@Test
public void iterateArray() {
    assertTrue(contains(array, toFind));

}

public boolean contains(final int[] array, final int key) {
    for (final int i : array) {
        if (i == key) {
            return true;
        }
    }
    return false;
}
}

Solution n ° 1

Étant donné que la question d'origine ne veut qu'une solution simplifiée (et non plus rapide), voici une solution en une ligne:

public boolean contains(int[] array, int key) {
    return Arrays.toString(array).matches(".*[\\[ ]" + key + "[\\],].*");
}

Explication: Javadoc d' Arrays.toString()états, le résultat est placé entre crochets et les éléments adjacents sont séparés par les caractères "," (une virgule suivie d'un espace). Nous pouvons donc compter sur cela. Nous convertissons arrayd'abord en une chaîne, puis nous vérifions si elle keyest contenue dans cette chaîne. Bien sûr, nous ne pouvons pas accepter les "sous-nombres" (par exemple "1234" contient "23"), nous devons donc rechercher des modèles où le keyest précédé d'un crochet ouvrant ou d'un espace, et suivi d'un crochet fermant ou d'une virgule.

Remarque: Le modèle d'expression régulière utilisé gère également correctement les nombres négatifs (dont la représentation sous forme de chaîne commence par un signe moins).

Solution n ° 2

Cette solution est déjà publiée mais elle contient des erreurs, je poste donc la bonne solution:

public boolean contains(int[] array, int key) {
    Arrays.sort(array);
    return Arrays.binarySearch(array, key) >= 0;
}

Cette solution a également un effet secondaire: elle modifie le array(le trie).

Essayez Integer.parseInt()de faire ceci .....

public boolean chkInt(final int[] array){
    int key = false;

    for (Integer i : array){


          try{

                   Integer.parseInt(i);
                   key = true;
                   return key;

             }catch(NumberFormatException ex){

                   key = false;

                   return key;

              }


     }
}