如何确定数组在Java中是否包含特定值？

我有一个String[]像这样的值：

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

给定String s，有没有一种很好的方法来测试是否VALUES包含s？

Arrays.asList(yourArray).contains(yourValue)

警告：这不适用于图元数组（请参见注释）。

以来 Java-8 您现在可以使用流。

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

要检查的阵列是否int，double或long包含一个值使用IntStream，DoubleStream或LongStream分别。

例

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

Java SE 9的简要更新

引用数组不好。对于这种情况，我们要紧紧抓住。从Java SE 9开始，我们有了Set.of。

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

“给出String，是否有测试VALUES是否包含s的好方法？”

VALUES.contains(s)

O（1）。

的权利类型，不可变的，O（1）和简洁。美丽。*

原始答案详细信息

只是为了清除代码。我们（已更正）：

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

这是一个可变的静态函数，FindBugs会告诉您这很顽皮。不要修改静态变量，也不要让其他代码也这样做。绝对最小值，该字段应为私有：

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

（注意，您实际上可以删除该new String[];位。）

引用数组仍然很糟糕，我们需要一个集合：

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

（如我这样的偏执狂人，如果把Collections.unmodifiableSet它包裹起来，可能会感到更自在-甚至可以公开。）

（*在品牌上要多说一点，按我的喜好，collection API仍会缺少不可变的collection类型，并且语法仍然太冗长。）

您可以ArrayUtils.contains从Apache Commons Lang使用

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

请注意，false如果传递的数组为，则此方法返回null。

也有各种方法可用于各种原始数组。

例：

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

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

只需手动实施即可：

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

改善：

该v != null方法内部的条件是恒定的。在方法调用期间，它始终求值为相同的布尔值。因此，如果输入array很大，则仅一次评估此条件会更有效率，并且我们可以for根据结果在循环内使用简化/更快的条件。改进的contains()方法：

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

四种不同的方法检查数组是否包含值

1）使用清单：

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

2）使用Set：

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

3）使用一个简单的循环：

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

4）使用Arrays.binarySearch（）：

下面的代码是错误的，此处出于完整性目的列出了该代码。binarySearch（）仅可用于排序数组。您会发现下面的结果很奇怪。这是对数组进行排序时的最佳选择。

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

快速示例：

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

如果数组未排序，则必须遍历所有内容并在每个数组上调用equals。

如果数组已排序，则可以进行二进制搜索，Arrays类中有一个。

一般来说，如果要进行大量成员资格检查，则可能需要将所有内容存储在Set中，而不是存储在数组中。

为了进行测试，我进行了一项测试，比较了3条关于速度的建议。我生成了随机整数，将其转换为字符串并将其添加到数组中。然后，我搜索了可能的最高数字/字符串，这对于来说是最坏的情况asList().contains()。

使用10K数组大小时，结果为：

排序和搜索：15
二进制搜索：0
asList.contains：0

使用100K数组时，结果为：

排序和搜索：156
二进制搜索：0
asList.contains：32

因此，如果按排序顺序创建数组，则二进制搜索是最快的，否则asList().contains将是解决方法。如果搜索次数很多，那么对数组进行排序可能是值得的，以便可以使用二进制搜索。这完全取决于您的应用程序。

我认为这些是大多数人期望的结果。这是测试代码：

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

您也可以不使用快速数组初始化语法，而直接使用Arrays.asList方法以类似的方式将其初始化为List，例如：

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

然后您可以做（如上）：

STRINGS.contains("the string you want to find");

使用Java 8，您可以创建一个流并检查流中是否有任何条目匹配"s"：

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

或作为通用方法：

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

您可以使用Arrays类对值执行二进制搜索。如果未对数组进行排序，则必须使用同一类中的sort函数对数组进行排序，然后对其进行搜索。

ObStupidAnswer（但我认为这里有一个教训）：

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}

实际上，如果您按照Tom Hawtin的建议使用HashSet <String>，则无需担心排序，并且速度与对预排序数组进行二进制搜索的速度相同，甚至可能更快。

显然，这全取决于代码的设置方式，但从我的立场来看，顺序将是：

在未排序的数组上：

1. 哈希集
2. asList
3. 排序和二进制

在排序数组上：

1. 哈希集
2. 二元
3. asList

因此，无论哪种方式，HashSet都是胜利。

如果您拥有谷歌收藏库，可以使用ImmutableSet（http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableSet.html）大大简化Tom的答案。

这确实消除了建议的初始化过程中的很多混乱情况

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

一种可能的解决方案：

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

开发人员经常这样做：

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

上面的代码有效，但是无需转换列表以首先设置。将列表转换为集合需要额外的时间。它可以很简单：

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

要么

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

return false;

第一个比第二个更具可读性。

使用简单循环是执行此操作的最有效方法。

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

由Programcreek提供

在Java 8中使用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. 对于有限长度的数组，请使用以下内容（由camickr给出）。对于重复检查，这很慢，特别是对于较长的数组（线性搜索）而言。

    Arrays.asList(...).contains(...)

2. 为了提高性能，如果您反复检查较大的一组元素

   • 数组是错误的结构。使用a TreeSet并将每个元素添加到其中。它对元素进行排序并具有快速exist()方法（二进制搜索）。

   • 如果元素实现Comparable＆您想要相应地TreeSet排序：

     ElementClass.compareTo()方法必须与兼容ElementClass.equals()：请参阅三合会未露面打架？（Java Set缺少项目）

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

   • 否则，请使用您自己的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);

   • 回报：检查某些元素的存在：

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

尝试这个：

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

使用以下内容（该contains()方法ArrayUtils.in()在此代码中）：

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

}

正如您在上面的代码中看到的那样，还有其他实用程序方法ObjectUtils.equals()和ArrayUtils.indexOf()，它们也在其他地方使用。

检查一下

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

Arrays.asList（）->然后调用contains（）方法将始终有效，但是搜索算法要好得多，因为您无需在数组周围创建轻量级列表包装器，这就是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.
}

如果您不希望它区分大小写

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

是否Array.BinarySearch(array,obj)用于在数组中查找给定的对象。

例：

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

假-不存在

创建一个初始设置为false的布尔值。运行循环以检查数组中的每个值，然后将其与要检查的值进行比较。如果匹配成功，请将boolean设置为true并停止循环。然后断言布尔是真的。

尝试使用Java 8谓词测试方法

这是一个完整的例子。

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

使用a Spliterator 可防止不必要的产生 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 == true如果search包含在数组中

这确实适用于原始数组

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

当我使用基本类型byte和byte []处理低级Java时，到目前为止，我得到的最好的结果是来自bytes-java https://github.com/patrickfav/bytes-java似乎是一件不错的工作

您可以通过两种方法进行检查

A）通过将数组转换为字符串，然后通过.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）这是一种更有效的方法

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

    }