[java] 배열에 특정 값이 포함되어 있는지 어떻게 테스트 할 수 있습니까?


Answers

처음부터 코드를 지우기 만하면됩니다. 우리는 (수정) :

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 에 싸여 있다면 더 편하게 느낄 것입니다. 공개 할 수도 있습니다.)

"String이 주어지면 VALUES에 s가 포함되어 있는지 테스트 할 수있는 좋은 방법이 있습니까?"

VALUES.contains(s)

O (1).

Question

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

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

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




배열에 값이 포함되어 있는지 확인하는 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



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



이것을 확인하십시오.

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



가능한 한 가지 해결책 :

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;

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




Arrays 클래스 를 사용하여 값에 대한 이진 검색을 수행 할 수 있습니다. 배열이 정렬되지 않은 경우 동일한 클래스의 정렬 함수를 사용하여 배열을 정렬 한 다음 검색해야합니다.




다음과 같이 간단 할 수 있습니다.

String[] VALUE = new String[] {"AB","BC","CD","AE"};
Arrays.asList(VALUE).contains(s);



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

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



빠른 배열 초기화 구문을 사용하는 대신 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




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

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

거짓 - 없음




Related



Tags

java java   arrays