배열에 Java의 특정 값이 포함되어 있는지 어떻게 확인합니까?

나는 다음 String[]과 같은 값을 가지고있다 :

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

을 감안할 때 String s, 여부를 테스트하는 좋은 방법이 VALUES포함은 s?

Arrays.asList(yourArray).contains(yourValue)

경고 : 프리미티브 배열에는 작동하지 않습니다 (주석 참조).

이후 자바 -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"
);

"문자열 제공, 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수 있습니다. 심지어 공개 될 수도 있습니다.)

(* 브랜드에 대해 좀 더 설명하기 위해 collections API에는 여전히 불변 컬렉션 유형이 누락되어 있으며 구문은 여전히 ​​취향에 비해 너무 장황합니다.)

Apache Commons LangArrayUtils.contains 에서 사용할 수 있습니다

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

배열에 값이 포함되어 있는지 확인하는 4 가지 다른 방법

1) 목록 사용 :

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

2) 세트 사용 :

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

배열이 정렬되어 있지 않으면 모든 것을 반복하고 각각에 대해 동일하게 호출해야합니다.

배열이 정렬되면 이진 검색을 수행 할 수 있습니다 . Arrays 클래스에 하나가 있습니다.

일반적으로 많은 멤버쉽 확인을 수행하려는 경우 모든 항목을 배열이 아닌 세트에 저장하려고 할 수 있습니다.

그만한 가치가 있기 때문에 속도에 대한 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 클래스 를 사용하여 값에 대한 이진 검색을 수행 할 수 있습니다 . 배열이 정렬되지 않은 경우 같은 클래스에서 정렬 함수를 사용하여 배열을 정렬 한 다음 검색해야합니다.

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.

Google 컬렉션 라이브러리가있는 경우 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

에서 자바 8은 스트림 사용합니다.

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()참조 : 싸울 표시되지 화음을? (자바 세트에 항목이 없음)

     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로 설정하십시오. 루프를 실행하여 배열의 모든 값을 확인하고 확인중인 값과 비교하십시오. 일치하는 것이 있으면 부울을 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

의 사용은 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 );
…

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

    }