Java, Vereinfachte Überprüfung, ob das Array int int enthält

Grundsätzlich hat mein Partner gesagt, dass ich meinen Code kürzer machen könnte, indem ich auf andere Weise überprüfe, ob ein int-Array ein int enthält, obwohl er mir nicht sagt, was es ist: P.

Aktuell:

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

Habe dies auch versucht, obwohl es aus irgendeinem Grund immer false zurückgibt.

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

Könnte mir jemand helfen?

Danke dir.

Hier ist die Java 8-Lösung

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

Sie könnten einfach ArrayUtils.containsvon verwenden Apache Commons Lang library.

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

Es ist weil Arrays.asList(array)Rückkehr List<int[]>.arrayDas Argument wird als ein Wert behandelt, den Sie umbrechen möchten (Sie erhalten eine Liste der Ints-Arrays), nicht als vararg.

Beachten Sie, dass es funktioniert die Arbeit mit Objekttypen (nicht Primitiven):

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

oder auch:

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

Aber Sie können nicht haben List<int>und Autoboxing funktioniert hier nicht.

Guave bietet zusätzliche Methoden für primitive Typen. Darunter befindet sich eine Methode, die dieselben Argumente wie Ihre verwendet.

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

Sie können die Guavenversion auch statisch importieren.

Siehe Erklärte Guavenprimitive

Ein anderer Weg:

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

Dadurch wird das übergebene Array geändert. Sie hätten die Möglichkeit, das Array zu kopieren und am ursprünglichen Array zu arbeiten, dh int[] sorted = array.clone();
dies ist nur ein Beispiel für Funktionscode. Die Laufzeit ist wie O(NlogN)du bistO(N)

Ich weiß, dass es super spät ist, aber versuche es Integer[]stattdessen int[].

1. einmalige Verwendung

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

2. Verwenden Sie HashSet zur Leistungsüberlegung, wenn Sie mehr als einmal verwenden.

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

Versuche dies:

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); 
}

Sie können Ihr primitives int-Array mit dem folgenden Java 8-Code in eine Arrayliste von Ganzzahlen konvertieren.

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

Verwenden Sie dann die contains()Methode, um zu überprüfen, ob die Liste ein bestimmtes Element enthält.

boolean containsElement = arrayElementsList.contains(key);

Dies funktionierte in Java 8

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

Mit java.util.Arraysclass können Sie das Array T[?]in ein List<T>Objekt mit folgenden Methoden transformieren contains:

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

Abhängig davon, wie groß Ihr Array von int sein wird, erzielen Sie eine viel bessere Leistung, wenn Sie Sammlungen verwenden und .containsnicht einzeln über das Array iterieren:

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;
}
}

Lösung Nr. 1

Da die ursprüngliche Frage nur eine vereinfachte (und keine schnellere) Lösung wünscht, ist hier eine einzeilige Lösung:

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

Erläuterung: Javadoc von Arrays.toString()Zuständen, bei denen das Ergebnis in eckigen Klammern steht und benachbarte Elemente durch die Zeichen "," (ein Komma gefolgt von einem Leerzeichen) getrennt sind. Darauf können wir also zählen. Zuerst konvertieren wir arrayin eine Zeichenfolge und prüfen dann, ob keydiese Zeichenfolge enthalten ist. Natürlich können wir keine "Subnummern" akzeptieren (z. B. "1234" enthält "23"), daher müssen wir nach Mustern suchen, denen keyeine öffnende Klammer oder ein Leerzeichen vorangestellt ist, gefolgt von einer schließenden Klammer oder einem Komma.

Hinweis: Das verwendete Regexp-Muster behandelt auch negative Zahlen ordnungsgemäß (deren Zeichenfolgendarstellung mit einem Minuszeichen beginnt).

Lösung Nr. 2

Diese Lösung ist bereits veröffentlicht, enthält jedoch Fehler. Daher poste ich die richtige Lösung:

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

Auch diese Lösung hat einen Nebeneffekt: Sie modifiziert die array(sortiert sie).

Versuchen Integer.parseInt()Sie dies zu tun .....

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;

              }


     }
}