¿Cómo determino si una matriz contiene un valor particular en Java?

2279

Tengo un String[]con valores como este:

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

Dado String s, ¿hay una buena manera de probar si VALUEScontiene s?

Mike Sickler
fuente
55
Un largo camino alrededor, pero puede usar un bucle for: "for (String s: VALUES) if (s.equals (" MYVALUE ")) return true;
Zack
70
@camickr. A su pregunta, voté por esta pregunta y su respuesta -ahora- porque me ahorró 30 minutos y 20 líneas de escritura de código feo para bucles, -ahora-. No lo leí hace tres años. (Por cierto, gracias :))
Persecución del
3
@ camickr - Tengo una situación casi idéntica con esta: stackoverflow.com/a/223929/12943 Sigue obteniendo votos pero fue solo una copia / pegado de la documentación de Sun. Supongo que el puntaje se basa en la cantidad de ayuda que prestaste y no en el esfuerzo que le pusiste, ¡y principalmente en lo rápido que lo publicas! ¡Quizás nos hemos topado con el secreto de John Skeet! Bueno, buena respuesta, +1 para ti.
Bill K
1
Si está utilizando Apache Commons, entonces org.apache.commons.lang.ArrayUtils.contains () hace esto por usted.
Sr. Boy
34
@camickr porque la gente, como yo, busca en Google una pregunta, hace clic en el resultado SO, ve su respuesta, la prueba, funciona, vota la respuesta y luego se va.
Aequitas

Respuestas:

2925
Arrays.asList(yourArray).contains(yourValue)

Advertencia: esto no funciona para matrices de primitivas (ver los comentarios).


Ya que ahora puedes usar Streams.

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

Para verificar si una matriz de int, doubleo longcontiene un valor IntStream, use , DoubleStreamo LongStreamrespectivamente.

Ejemplo

int[] a = {1,2,3,4};
boolean contains = IntStream.of(a).anyMatch(x -> x == 4);
camickr
fuente
87
Tengo un poco de curiosidad sobre el rendimiento de esto frente a las funciones de búsqueda en la clase Arrays versus iterar sobre una matriz y usar una función equals () o == para primitivas.
Thomas Owens el
186
No pierde mucho, ya que asList () devuelve una ArrayList que tiene una matriz en su corazón. El constructor simplemente cambiará una referencia, por lo que no hay mucho trabajo por hacer allí. Y contiene () / indexOf () iterará y usará equals (). Sin embargo, para los primitivos deberías codificarlo tú mismo. Para cadenas u otras clases, la diferencia no será notable.
Joey el
18
Extraño, NetBeans afirma que 'Arrays.asList (holidays)' para un 'int [] holidays' devuelve una 'list <int []>', y no una 'list <int>'. Solo contiene un único elemento. Lo que significa que el contenido no funciona ya que solo tiene un elemento; la matriz int.
Nyerguds el
6262
Nyerguds: de hecho, esto no funciona para los primitivos. En java, los tipos primitivos no pueden ser genéricos. asList se declara como <T> List <T> asList (T ...). Cuando le pasa un int [], el compilador infiere T = int [] porque no puede inferir T = int, porque las primitivas no pueden ser genéricas.
CromTheDestroyer
28
@Joey sólo una nota al margen, que es una ArrayList, pero no java.util.ArrayListcomo se esperaba, la clase real, se volvió: java.util.Arrays.ArrayList<E>definida como: public class java.util.Arrays {private static class ArrayList<E> ... {}}.
TWiStErRob
363

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

Solo para borrar el código para empezar. Tenemos (corregido):

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

Esta es una estática mutable que FindBugs le dirá que es muy traviesa. No modifique las estadísticas y no permita que otros códigos también lo hagan. Como mínimo absoluto, el campo debe ser privado:

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

(Nota, en realidad puedes soltar el 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 a gusto si esto se envuelve 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 no tenga tipos de colección inmutables y la sintaxis sigue siendo demasiado detallada, para mis gustos).

Tom Hawtin - tackline
fuente
184
Excepto que es O (N) para crear la colección en primer lugar :)
Drew Noakes
61
Si es estático, probablemente se usará varias veces. Por lo tanto, el tiempo que se tarda en inicializar el conjunto tiene buenas posibilidades de ser bastante pequeño en comparación con el costo de muchas búsquedas lineales.
Xr.
1
La creación de la colección estará dominada por el tiempo de carga del código (que técnicamente es O (n) pero prácticamente constante).
Tom Hawtin - tackline
2
@ TomHawtin-tackline ¿Por qué dices "en particular aquí queremos un set"? ¿Cuál es la ventaja de un Set (HashSet) en este caso? ¿Por qué un "conjunto de referencia" es malo (por "conjunto de referencia" quiere decir un ArrayList respaldado por un conjunto generado por una llamada a Arrays.asList)?
Basil Bourque
66
@nmr A TreeSetlo sería O(log n). HashSets se escalan de tal manera que el número medio de elementos en un cubo es aproximadamente constante. Al menos para matrices de hasta 2 ^ 30. Puede haber efectos de, por ejemplo, cachés de hardware que el análisis big-O ignora. También supone que la función hash está funcionando de manera efectiva.
Tom Hawtin - tackline
206

Puedes usar ArrayUtils.containsdesde Apache Commons Lang

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

Tenga en cuenta que este método se devuelve falsesi la matriz aprobada es null.

También hay métodos disponibles para matrices primitivas de todo tipo.

Ejemplo:

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

if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}
Intracer
fuente
44
@ max4ever Estoy de acuerdo, pero esto es aún mejor que "rodar el tuyo" y más fácil de leer que el modo Java puro.
Jason
2
paquete: org.apache.commons.lang.ArrayUtils
slamborne
38
@ max4ever A veces ya tienes esta biblioteca incluida (por otras razones) y es una respuesta perfectamente válida. Estaba buscando esto y ya dependo de Apache Commons Lang. Gracias por esta respuesta
GuiSim
1
O simplemente podría copiar el método (y las dependencias si las hay).
Buffalo
10
@ max4ever La mayoría de las aplicaciones de Android están minimizadas por Proguard, poniendo solo las clases y funciones que necesita en su aplicación. Eso hace que sea igual rodar el tuyo o copiar la fuente de la cosa apache. Y quien no use esa minimización no necesita quejarse de 700kb o 78kb :)
Kenyakorn Ketsombut
158

Simplemente impleméntelo 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;
}

Mejora:

La v != nullcondición es constante dentro del método. Siempre se evalúa con el mismo valor booleano durante la llamada al método. Entonces, si la entrada arrayes 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 forciclo en función del resultado. El contains()método mejorado :

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;
}
icza
fuente
99
@Phoexo Esta solución es obviamente más rápida porque la respuesta aceptada envuelve la matriz en una lista y llama al método contiene () en esa lista, mientras que mi solución básicamente hace lo que solo contiene ().
icza
10
@AlastorMoody e == v realiza una comprobación de igualdad de referencia que es muy rápida. Si el mismo objeto (el mismo por referencia) está en la matriz, se encontrará más rápido. Si no es la misma instancia, aún podría ser el mismo que el método equals (), esto es lo que se verifica si las referencias no son las mismas.
icza
20
¿Por qué esta función no es parte de Java? No es de extrañar que la gente diga que Java está hinchado ... mira todas las respuestas anteriores que usan un montón de bibliotecas cuando todo lo que necesitas es un bucle for. ¡Los niños de hoy en día!
phreakhead
44
@phreakhead Es parte de Java, veaCollection.contains(Object)
Steve Kuo
11
@icza Si nos fijamos en la fuente Arraysy ArrayListresulta que esto no es necesariamente más rápido que la versión que usa Arrays.asList(...).contains(...). La sobrecarga de crear una ArrayListes extremadamente pequeña y ArrayList.contains()utiliza un bucle más inteligente (en realidad usa dos bucles diferentes) que el que se muestra arriba (JDK 7).
Axel
72

Cuatro formas diferentes de verificar si una matriz contiene un valor

1) Uso de la lista:

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 bucle simple:

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) {  
            int a = Arrays.binarySearch(arr, targetValue);
            return a > 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
Sireesh Yarlagadda
fuente
55
su ejemplo de búsqueda binaria debería devolver a> 0;
Will Sherwood
66
¿Por qué? Creo que debería devolver un> -1, ya que 0 indicaría que está contenido en la cabecera de la matriz.
mbelow
1
La primera variante con (a >= 0)era correcta, solo verifique los documentos , dicen "Tenga en cuenta que esto garantiza que el valor de retorno será> = 0 si y solo si se encuentra la clave".
Yoory N.
¿Por qué funciona para String y no para int? existe boolean estático (int [] ints, int k) {return Arrays.asList (ints) .contains (k); }
Willians Martins
71

Si la matriz no está ordenada, deberá iterar sobre todo y hacer una llamada a iguales en cada uno.

Si la matriz está ordenada, puede hacer una búsqueda binaria, hay una en la clase Arrays .

En términos generales, si va a hacer muchas comprobaciones de membresía, es posible que desee almacenar todo en un Conjunto, no en una matriz.

Uri
fuente
1
Además, como dije en mi respuesta, si usa la clase Arrays, puede ordenar la matriz y luego realizar la búsqueda binaria en la matriz recién ordenada.
Thomas Owens el
1
@Thomas: estoy de acuerdo. O simplemente puede agregar todo a un TreeSet; misma complejidad Usaría las matrices si no cambia (tal vez ahorre un poco de localidad de memoria ya que las referencias se encuentran contiguas aunque las cadenas no lo están). Usaría el conjunto si esto cambiara con el tiempo.
Uri el
49

Por lo que vale, realicé una prueba comparando las 3 sugerencias de velocidad. Generé enteros aleatorios, los convertí en una cadena y los agregué a una matriz. Luego busqué el número / cadena más alto posible, que sería el peor de los casos para el asList().contains().

Al usar un tamaño de matriz de 10K, los resultados fueron:

Ordenar y buscar: 15
Búsqueda binaria: 0
asList.contains: 0

Cuando se usa una matriz de 100K, los resultados fueron:

Ordenar y buscar: 156
Búsqueda binaria: 0
asList.contains: 32

Entonces, si la matriz se crea en orden ordenado, la búsqueda binaria es la más rápida, de lo contrario, este asList().containssería el camino a seguir. Si tiene muchas búsquedas, puede valer la pena ordenar la matriz para que pueda usar la búsqueda binaria. Todo depende de tu aplicación.

Creo que esos son los resultados que la mayoría de la gente esperaría. Aquí está el código de prueba:

import java.util.*;

public class Test
{
    public static void main(String args[])
    {
        long start = 0;
        int size = 100000;
        String[] strings = new String[size];
        Random random = new Random();


        for (int i = 0; i < size; i++)
            strings[i] = "" + random.nextInt( size );

        start = System.currentTimeMillis();
        Arrays.sort(strings);
        System.out.println(Arrays.binarySearch(strings, "" + (size - 1) ));
        System.out.println("Sort & Search : " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        System.out.println(Arrays.binarySearch(strings, "" + (size - 1) ));
        System.out.println("Search        : " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        System.out.println(Arrays.asList(strings).contains( "" + (size - 1) ));
        System.out.println("Contains      : " + (System.currentTimeMillis() - start));
    }
}
camickr
fuente
66
No entiendo este código. Ordena las 'cadenas' de la matriz y usa la misma matriz (ordenada) en ambas llamadas a binarySearch. ¿Cómo puede eso mostrar algo más que la optimización del tiempo de ejecución de HotSpot? Lo mismo con la llamada asList.contains. Crea una lista a partir de la matriz ordenada y luego contiene en ella el valor más alto. Por supuesto que llevará tiempo. ¿Cuál es el significado de esta prueba? Sin mencionar ser un microbenchmark incorrectamente escrito
Erik
Además, dado que la búsqueda binaria solo se puede aplicar a un conjunto ordenado, ordenar y buscar es la única forma posible de usar la búsqueda binaria.
Erik
Es posible que la clasificación ya se haya realizado por varias otras razones, por ejemplo, podría clasificarse en init y nunca cambiarse. Es útil para probar el tiempo de búsqueda por sí solo. Sin embargo, cuando esto cae es en ser un ejemplo menos que estelar de microbenchmarking. Las microbenchmarks son notoriamente difíciles de acertar en Java y, por ejemplo, deben incluir la ejecución del código de prueba lo suficiente como para obtener la optimización del punto de acceso antes de ejecutar la prueba real, y mucho menos ejecutar el código de prueba real más de UNA VEZ con un temporizador.
Errores de
77
Esta prueba es defectuosa ya que ejecuta las 3 pruebas en la misma instancia de JVM. Las pruebas posteriores podrían beneficiarse de las anteriores calentando el caché, JIT, etc.
Steve Kuo
44
Esta prueba en realidad no tiene ninguna relación. Sort & Search es una complejidad linearithmic (n * log (n)), la búsqueda binaria es logarítmica y ArrayUtils.contains es obviamente lineal. No sirve de nada comparar estas soluciones, ya que se encuentran en clases de complejidad totalmente diferentes.
Dragn
37

En lugar de utilizar también la sintaxis de inicialización de matriz rápida, puede inicializarla como una Lista directamente de manera similar utilizando el método Arrays.asList, por ejemplo:

public static final List<String> STRINGS = Arrays.asList("firstString", "secondString" ...., "lastString");

Entonces puedes hacer (como arriba):

STRINGS.contains("the string you want to find");
Mark Rhodes
fuente
36

Con Java 8 puede crear una secuencia y verificar si alguna entrada en la secuencia coincide "s":

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

O como un método genérico:

public static <T> boolean arrayContains(T[] array, T value) {
    return Arrays.stream(array).anyMatch(value::equals);
}
asilias
fuente
3
Vale la pena señalar también las especializaciones primitivas.
skiwi
Para agregar también, anyMatchJavaDoc lo indica "...May not evaluate the predicate on all elements if not necessary for determining the result.", por lo que es posible que no necesite continuar el procesamiento después de encontrar una coincidencia.
mkobit
28

Puede usar la clase Arrays para realizar una búsqueda binaria del valor. Si su matriz no está ordenada, tendrá que usar las funciones de clasificación en la misma clase para ordenar la matriz y luego buscarla.

Thomas Owens
fuente
Puede usar las funciones de clasificación en la misma clase para lograr eso ... Debo agregar eso a mi respuesta.
Thomas Owens el
1
Probablemente costará más que el enfoque asList (). Contiene (), entonces, creo. A menos que necesite hacer esa verificación con mucha frecuencia (pero para ser justos, si es solo una lista estática de valores que se pueden ordenar para empezar).
Joey el
Cierto. Hay muchas variables sobre cuál sería la más efectiva. Sin embargo, es bueno tener opciones.
Thomas Owens el
Algún código que hace esto aquí: stackoverflow.com/a/48242328/9131078
OOBalance
Ordenar una matriz completa para una búsqueda es costoso. Podemos usar el mismo tiempo de CPU para la búsqueda de línea. Prefiero la búsqueda binaria en una colección que ya está construida en orden de antemano.
arunwithasmile
17

ObStupidAnswer (pero creo que hay una lección aquí en alguna parte):

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}
Tom Hawtin - tackline
fuente
1
El lanzamiento de excepciones es aparentemente pesado, pero esta sería una forma novedosa de probar un valor si funciona. La desventaja es que la enumeración debe definirse de antemano.
James P.
13

En realidad, si usa HashSet <String> como lo propuso Tom Hawtin, no necesita preocuparse por la clasificación, y su velocidad es la misma que con la búsqueda binaria en una matriz preseleccionada, probablemente incluso más rápido.

Todo depende de cómo esté configurado su código, obviamente, pero desde mi punto de vista, el orden sería:

En una matriz sin clasificar :

  1. HashSet
  2. asList
  3. ordenar y binario

En una matriz ordenada:

  1. HashSet
  2. Binario
  3. asList

De cualquier manera, HashSet para la victoria.

no
fuente
2
La membresía de HashSet debe ser O (1) y la búsqueda binaria en una colección ordenada es O (log n).
Skylar Saveland
11

Si tiene la biblioteca de colecciones de Google, la respuesta de Tom se puede simplificar mucho usando ImmutableSet (http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableSet.html)

Esto realmente elimina mucho desorden de la inicialización propuesta

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

Una posible solución:

import java.util.Arrays;
import java.util.List;

public class ArrayContainsElement {
  public static final List<String> VALUES = Arrays.asList("AB", "BC", "CD", "AE");

  public static void main(String args[]) {

      if (VALUES.contains("AB")) {
          System.out.println("Contains");
      } else {
          System.out.println("Not contains");
      }
  }
}
Christian Giménez
fuente
8

Los desarrolladores a menudo hacen:

Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);

El código anterior funciona, pero no es necesario convertir una lista para establecer primero. La conversión de una lista a un conjunto requiere tiempo adicional. Puede ser tan simple como:

Arrays.asList(arr).contains(targetValue);

o

   for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }

return false;

El primero es más legible que el segundo.

Jawad Zeb
fuente
7

Usar un bucle simple es la forma más eficiente de hacerlo.

boolean useLoop(String[] arr, String targetValue) {
    for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }
    return false;
}

Cortesía de Programcreek.

Ryan
fuente
Esto arrojará una excepción de puntero nulo si la matriz contiene una referencia nula antes del valor objetivo.
Samuel Edwin Ward,
1
la instrucción if debería ser: if (targetValue.equals (s)) porque String equals tiene una instancia de corrector.
TheArchon
use Objects.equals (obj1, obj2) en lugar de ser nulo seguro.
trilogía el
7

En Java 8 use Streams.

List<String> myList =
Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList
.stream()
.filter(s -> s.startsWith("c"))
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);
Brillo Basheer
fuente
77
¿Hay alguna ventaja con este enfoque?
Johannes Stadler
1
No responde la pregunta.
Florian F
5
  1. Para matrices de longitud limitada, use lo siguiente (como lo proporciona camickr ). Esto es lento para verificaciones repetidas, especialmente para matrices más largas (búsqueda lineal).

     Arrays.asList(...).contains(...)
  2. Para un rendimiento rápido si verifica repetidamente contra un conjunto de elementos más grande

    • Una matriz es la estructura incorrecta. Use ay TreeSetagregue cada elemento. Ordena elementos y tiene un exist()método rápido (búsqueda binaria).

    • Si los elementos se implementan Comparabley desea TreeSetordenarlos en consecuencia:

      ElementClass.compareTo()El método debe ser compatible con ElementClass.equals(): ¿Ver Tríadas que no aparecen para luchar? (Java Set falta un elemento)

      TreeSet myElements = new TreeSet();
      
      // Do this for each element (implementing *Comparable*)
      myElements.add(nextElement);
      
      // *Alternatively*, if an array is forceably provided from other code:
      myElements.addAll(Arrays.asList(myArray));
    • De lo contrario, use el suyo Comparator:

      class MyComparator implements Comparator<ElementClass> {
           int compareTo(ElementClass element1; ElementClass element2) {
                // Your comparison of elements
                // Should be consistent with object equality
           }
      
           boolean equals(Object otherComparator) {
                // Your equality of comparators
           }
      }
      
      
      // construct TreeSet with the comparator
      TreeSet myElements = new TreeSet(new MyComparator());
      
      // Do this for each element (implementing *Comparable*)
      myElements.add(nextElement);
    • La recompensa: verificar la existencia de algún elemento:

      // Fast binary search through sorted elements (performance ~ log(size)):
      boolean containsElement = myElements.exists(someElement);
Glen Best
fuente
44
¿Por qué molestarse con TreeSet? HashSetes más rápido (O (1)) y no requiere orden.
Sean Owen
4

Prueba esto:

ArrayList<Integer> arrlist = new ArrayList<Integer>(8);

// use add() method to add elements in the list
arrlist.add(20);
arrlist.add(25);
arrlist.add(10);
arrlist.add(15);

boolean retval = arrlist.contains(10);
if (retval == true) {
    System.out.println("10 is contained in the list");
}
else {
    System.out.println("10 is not contained in the list");
}
Mr.G
fuente
4

Use lo siguiente (el contains()método está ArrayUtils.in()en este código):

ObjectUtils.java

public class ObjectUtils{

    /**
     * A null safe method to detect if two objects are equal.
     * @param object1
     * @param object2
     * @return true if either both objects are null, or equal, else returns false.
     */
    public static boolean equals(Object object1, Object object2){
        return object1==null ? object2==null : object1.equals(object2);
    }

}

ArrayUtils.java

public class ArrayUtils{

    /**
     * Find the index of of an object is in given array, starting from given inclusive index.
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @param start  The index from where the search must start.
     * @return Index of the given object in the array if it is there, else -1.
     */
    public static <T> int indexOf(final T[] ts, final T t, int start){
        for(int i = start; i < ts.length; ++i)
            if(ObjectUtils.equals(ts[i], t))
                return i;
        return -1;
    }

    /**
     * Find the index of of an object is in given array, starting from 0;
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @return  indexOf(ts, t, 0)
     */
    public static <T> int indexOf(final T[] ts, final T t){
        return indexOf(ts, t, 0);
    }

    /**
     * Detect if the given object is in the given array.
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @return  If indexOf(ts, t) is greater than -1.
     */
    public static <T> boolean in(final T[] ts, final T t){
        return indexOf(ts, t) > -1 ;
    }

}

Como puede ver en el código anterior, hay otros métodos de utilidad ObjectUtils.equals()y ArrayUtils.indexOf()que también se usaron en otros lugares.

Abhishek Oza
fuente
Llego muy tarde para unirme a esta discusión, pero dado que mi enfoque para resolver este problema, cuando lo enfrenté hace unos años, era un poco diferente a las otras respuestas ya publicadas aquí, estoy publicando esa solución que usé en ese momento, por aquí, en caso de que alguien lo encuentre útil.
Abhishek Oza
3

Mira esto

String[] VALUES = new String[] {"AB","BC","CD","AE"};
String s;

for(int i=0; i< VALUES.length ; i++)
{
    if ( VALUES[i].equals(s) )
    { 
        // do your stuff
    } 
    else{    
        //do your stuff
    }
}
SubbaRao Boddu
fuente
1
Esto no funciona: ingresará el elsepara cada elemento que no coincida (por lo que si está buscando "AB" en esa matriz, irá allí 3 veces, ya que 3 de los valores no son "AB" ").
Bernhard Barker
3

Arrays.asList () -> luego llamar al método contiene () siempre funcionará, pero un algoritmo de búsqueda es mucho mejor ya que no necesita crear un envoltorio de lista ligero alrededor de la matriz, que es lo que hace Arrays.asList () .

public boolean findString(String[] strings, String desired){
   for (String str : strings){
       if (desired.equals(str)) {
           return true;
       }
   }
   return false; //if we get here… there is no desired String, return false.
}
TheArchon
fuente
Arrays.asListno es O (n). Es solo una envoltura ligera. Echa un vistazo a la implementación.
Patrick Parker el
3

Si no quieres que sea sensible a mayúsculas y minúsculas

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);
Akhil babu K
fuente
2

Se usa Array.BinarySearch(array,obj)para encontrar el objeto dado en una matriz o no.

Ejemplo:

if (Array.BinarySearch(str, i) > -1)`  true --exists

falso: no existe

Vengador
fuente
44
Array.BinarySearchy Array.FindIndexson métodos .NET y no existen en Java.
ataylor
@ataylor hay Arrays.binarySearch en java. Pero tienes razón, no Arrays.findIndex
mente
Cabe señalar:The array must be sorted prior to making this call. If it is not sorted, the results are undefined.
Dorian Gray
1

Cree un booleano inicialmente establecido en falso. Ejecute un bucle para verificar cada valor en la matriz y compárelo con el valor con el que está comprobando. Si alguna vez obtiene una coincidencia, establezca boolean en true y detenga el bucle. Luego afirme que el booleano es verdadero.

mandy1339
fuente
1

Intente usar el método de prueba de predicado Java 8

Aquí hay un ejemplo completo de ello.

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Test {
 public static final List<String> VALUES = Arrays.asList("AA", "AB", "BC", "CD", "AE");

 public static void main(String args[]) {
  Predicate<String> containsLetterA = VALUES -> VALUES.contains("AB");
  for (String i : VALUES) {

   System.out.println(containsLetterA.test(i));
  } 
 }
}

http://mytechnologythought.blogspot.com/2019/10/java-8-predicate-test-method-example.html

https://github.com/VipulGulhane1/java8/blob/master/Test.java

Vipul Gulhane
fuente
0

el uso de a Spliterator previene la generación innecesaria de List

boolean found = false;  // class variable

String search = "AB";
Spliterator<String> spl = Arrays.spliterator( VALUES, 0, VALUES.length );
while( (! found) && spl.tryAdvance(o -> found = o.equals( search )) );

found == truesi searchestá contenido en la matriz


esto hace el trabajo para las matrices de primitivas

public static final int[] VALUES = new int[] {1, 2, 3, 4};
boolean found = false;  // class variable

int search = 2;
Spliterator<Integer> spl = Arrays.spliterator( VALUES, 0, VALUES.length );
Kaplan
fuente
-2

Puedes verificarlo por dos métodos

A) Al convertir la matriz en cadena y luego verificar la cadena requerida por el método .contains

 String a=Arrays.toString(VALUES);
    System.out.println(a.contains("AB"));
    System.out.println(a.contains("BC"));
    System.out.println(a.contains("CD"));
    System.out.println(a.contains("AE"));

B) este es un método más eficiente

 Scanner s=new Scanner(System.in);


   String u=s.next();
   boolean d=true;
    for(int i=0;i<VAL.length;i++)
    {
        if(VAL[i].equals(u)==d)
            System.out.println(VAL[i] +" "+u+VAL[i].equals(u));  

    }
Syed Salman Hassan
fuente
1
La conversión de cadena es absurdamente ineficiente y la solución es incorrecta, por ejemplo, contiene (",") devolverá verdadero.
Atuos