¿Cómo determino si un arreglo contiene un valor particular en Java

java arrays


Tengo una String[] con valores como este:

public static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

Dada la String s , ¿hay una buena manera de probar si VALUES contiene s ?




Answer 1 camickr


Arrays.asList(yourArray).contains(yourValue)

Advertencia:esto no funciona para los grupos de primitivos (ver los comentarios).


Desde java-8 ahora puede usar Streams.

String[] values = {"AB","BC","CD","AE"};
boolean contains = Arrays.stream(values).anyMatch("s"::equals);

Para verificar si una matriz de int , double o long contiene un valor, use IntStream , DoubleStream o LongStream respectivamente.

Example

int[] a = {1,2,3,4};
boolean contains = IntStream.of(a).anyMatch(x -> x == 4);



Answer 2 Tom Hawtin - tackline


Actualización concisa para Java SE 9

Las matrices de referencia son malas. Para este caso estamos tras un conjunto. Desde Java SE 9 tenemos Set.of .

private static final Set<String> VALUES = Set.of(
    "AB","BC","CD","AE"
);

"Dado String s, ¿hay una buena manera de probar si VALUES contiene s?"

VALUES.contains(s)

O(1).

El tipo correcto , inmutable , O (1) y conciso . Hermoso.*

Detalles de la respuesta original

Sólo para aclarar el código para empezar.Lo hemos (corregido):

public static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

Esta es una estática mutable que FindBugs te dirá que es muy traviesa.No modifiques la estática y no permitas que otro código lo haga también.Como mínimo absoluto,el campo debería ser privado:

private static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

(Tenga en cuenta que en realidad puede soltar la new String[]; bit).

Las matrices de referencia siguen siendo malas y queremos un conjunto:

private static final Set<String> VALUES = new HashSet<String>(Arrays.asList(
     new String[] {"AB","BC","CD","AE"}
));

(Las personas paranoicas, como yo, pueden sentirse más tranquilas si esto estuviera envuelto en Collections.unmodifiableSet ; incluso podría hacerse público).

(* Para ser un poco más sobre la marca, es previsible que la API de colecciones todavía falte tipos de colecciones inmutables y la sintaxis sigue siendo demasiado detallada, para mi gusto).




Answer 3 Intracer


Puede usar ArrayUtils.contains de Apache Commons Lang

public static boolean contains(Object[] array, Object objectToFind)

Tenga en cuenta que este método devuelve false si la matriz aprobada es null .

También hay métodos disponibles para conjuntos primitivos de todo tipo.

Example:

String[] fieldsToInclude = { "id", "name", "location" };

if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}



Answer 4 icza


Simplemente impleméntalo a mano:

public static <T> boolean contains(final T[] array, final T v) {
    for (final T e : array)
        if (e == v || v != null && v.equals(e))
            return true;

    return false;
}

Improvement:

La condición v != null Es constante dentro del método. Siempre se evalúa con el mismo valor booleano durante la llamada al método. Entonces, si la array entrada es grande, es más eficiente evaluar esta condición solo una vez, y podemos usar una condición simplificada / más rápida dentro del ciclo for en función del resultado. El mejorado contains() método :

public static <T> boolean contains2(final T[] array, final T v) {
    if (v == null) {
        for (final T e : array)
            if (e == null)
                return true;
    } 
    else {
        for (final T e : array)
            if (e == v || v.equals(e))
                return true;
    }

    return false;
}



Answer 5 Sireesh Yarlagadda


Cuatro maneras diferentes de comprobar si un conjunto contiene un valor

  1. Usando la List :

    public static boolean useList(String[] arr, String targetValue) {
        return Arrays.asList(arr).contains(targetValue);
    }
  2. Usando Set :

    public static boolean useSet(String[] arr, String targetValue) {
        Set<String> set = new HashSet<String>(Arrays.asList(arr));
        return set.contains(targetValue);
    }
  3. Usando un simple bucle:

    public static boolean useLoop(String[] arr, String targetValue) {
        for (String s: arr) {
            if (s.equals(targetValue))
                return true;
        }
        return false;
    }
  4. Usando Arrays.binarySearch() :

    El siguiente código es incorrecto, se enumera aquí para completar. binarySearch() SOLO se puede usar en matrices ordenadas.Encontrará que el resultado es extraño a continuación. Esta es la mejor opción cuando se ordena la matriz.

    public static boolean binarySearch(String[] arr, String targetValue) {  
        return Arrays.binarySearch(arr, targetValue) >= 0;
    }

Ejemplo rápido:

String testValue="test";
String newValueNotInList="newValue";
String[] valueArray = { "this", "is", "java" , "test" };
Arrays.asList(valueArray).contains(testValue); // returns true
Arrays.asList(valueArray).contains(newValueNotInList); // returns false