java - 포함 - 자바 배열에 값이 있는지 확인




배열에 Java의 특정 값이 포함되어 있는지 확인하는 방법은 무엇입니까? (17)

나는 String[] 과 같은 값을 갖는다.

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

주어진 String s , VALUESs 가 포함되어 있는지 여부를 테스트 할 수있는 좋은 방법이 있습니까?


  1. 길이가 제한된 배열의 경우 다음을 사용합니다 ( camickr에서 제공 ). 이는 반복 검사, 특히 긴 배열 (선형 검색)의 경우 느립니다.

     Arrays.asList(...).contains(...)
    
  2. 보다 큰 요소 집합에 대해 반복적으로 검사하는 경우 빠른 성능을 위해

    • 배열이 잘못된 구조입니다. TreeSet 사용하고 각 요소를 추가하십시오. 요소를 정렬하고 빠른 exist() 메서드 (이진 검색)를 사용합니다.

    • 요소가 Comparable 구현하고 있고 그에 따라 정렬 된 TreeSet 을 원한다면 :

      ElementClass.compareTo() 메소드는 ElementClass.equals() 와 호환 가능해야합니다. Triads가 표시되지 않는지 확인하십시오 . (자바 세트 항목 누락)

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

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

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

ObStupidAnswer (하지만 어딘가에 여기에 교훈이 있다고 생각합니다) :

enum Values {
    AB, BC, CD, AE
}

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

간단한 루프를 사용하는 것이 가장 효율적인 방법입니다.

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

Programcreek 에게 의례


개발자는 종종 다음을 수행합니다.

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;

첫 번째 것은 두 번째 것보다 읽기 쉽습니다.


나는이 토론에 참여하기가 너무 늦었지만이 문제를 해결하기위한 나의 접근 방식은 몇 년 전에 직면했을 때 이미 여기에 게시 된 다른 답변 들과는 조금 달랐다. 그 당시 내가 사용했던 해결책을 게시하고있다. 여기에 누군가가 유용하다고 생각할 때를 대비해서 : ( 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() 와 같은 다른 유틸리티 메서드도 있으므로 다른 곳에서도 사용되었습니다.


대소 문자를 구분하지 않으려면

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

빠른 배열 초기화 구문을 사용하는 대신 Arrays.asList 메서드를 사용하여 비슷한 방식으로 곧바로 List로 초기화 할 수 있습니다. 예 :

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

그런 다음 위와 같이 할 수 있습니다. STRINGS.contains("the string you want to find");


실제로 Tom Hawtin이 제안한 HashSet을 사용하면 정렬에 대해 걱정할 필요가 없으며 사전 정렬 된 배열에서 Binary Search와 속도가 동일 할 수도 있습니다.

그것은 모두 당신의 코드가 어떻게 설정되었는지에 달려 있습니다. 그러나 내가 서있는 곳에서부터 순서는 다음과 같습니다.

정렬되지 않은 배열에서 :

  1. HashSet
  2. asList
  3. 정렬 및 이진

정렬 된 배열에서 :

  1. HashSet
  2. 이진
  3. asList

그래서 어느 쪽이든, HashSet ftw


이것을 확인하십시오.

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

저는 아무도 손으로 그것을 단순히 구현한다고 제안한 사람은 놀랍습니다.

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

최초로 false로 설정된 boolean를 작성합니다. 루프를 실행하여 배열의 모든 값을 검사하고 비교 대상 값과 비교하십시오. 일치하는 항목이 있으면 부울을 true로 설정하고 루핑을 중지하십시오. 그런 다음 부울이 참이라고 주장합니다.


배열에 값이 포함되어 있는지 확인하는 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 클래스 를 사용하여 값에 대한 이진 검색을 수행 할 수 있습니다. 배열이 정렬되지 않은 경우 동일한 클래스의 정렬 함수를 사용하여 배열을 정렬 한 다음 검색해야합니다.


Array.BinarySearch(array,obj) 를 사용하여 배열에서 지정된 객체를 찾습니다. 전의:

if (Array.BinarySearch(str, i) > -1) -> true - 존재 함

거짓 - 없음


Arrays.asList(yourArray).contains(yourValue)

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

java-8 부터 이제 Streams를 사용할 수 있습니다.

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

int , double 또는 long 의 배열에 값이 들어 있는지 여부를 확인하려면 각각 IntStream , DoubleStream 또는 LongStream 사용 IntStream .

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






arrays