arrays array string - Como determinar se uma matriz contém um valor específico em Java?





12 Answers

Apenas para limpar o código para começar. Nós temos (corrigido):

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

Esta é uma estática mutável que o FindBugs irá dizer que é muito desobediente. Deve ser privado:

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

(Nota, você pode realmente largar o new String[]; bit new String[]; )

Então, as matrizes de referência são ruins e, em particular, aqui 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 for envolto em Collections.unmodifiableSet - pode até ser tornado público.)

"Dado String s, existe uma boa maneira de testar se VALUES contém s?"

VALUES.contains(s)

O (1)

objetos declarar tutorial

Eu tenho um String[] com valores como:

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

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




Estou surpreso que ninguém sugeriu simplesmente 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 condição v != null é constante dentro do método, sempre avalia o mesmo valor booleano durante a chamada do método. Portanto, se a array entrada for grande, é mais eficiente avaliar essa condição apenas uma vez e podemos usar uma condição simplificada / mais rápida dentro do loop for base no resultado. O método contains() 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;
}



Quatro maneiras diferentes de verificar se um array contém um valor

1) Usando 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 por completo. binarySearch () só pode ser usado em matrizes ordenadas. 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



Com o Java 8, você pode criar um fluxo e verificar se alguma entrada no fluxo corresponde a "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);
}



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




Na verdade, se você usar o HashSet como o Tom Hawtin propôs você não precisa se preocupar com a classificação e sua velocidade é a mesma que a da Pesquisa Binária em uma matriz pré-determinada, provavelmente ainda mais rápida.

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

Em uma matriz UNsorted:

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

Em uma matriz ordenada:

  1. HashSet
  2. Binário
  3. asList

Então, de qualquer forma, HashSet ftw




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



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



  1. Para matrizes de comprimento limitado, use o seguinte (conforme fornecido por camickr ). Isso é lento para verificações repetidas, especialmente para matrizes mais longas (pesquisa linear).

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

    • Uma matriz é a estrutura errada. Use um TreeSet e adicione cada elemento a ele. Ele classifica os elementos e possui um método fast exist() (pesquisa binária).

    • Se os elementos implementarem o Comparable e você quiser que o TreeSet classificado de acordo:

      ElementClass.compareTo() método ElementClass.compareTo() deve ser compatível com ElementClass.equals() : veja Triads não aparecer para lutar? (Java Set faltando 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 seu próprio 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);
    • O pagamento: verifique a existência de algum elemento:

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



Use Array.BinarySearch(array,obj) para encontrar o objeto dado na matriz ou não. Ex:

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

falso - não existe




Verificar isso

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



Se você não quer que seja case sensitive

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



Related


Tags

java   arrays