Como determino se uma matriz contém um valor específico em Java?

2278

Eu tenho um String[]com valores como este:

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

Dado String s, existe uma boa maneira de testar se VALUEScontém s?

Mike Sickler
fonte
5
Um longo caminho, mas você pode usar um loop for: "for (String s: VALUES) if (s.equals (" MYVALUE ")) retorna true;
Zack
70
@camickr. Para sua pergunta, eu votei de uma vez para esta e para a sua resposta - agora - porque me salvou 30 minutos e 20 linhas de código feias para criar loops, agora. Não o li há três anos. (BTW, obrigado :))
Prossiga
3
@ camickr - Eu tenho uma situação quase idêntica a esta: stackoverflow.com/a/223929/12943 Ele continua recebendo votos, mas foi apenas uma cópia / pasta da documentação da sun. Eu acho que a pontuação é baseada em quanta ajuda você forneceu e não em quanto esforço você coloca nela - e principalmente na rapidez com que você a publica! Talvez tenhamos tropeçado no segredo de John Skeet! Bem, boa resposta, +1 para você.
Bill K
1
Se você estiver usando o Apache Commons, org.apache.commons.lang.ArrayUtils.contains () faz isso por você.
Mr. Boy
34
@camickr porque pessoas, como eu, pesquisam no google uma pergunta, clicam no resultado do SO, veem sua resposta, testam-na, funcionam, votam na resposta e saem.
Aequitas

Respostas:

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

Aviso: isso não funciona para matrizes de primitivas (veja os comentários).


Desde a agora você pode usar o Streams.

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

Para verificar se uma matriz de int, doubleou longcontém um valor IntStream, use DoubleStreamou LongStreamrespectivamente.

Exemplo

int[] a = {1,2,3,4};
boolean contains = IntStream.of(a).anyMatch(x -> x == 4);
camickr
fonte
87
Estou um pouco curioso quanto ao desempenho disso versus as funções de pesquisa na classe Arrays versus a iteração sobre uma matriz e o uso de uma função equals () ou == para primitivas.
9119 Thomas Thomasens
186
Você não perde muito, pois asList () retorna um ArrayList que possui uma matriz no coração. O construtor mudará apenas uma referência, para que não haja muito trabalho a ser feito lá. E contains () / indexOf () iterará e usará igual a (). Para os primitivos, é melhor codificá-lo você mesmo. Para Strings ou outras classes, a diferença não será perceptível.
Joey
18
Estranho, o NetBeans afirma que 'Arrays.asList (feriados)' para um 'int [] feriados' retorna uma 'lista <int []>', e não uma 'lista <int>'. Ele contém apenas um único elemento. Significando que o Contém não funciona, pois possui apenas um elemento; a matriz int.
Nyerguds
62
Nyerguds: na verdade, isso não funciona para os primitivos. No java, os tipos primitivos não podem ser genéricos. asList é declarado como <T> List <T> asList (T ...). Quando você passa um int [] para ele, o compilador deduz T = int [] porque não pode inferir T = int, porque os primitivos não podem ser genéricos.
CromTheDestroyer
28
@Joey apenas uma nota lateral, é uma ArrayList, mas não java.util.ArrayListcomo você espera, a classe verdadeira retornado é: java.util.Arrays.ArrayList<E>definido como: public class java.util.Arrays {private static class ArrayList<E> ... {}}.
TWIStErRob 17/10/12
363

Atualização concisa para Java SE 9

Matrizes de referência são ruins. Para este caso, estamos atrás de um conjunto. Desde o Java SE 9, temos Set.of.

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

"Dada a string s, existe uma boa maneira de testar se VALUES contém s?"

VALUES.contains(s)

O (1)

O tipo certo , imutável , O (1) e conciso . Bonita.*

Detalhes da resposta original

Apenas para limpar o código, para começar. Temos (corrigido):

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

Esta é uma estática mutável que o FindBugs lhe dirá que é muito travessa. Não modifique a estática e não permita que outro código faça isso também. No mínimo absoluto, o campo deve ser privado:

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

(Observe, você pode realmente diminuir o new String[];bit.)

Matrizes de referência ainda estão ruins e queremos um conjunto:

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

(Pessoas paranóicas, como eu, podem se sentir mais à vontade se isso estiver envolvido Collections.unmodifiableSet- pode até ser tornado público.)

(* Para ser um pouco mais sobre a marca, a API de coleções ainda previsivelmente está faltando tipos de coleções imutáveis ​​e a sintaxe ainda é muito detalhada, para o meu gosto.)

Tom Hawtin - linha de orientação
fonte
184
A não ser que de O (N) para criar o conjunto em primeiro lugar :)
Desenhou Noakes
61
Se for estático, provavelmente será usado algumas vezes. Portanto, o tempo consumido para inicializar o conjunto tem boas chances de ser bem pequeno comparado ao custo de muitas pesquisas lineares.
Xr.
1
Ao criar, a coleção será dominada pelo tempo de carregamento do código (que é tecnicamente O (n), mas praticamente constante).
Tom Hawtin - defina
2
@ TomHawtin-tackline Por que você diz "em particular aqui queremos um conjunto"? Qual é a vantagem de um conjunto (HashSet) nesse caso? Por que um "array de referência" é ruim (por "array de referência", você quer dizer um ArrayList apoiado por um array conforme gerado por uma chamada para Arrays.asList)?
Basil Bourque
6
@nmr A TreeSetseria O(log n). HashSets são dimensionados de forma que o número médio de elementos em um balde seja aproximadamente constante. Pelo menos para matrizes de até 2 ^ 30. Pode haver efeitos de, digamos, caches de hardware que a análise big-O ignora. Também assume que a função hash está funcionando efetivamente.
Tom Hawtin - defina
206

Você pode usar ArrayUtils.containsa partir de Apache Commons Lang

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

Observe que esse método retorna falsese a matriz passada for null.

Também existem métodos disponíveis para matrizes primitivas de todos os tipos.

Exemplo:

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

if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}
Intracer
fonte
4
@ max4ever Eu concordo, mas isso ainda é melhor do que "rodar o seu próprio" e mais fácil de ler do que o modo java bruto.
Jason
38
@ max4ever Às vezes você já tem esta biblioteca incluída (por outros motivos) e é uma resposta perfeitamente válida. Eu estava procurando por isso e já dependo do Apache Commons Lang. Obrigado por esta resposta.
GuiSim
1
Ou você pode apenas copiar o método (e impedimentos, se houver algum).
Buffalo
10
@ max4ever A maioria dos aplicativos Android é minimizada pelo Proguard, colocando apenas as classes e funções necessárias no seu aplicativo. Isso faz com que seja igual a você mesmo, ou copie a fonte da coisa do apache. E quem não usar esse minimalization não precisa reclamar 700kb ou 78kb :)
Kenyakorn Ketsombut
158

Basta implementá-lo manualmente:

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

Melhoria:

A v != nullcondição é constante dentro do método. Ele sempre avalia o mesmo valor booleano durante a chamada do método. Portanto, se a entrada arrayfor grande, é mais eficiente avaliar essa condição apenas uma vez e podemos usar uma condição simplificada / mais rápida dentro do forloop com base no resultado. O contains()método aprimorado :

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
fonte
9
@Phoexo Esta solução é obviamente mais rápida porque a resposta aceita agrupa a matriz em uma lista e chama o método contains () nessa lista, enquanto minha solução basicamente faz o que contém () faria.
icza 10/10
10
O @AlastorMoody e == v faz uma verificação de igualdade de referência que é muito rápida. Se o mesmo objeto (o mesmo por referência) estiver na matriz, ele será encontrado mais rapidamente. Se não for a mesma instância, ainda pode ser a mesma reivindicada pelo método equals (), é isso que é verificado se as referências não forem as mesmas.
Icza
20
Por que essa função não faz parte do Java? Não é de admirar que as pessoas digam que o Java está inchado ... veja todas as respostas acima que usam várias bibliotecas quando tudo que você precisa é um loop for. As crianças nos dias de hoje!
Phreakhead #
4
@phreakhead Faz parte do Java, vejaCollection.contains(Object)
Steve Kuo
11
@icza Se você olhar para a fonte Arrayse ArrayListse verificar que isso não é necessariamente mais rápido que a versão usada Arrays.asList(...).contains(...). A sobrecarga de criação de um ArrayListé extremamente pequena e ArrayList.contains()usa um loop mais inteligente (na verdade, ele usa dois loops diferentes) do que o mostrado acima (JDK 7).
Axel
72

Quatro maneiras diferentes de verificar se uma matriz contém um valor

1) Usando a 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 um loop simples:

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

4) Usando Arrays.binarySearch ():

O código abaixo está errado, está listado aqui para fins de integridade. O binarySearch () só pode ser usado em matrizes classificadas. Você encontrará o resultado estranho abaixo. Essa é a melhor opção quando a matriz é classificada.

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

Exemplo 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
fonte
5
seu exemplo de pesquisa binária deve retornar um> 0;
quer
6
Por quê? Eu acho que ele deve retornar um> -1, pois 0 indica que ele está contido no cabeçalho da matriz.
23416 mbbow
1
A primeira variante com (a >= 0)estava correta, basta verificar os documentos , eles dizem "Observe que isso garante que o valor de retorno será> = 0 se e somente se a chave for encontrada".
Yoory N.
Por que trabalha com String e não com int? boolean estático existe (int [] ints, int k) {return Arrays.asList (ints) .contains (k); }
Willians Martins
71

Se a matriz não for classificada, você terá que repetir tudo e fazer uma chamada para igual a cada um.

Se a matriz estiver classificada, você poderá fazer uma pesquisa binária, há uma na classe Arrays .

De um modo geral, se você for fazer muitas verificações de associação, convém armazenar tudo em um conjunto, não em uma matriz.

Uri
fonte
1
Além disso, como eu disse na minha resposta, se você usar a classe Arrays, poderá classificar a matriz e executar a pesquisa binária na nova matriz classificada.
9789 Thomas Thomasens
1
@ Thomas: eu concordo. Ou você pode simplesmente adicionar tudo em um TreeSet; mesma complexidade. Eu usaria as matrizes se isso não mudar (talvez salve um pouco da localidade da memória, pois as referências estão localizadas contiguamente, embora as seqüências de caracteres não sejam). Eu usaria o aparelho se isso mudasse com o tempo.
Uri
49

Pelo que vale a pena, fiz um teste comparando as 3 sugestões de velocidade. Gerei números inteiros aleatórios, converti-os em uma String e os adicionei a uma matriz. Em seguida, procurei o maior número / string possível, o que seria o pior cenário possível para o asList().contains().

Ao usar um tamanho de matriz de 10K, os resultados foram:

Classificação e pesquisa: 15
Pesquisa binária: 0
asList.contains: 0

Ao usar uma matriz de 100K, os resultados foram:

Classificar & Pesquisar: 156
Pesquisa binária: 0
asList.contains: 32

Portanto, se a matriz for criada em ordem classificada, a pesquisa binária será a mais rápida; caso contrário, asList().containsseria o caminho a seguir. Se você tiver muitas pesquisas, pode valer a pena classificar a matriz para poder usar a pesquisa binária. Tudo depende da sua aplicação.

Eu acho que esses são os resultados que a maioria das pessoas esperaria. Aqui está o código do teste:

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
fonte
6
Eu não entendo esse código. Você classifica as 'strings' da matriz e usa a mesma matriz (classificada) nas duas chamadas para binarySearch. Como isso pode mostrar algo, exceto a otimização do tempo de execução do HotSpot? O mesmo com a chamada asList.contains. Você cria uma lista a partir da matriz classificada e, em seguida, contém nela o valor mais alto. Claro que vai levar tempo. Qual é o significado deste teste? Para não mencionar ser um microbenchmark indevidamente escrita
Erik
Além disso, como a pesquisa binária pode ser aplicada apenas a um conjunto classificado, a classificação e a pesquisa são a única maneira possível de usar a pesquisa binária.
Erik
A classificação já pode ter sido feita por vários outros motivos, por exemplo, poderia ser classificada no init e nunca alterada. É útil testar o tempo de pesquisa por conta própria. Onde isso ocorre, no entanto, é um exemplo menos do que estelar de marcas de microbenching. As marcas de microbench são notoriamente difíceis de corrigir em Java e devem, por exemplo, incluir a execução do código de teste o suficiente para obter a otimização do ponto de acesso antes de executar o teste real, sem falar em executar o código de teste real mais do que ONCE com um timer. Exemplo de armadilhas
Thor84no 24/10
7
Este teste é falho, pois executa todos os 3 testes na mesma instância da JVM. Os testes posteriores podem se beneficiar dos anteriores, aquecendo o cache, o JIT, etc. #
Steve Kuo
4
Este teste é realmente totalmente independente. A classificação e pesquisa são de complexidade linearitômica (n * log (n)), a pesquisa binária é logarítmica e o ArrayUtils.contains é obviamente linear. Não adianta comparar essas soluções, pois elas estão em classes de complexidade totalmente diferentes.
dragn
37

Em vez de usar também a sintaxe de inicialização rápida da matriz, você pode inicializá-la imediatamente como uma Lista de maneira semelhante, usando o método Arrays.asList, por exemplo:

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

Então você pode fazer (como acima):

STRINGS.contains("the string you want to find");
Mark Rhodes
fonte
35

Com o Java 8, você pode criar um fluxo e verificar se alguma entrada no fluxo corresponde "s":

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

Ou como um método genérico:

public static <T> boolean arrayContains(T[] array, T value) {
    return Arrays.stream(array).anyMatch(value::equals);
}
assylias
fonte
3
Vale ressaltar também as especializações primitivas.
skiwi
Para adicionar também, o anyMatchJavaDoc declara isso "...May not evaluate the predicate on all elements if not necessary for determining the result.", portanto, talvez não seja necessário continuar o processamento após encontrar uma correspondência.
Mkobit
28

Você pode usar a classe Arrays para executar uma pesquisa binária pelo valor. Se sua matriz não estiver classificada, você precisará usar as funções de classificação na mesma classe para classificar a matriz e, em seguida, pesquise por ela.

Thomas Owens
fonte
Você pode usar as funções de classificação na mesma classe para fazer isso ... Devo adicionar isso à minha resposta.
9119 Thomas Thomasens
1
Provavelmente custará mais do que a abordagem asList (). Contains (), então, eu acho. A menos que você precise fazer essa verificação com muita frequência (mas se for apenas uma lista estática de valores que podem ser classificados para começar, para ser justo).
1013 Joey
Verdade. Existem muitas variáveis ​​sobre quais seriam as mais eficazes. É bom ter opções, no entanto.
9119 Thomas Thomasens
Algum código que faz isso aqui: stackoverflow.com/a/48242328/9131078
OOBalance
Classificar uma matriz inteira para fins de pesquisa é caro. Podemos usar o mesmo tempo de CPU para a pesquisa do liner em si. Eu prefiro a pesquisa binária em uma coleção que já é construída previamente em ordem classificada.
Arunwithasmile
17

ObStupidAnswer (mas acho que há uma lição aqui em algum lugar):

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}
Tom Hawtin - linha de orientação
fonte
1
O lançamento de exceção é aparentemente pesado, mas essa seria uma nova maneira de testar um valor se funcionar. A desvantagem é que o enum deve ser definido com antecedência.
James P.
13

Na verdade, se você usar o HashSet <> como proposto por Tom Hawtin, não precisará se preocupar com a classificação, e sua velocidade será a mesma da pesquisa binária em uma matriz pré-definida, provavelmente ainda mais rápida.

Tudo depende de como seu código está configurado, obviamente, mas de onde eu estou, a ordem seria:

Em uma matriz não classificada :

  1. HashSet
  2. asList
  3. ordenar e binário

Em uma matriz classificada:

  1. HashSet
  2. Binário
  3. asList

Então, de qualquer forma, HashSet para a vitória.

não
fonte
2
A associação ao HashSet deve ser O (1) e a pesquisa binária em uma coleção classificada é O (log n).
Skylar Saveland
11

Se você possui a biblioteca de coleções do Google, a resposta de Tom pode ser muito simplificada usando ImmutableSet (http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableSet.html)

Isso realmente remove muita confusão da inicialização proposta

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

Uma solução possível:

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
fonte
8

Os desenvolvedores costumam:

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

O código acima funciona, mas não há necessidade de converter uma lista para definir primeiro. Converter uma lista em um conjunto requer tempo extra. Pode ser tão simples quanto:

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

ou

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

return false;

O primeiro é mais legível que o segundo.

Jawad Zeb
fonte
7

Usar um loop simples é a maneira mais eficiente de fazer isso.

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

Cortesia de Programcreek

Ryan
fonte
Isso lançará uma exceção de ponteiro nulo se a matriz contiver uma referência nula antes do valor de destino.
Samuel Edwin Ward
1
a instrução if deve ser: if (targetValue.equals (s)) porque String igual a possui um verificador instanceof.
TheArchon
use Objects.equals (obj1, obj2) para ser nulo seguro.
trilogia
7

No 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);
Bainha Brilhada
fonte
7
Há alguma vantagem com essa abordagem?
Johannes Stadler
1
Não responde à pergunta.
Florian F
5
  1. Para matrizes de tamanho limitado, use o seguinte (conforme indicado pelo camickr ). Isso é lento para verificações repetidas, especialmente para matrizes mais longas (pesquisa linear).

     Arrays.asList(...).contains(...)
  2. Para um desempenho rápido, se você verificar repetidamente um conjunto maior de elementos

    • Uma matriz é a estrutura errada. Use ae TreeSetadicione cada elemento a ele. Classifica elementos e possui um exist()método rápido (pesquisa binária).

    • Se os elementos forem implementados Comparablee você desejar TreeSetclassificar adequadamente:

      ElementClass.compareTo()O método deve ser compatível com ElementClass.equals(): veja Tríades não aparecendo para lutar? (Conjunto Java sem um item)

      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));
    • Caso contrário, use o seu 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);
    • A recompensa: verifique a existência de algum elemento:

      // Fast binary search through sorted elements (performance ~ log(size)):
      boolean containsElement = myElements.exists(someElement);
Glen Best
fonte
4
Por que se preocupar TreeSet? HashSeté mais rápido (O (1)) e não requer pedidos.
Sean Owen
4

Tente o seguinte:

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
fonte
4

Use o seguinte (o contains()método éArrayUtils.in() neste 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 você pode ver no código acima, existem outros métodos utilitários ObjectUtils.equals()e ArrayUtils.indexOf()que foram usados ​​em outros locais também.

Abhishek Oza
fonte
Estou muito atrasado para ingressar nesta discussão, mas como minha abordagem para solucionar esse problema, quando o enfrentei há alguns anos atrás, era um pouco diferente das outras respostas já postadas aqui, estou postando a solução que usei na época, aqui, caso alguém ache útil.
Abhishek Oza
3

Verifique isto

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
fonte
1
Isso não funciona - ele inserirá o item elsepara cada item que não corresponder (por isso, se você estiver procurando por "AB" nessa matriz, ele irá para lá 3 vezes, já que 3 dos valores não são "AB ").
Bernhard Barker
3

Arrays.asList () -> chamar o método contains () sempre funcionará, mas um algoritmo de pesquisa é muito melhor, pois você não precisa criar um wrapper de lista leve em torno da matriz, que é o que Arrays.asList () faz .

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
fonte
Arrays.asListnão é O (n). É apenas uma embalagem leve. Dê uma olhada na implementação.
Patrick Parker
3

Se você não quer que seja sensível a maiúsculas e minúsculas

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

Usar Array.BinarySearch(array,obj) para encontrar o objeto especificado na matriz ou não.

Exemplo:

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

false - não existe

Vingador
fonte
4
Array.BinarySearche Array.FindIndexsão métodos .NET e não existem em Java.
ataylor
@ataylor há Arrays.binarySearch em java. Mas você está certo, não Arrays.findIndex
mente
Note-se:The array must be sorted prior to making this call. If it is not sorted, the results are undefined.
Dorian Gray
1

Crie um booleano inicialmente definido como false. Execute um loop para verificar todos os valores na matriz e comparar com o valor que você está verificando. Se você conseguir uma correspondência, defina booleano como true e interrompa o loop. Em seguida, afirme que o booleano é verdadeiro.

mandy1339
fonte
1

Tente usar o método de teste de predicado Java 8

Aqui está um exemplo completo disso.

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
fonte
0

o uso de a Spliterator impede a geração desnecessária de um 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 == truese searchestá contido na matriz


isso faz o trabalho para arrays 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
fonte
-2

Você pode verificá-lo por dois métodos

A) Convertendo a matriz em string e, em seguida, verifique a string necessária pelo 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 é um método mais eficaz

 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
fonte
1
A conversão de strings é absurdamente ineficiente e a solução está incorreta, por exemplo, contains (",") retornará true.
Atuos 22/08/19