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

Tengo un String[] con valores como este:

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

Dado String s, ¿hay una buena forma de comprobar si VALUES contiene s?

preguntado el 14 de julio de 09 a las 21:07

Mucho camino alrededor, pero puede usar un bucle for: "for (String s: VALUES) if (s.equals (" MYVALUE ")) return true; -

Sí, casi me avergonzó hacer la pregunta, pero al mismo tiempo me sorprendió que no se la hubiera preguntado. Es una de esas API a las que no he estado expuesto ... -

@ camickr - Tengo una situación casi idéntica a esta: stackoverflow.com/a/223929/12943 Sigue recibiendo votos, pero es solo una copia / pegado de la documentación de sun. Supongo que la puntuación se basa en la cantidad de ayuda que proporcionaste y no en el esfuerzo que dedicaste a ella, ¡y sobre todo en la rapidez con que la publicas! ¡Quizás nos hemos topado con el secreto de John Skeet! Bueno, buena respuesta, +1 para ti. -

Si usa Apache Commons, entonces org.apache.commons.lang.ArrayUtils.contains () hace esto por ti. -

@camickr porque la gente, como yo, busca en Google una pregunta, hace clic en el resultado de SO, ve su respuesta, pruébalo, funciona, vota la respuesta y luego se va. -

29 Respuestas

Arrays.asList(yourArray).contains(yourValue)

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


Como ahora puede utilizar Streams.

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

Para comprobar si una matriz de int, double or long contiene un valor de uso IntStream, DoubleStream or LongStream respectivamente.

Ejemplo

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

Respondido 08 Oct 18, 13:10

Tengo algo de curiosidad sobre el rendimiento de esto frente a las funciones de búsqueda en la clase Arrays frente a iterar sobre una matriz y usar una función equals () o == para primitivas. - Thomas Owens

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 las primitivas debería ser mejor codificarlo usted mismo. Para Strings u otras clases, la diferencia no se notará. - Joey

Curioso, NetBeans afirma que 'Arrays.asList (vacaciones)' para un 'int [] vacaciones' devuelve una 'lista ', y no una' lista '. Solo contiene un solo elemento. Lo que significa que Contiene no funciona ya que solo tiene un elemento; la matriz int. - Nyerguds

Nyerguds: de hecho, esto no funciona para los primitivos. En Java, los tipos primitivos no pueden ser genéricos. asList se declara como Lista 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. - cromeldestructor

@Joey solo una nota al margen, es una ArrayList, Pero no java.util.ArrayList como esperaba, la clase real devuelta es: java.util.Arrays.ArrayList<E> definido como: public class java.util.Arrays {private static class ArrayList<E> ... {}}. - TWiStErRob

Actualización concisa para Java SE 9

Las matrices de referencia son malas. Para este caso buscamos un set. Desde Java SE 9 tenemos Set.of.

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

"Dadas las cadenas de caracteres, ¿hay una buena forma de probar si VALUES contiene s?"

VALUES.contains(s)

O (1).

Los programas Tipo de derecho, inmutable, O (1) y conciso. Hermosa.*

Detalles de la respuesta original

Solo para borrar el código para empezar. 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 modifique las estáticas y no permita que otro código también lo haga. Como mínimo, el campo debe ser privado:

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

(Tenga en cuenta que puede soltar el new String[]; un poco.)

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 estuviera envuelto en Collections.unmodifiableSet - incluso podría hacerse público.)

(* Para ser un poco más en la marca, la API de colecciones, como era de esperar, todavía falta tipos de colección inmutables y la sintaxis todavía es demasiado detallada, para mi gusto).

Respondido el 20 de junio de 20 a las 10:06

Excepto que es O (N) para crear la colección en primer lugar :) - Dibujó Noakes

Si es estático, probablemente se usará varias veces. Por lo tanto, el tiempo consumido para inicializar el conjunto tiene buenas posibilidades de ser bastante pequeño en comparación con el costo de muchas búsquedas lineales. - Xr.

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 - táctica

@ TomHawtin-tackline ¿Por qué dice "en particular, aquí queremos un juego"? ¿Cuál es la ventaja de un Set (HashSet) en este caso? ¿Por qué una "matriz de referencia" es mala (por "matriz de referencia" se refiere a una ArrayList respaldada por una matriz generada por una llamada a Arrays.asList)? - Albahaca bourque

@nmr un TreeSet sería O(log n). HashSetLos s se escalan de manera que el número medio de elementos en un depósito sea aproximadamente constante. Al menos para matrices de hasta 2 ^ 30. Puede haber efectos de, digamos, cachés de hardware que el análisis de big-O ignora. También asume que la función hash está funcionando de manera efectiva. - Tom Hawtin - táctica

Puedes 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 pasada 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.
}

Respondido 19 Oct 15, 21:10

@ max4ever Estoy de acuerdo, pero esto es aún mejor que "enrollar el tuyo" y más fácil de leer que el método java sin procesar. - Jason

@ 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

O simplemente puede copiar el método (y las dependencias si las hay). - Buffalo

@ 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 a rodar el suyo o copiar la fuente de apache. Y quien no use esa minimalización no necesita quejarse de 700kb o 78kb :) - Keniakorn Ketsombut

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:

Los programas v != null La condició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 array 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 de la for bucle basado en el 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;
}

Respondido el 05 de enero de 19 a las 09:01

@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 contains () en esa lista, mientras que mi solución básicamente hace lo que contiene () solo haría. - icza

@AlastorMoody e == v realiza una verificació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 la misma que afirma el método equals (), esto es lo que se verifica si las referencias no son las mismas. - icza

¿Por qué esta función no es parte de Java? No es de extrañar que la gente diga que Java está inflado ... mire todas las respuestas anteriores que usan un montón de bibliotecas cuando todo lo que necesita es un bucle for. ¡Los niños de hoy en día! - cabeza de phreak

@phreakhead Es parte de Java, ver Collection.contains(Object) - steve kuo

@icza Si miras la fuente de Arrays y ArrayList resulta que esto no es necesariamente más rápido que la versión que usa Arrays.asList(...).contains(...). Sobrecarga de crear un ArrayList es extremadamente pequeño, y ArrayList.contains() usa un bucle más inteligente (en realidad, usa dos bucles diferentes) que el que se muestra arriba (JDK 7). - Axel

Cuatro formas diferentes de comprobar si una matriz contiene un valor

  1. Usar List:

    public static boolean useList(String[] arr, String targetValue) {
        return Arrays.asList(arr).contains(targetValue);
    }
    
  2. Usar 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. Usar Arrays.binarySearch():

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

    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

Respondido el 17 de junio de 20 a las 08:06

su ejemplo de búsqueda binaria debería devolver un> 0; - Will Sherwood

¿Por qué? Creo que debería devolver un> -1, ya que 0 indicaría que está contenido en el encabezado de la matriz. - mbajo

La primera variante con (a >= 0) era correcto, solo revisa los docs, 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 con String y no con int? existe un booleano estático (int [] ints, int k) {return Arrays.asList (ints) .contains (k); } - willians martins

Si la matriz no está ordenada, tendrá que 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 el Matrices clase.

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

Respondido 14 Jul 14, 16:07

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

@Thomas: Estoy de acuerdo. O simplemente puede agregar todo en un TreeSet; misma complejidad. Usaría las matrices si no cambia (tal vez guarde un poco de localidad de memoria ya que las referencias están ubicadas contiguas aunque las cadenas no lo están). Usaría el conjunto si esto cambiara con el tiempo. - Uri

Por lo que vale, realicé una prueba comparando las 3 sugerencias de velocidad. Genere números 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().

Cuando se usa un tamaño de matriz de 10K, los resultados fueron:

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

Al usar una matriz de 100 K, 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, la asList().contains sería el camino a seguir. Si tiene muchas búsquedas, puede que valga la pena ordenar la matriz para poder utilizar 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));
    }
}

Respondido 02 Abr '19, 19:04

No entiendo este código. Ordena la matriz 'cadenas' y usa la misma matriz (ordenada) en ambas llamadas a binarySearch. ¿Cómo puede eso mostrar algo excepto la optimización del tiempo de ejecución de HotSpot? Lo mismo con la llamada asList.contains. Usted crea una lista a partir de la matriz ordenada y luego la contiene con el valor más alto. Por supuesto que llevará tiempo. ¿Cuál es el significado de esta prueba? Por no hablar de 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 utilizar la búsqueda binaria. - Erik

Es posible que la ordenación ya se haya realizado por otras razones, por ejemplo, se podría ordenar en init y nunca cambiar. Es útil probar el tiempo de búsqueda por sí solo. Sin embargo, donde esto fracasa es en ser un ejemplo menos que estelar de microbenchmarking. Los microbenchmarks son notoriamente difíciles de hacer bien en Java y deberían incluir, por ejemplo, ejecutar el 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 ejemplo - thor84no

Esta prueba tiene fallas ya que ejecuta las 3 pruebas en el mismo Instancia de JVM. Las últimas pruebas podrían beneficiarse de que las anteriores calentaran el caché, JIT, etc. steve kuo

Esta prueba en realidad no tiene ninguna relación. Sort & Search es de complejidad lineal (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. - arrastrar

En lugar de usar también la sintaxis de inicialización rápida de matriz, puede simplemente inicializarla como una Lista 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");

Respondido el 05 de enero de 19 a las 09:01

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

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

O como método genérico:

public static <T> boolean arrayContains(T[] array, T value) {
    return Arrays.stream(array).anyMatch(value::equals);
}

respondido 13 mar '14, 15:03

Vale la pena señalar también las especializaciones primitivas. - esquí

Para agregar también, anyMatch JavaDoc afirma que "...May not evaluate the predicate on all elements if not necessary for determining the result.", por lo que es posible que no sea necesario seguir procesando después de encontrar una coincidencia. - mkobit

Puede utilizar el Clase de matrices 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 buscar en ella.

Respondido el 23 de junio de 17 a las 20:06

Puede usar las funciones de clasificación en la misma clase para lograr eso ... Debería agregar eso a mi respuesta. - Thomas Owens

Probablemente costará más que el enfoque asList (). Contains (), entonces, creo. A menos que necesite hacer esa verificación con mucha frecuencia (pero si es solo una lista estática de valores que se pueden ordenar para empezar, para ser justos). - Joey

Cierto. Hay muchas variables en cuanto a cuál sería la más efectiva. Sin embargo, es bueno tener opciones. - Thomas Owens

Algún código que hace esto aquí: stackoverflow.com/a/48242328/9131078 - OOBalance

Ordenar una matriz completa con el propósito de una búsqueda es costoso. Podemos usar el mismo tiempo de CPU para la búsqueda de líneas en sí. Prefiero la búsqueda binaria en una colección que ya está construida en orden ordenado de antemano. - arunwithasmile

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

Respondido 15 Jul 09, 02:07

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.

En realidad, si usa HashSet como 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 preclasificada, probablemente incluso más rápida.

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

En una sin clasificar formación:

  1. HashSet
  2. comoLista
  3. ordenar y binario

En una matriz ordenada:

  1. HashSet
  2. Binario
  3. comoLista

Entonces, de cualquier manera, HashSet para la victoria.

Respondido el 05 de enero de 19 a las 09:01

La membresía de HashSet debe ser O (1) y la búsqueda binaria en una colección ordenada es O (log n). - skylar salvar la tierra

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

Respondido el 19 de Septiembre de 12 a las 15:09

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

Respondido el 08 de enero de 18 a las 03:01

Los desarrolladores suelen hacer:

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 configurarla primero. Convertir una lista en un conjunto requiere más tiempo. Puede ser tan simple como:

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

or

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

return false;

El primero es más legible que el segundo.

Respondido el 25 de junio de 14 a las 08:06

In Java 8 utilizar 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);

Respondido 28 Abr '15, 07:04

¿Hay ventajas con este enfoque? - johannes stadler

No responde a la pregunta. - Florian F

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

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

Cortesía de programacreek

Respondido 07 Abr '14, 20:04

Esto arrojará una excepción de puntero nulo si la matriz contiene una referencia nula antes del valor objetivo. - Samuel Edwin Ward

la instrucción if debería ser: if (targetValue.equals (s)) porque String equals tiene una instancia de verificador. - El Arconte

use Objects.equals (obj1, obj2) en su lugar para ser nulo seguro. - trilogía

  1. Para matrices de longitud limitada, utilice lo siguiente (como se indica en camickr). Esto es lento para comprobaciones repetidas, especialmente para matrices más largas (búsqueda lineal).

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

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

    • Si los elementos implementan Comparable & quiere que el TreeSet ordenados en consecuencia:

      ElementClass.compareTo() El método debe ser compatible con ElementClass.equals(): ver ¿Las tríadas no se presentan a pelear? (Al conjunto de Java le 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: comprobar la existencia de algún elemento:

      // Fast binary search through sorted elements (performance ~ log(size)):
      boolean containsElement = myElements.exists(someElement);
      

contestado el 23 de mayo de 17 a las 13:05

¿Por qué molestarse con TreeSet? HashSet es más rápido (O (1)) y no requiere pedido. - Sean Owen

Utilice lo siguiente (el contains() el método es 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, existen otros métodos de utilidad ObjectUtils.equals() y ArrayUtils.indexOf(), que también se utilizaron en otros lugares.

Respondido el 05 de enero de 19 a las 09:01

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 que ya se publicaron aquí, estoy publicando esa solución que usé en ese momento, por aquí, en caso de que alguien lo encuentre útil. - Abhishek Oza

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

Respondido el 08 de enero de 18 a las 03:01

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

Respondido el 08 de enero de 18 a las 03:01

Esto no funciona, entrará en el else por cada elemento que no coincide (por lo que si está buscando "AB" en esa matriz, irá allí 3 veces, ya que 3 de los valores no son "AB"). - Bernardo Barker

Arrays.asList () -> entonces llamar al método contains () siempre funcionará, pero un algoritmo de búsqueda es mucho mejor ya que no necesita crear un contenedor 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.
}

Respondido el 18 de Septiembre de 18 a las 00:09

Arrays.asList no es O (n). Es solo una envoltura liviana. Eche un vistazo a la implementación. - Patricio Parker

Si no quiere que distinga entre mayúsculas y minúsculas

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);

Respondido el 21 de Septiembre de 18 a las 18:09

Utilice las 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

Respondido 24 Feb 19, 20:02

Array.BinarySearch y Array.FindIndex son métodos .NET y no existen en Java. - ataylor

@ataylor hay Arrays.binarySearch en java. Pero tienes razón, no Arrays.findIndex - mente

Se debería notar: The array must be sorted prior to making this call. If it is not sorted, the results are undefined. - Dorian Gray

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

contestado el 17 de mayo de 18 a las 20:05

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

He aquí 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

Respondido 13 Oct 19, 07:10

Como estoy tratando con Java de bajo nivel usando tipos primitivos byte y byte [], lo mejor que obtuve hasta ahora es de bytes-java https://github.com/patrickfav/bytes-java parece un buen trabajo

Respondido 26 Feb 20, 08:02

la solución más corta si mi matriz contiene duplicados
desde Java 9

List.of(VALUES).contains(s);

respondido 06 mar '21, 06:03

Puedes comprobarlo por dos métodos

A) Al convertir la matriz en una cadena y luego verificar la cadena requerida mediante 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));  

    }

Respondido el 23 de Septiembre de 19 a las 23:09

La conversión de cadenas es absurdamente ineficiente y la solución es incorrecta, por ejemplo, contiene (",") devolverá verdadero. - Atuos

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.