Java, vereenvoudigde controle of int-array int bevat

Mijn maat heeft eigenlijk gezegd dat ik mijn code korter kon maken door een andere manier te gebruiken om te controleren of een int-array een int bevat, hoewel hij me niet wil vertellen wat het is :P.

Huidige:

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

Heb dit ook geprobeerd, hoewel het om de een of andere reden altijd false retourneert.

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

Kan iemand me helpen?

Bedankt.

Antwoord 1, autoriteit 100%

Hier is Java 8-oplossing

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

Antwoord 2, autoriteit 94%

Je kunt gewoon ArrayUtils.containsvan Apache Commons Lang library.

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

Antwoord 3, autoriteit 70%

Het is omdat Arrays.asList(array)List<int[]>retourneert. Het argument arraywordt behandeld als een waarde die u wilt omwikkelen (u krijgt een lijst met arrays van ints), niet als vararg.

Merk op dat het werktmet objecttypen (geen primitieven):

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

of zelfs:

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

Maar u kunt geen List<int>gebruiken en autoboxing werkt hier niet.

Antwoord 4, autoriteit 40%

Guava biedt aanvullende methoden voor primitieve typen. Onder hen een bevat methode die dezelfde argumenten als de jouwe heeft.

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

Je kunt net zo goed de guaveversie statisch importeren.

Zie Guava Primitives Explained

Antwoord 5, autoriteit 38%

Een andere manier:

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

Dit wijzigt de doorgegeven array. Je zou de mogelijkheid hebben om de array te kopiëren en aan de originele array te werken, d.w.z. int[] sorted = array.clone();
Maar dit is slechts een voorbeeld van korte code. De runtime is O(NlogN)terwijl jouw manier is O(N)

Antwoord 6, autoriteit 34%

Ik weet dat het super laat is, maar probeer Integer[]in plaats van int[].

Antwoord 7, Autoriteit 4%

U kunt uw primitieve INT-array converteren in een arrayclist met gehele getallen die onder Java 8-code gebruiken,

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

en gebruik vervolgens contains()-methode om te controleren of de lijst een bepaald element bevat,

boolean containsElement = arrayElementsList.contains(key);

Antwoord 8, Autoriteit 2%

1.Un-off gebruikt

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

2.Gebruik hashset voor prestatieoverweging Als u meer dan één keer gebruikt.

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

Antwoord 9, Autoriteit 2%

Probeer dit:

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

Antwoord 10

Dit werkte in Java 8

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

Antwoord 11

U kunt de klasse java.util.Arraysgebruiken om de array T[?]te transformeren in een List<T>-object met methoden zoals contains:

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

Antwoord 12

private static void solutions() {
    int[] A = { 1, 5, 10, 20, 40, 80 };
    int[] B = { 6, 7, 20, 80, 100 };
    int[] C = { 3, 4, 15, 20, 30, 70, 80, 120 };
    List<Integer> aList = Arrays.stream(A).boxed().collect(Collectors.toList());
    List<Integer> cList = Arrays.stream(C).boxed().collect(Collectors.toList());
    String s = "";
    for (Integer a : C) {
        if (aList.contains(a) && cList.contains(a)) {
            s = s.concat(String.valueOf(a)).concat("->");
        }
    }
}

Antwoord 13

Afhankelijk van hoe groot uw array van int zal zijn, krijgt u veel betere prestaties als u collecties en .containsgebruikt in plaats van de array één voor één te herhalen:

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

Antwoord 14

Probeer Integer.parseInt()om dit te doen…..

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