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




12 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).

java 배열 contains

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

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

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




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

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



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




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

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

정렬되지 않은 배열에서 :

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

정렬 된 배열에서 :

  1. HashSet
  2. 이진
  3. asList

그래서 어느 쪽이든, HashSet ftw




가능한 한 가지 해결책 :

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



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. 보다 큰 요소 집합에 대해 반복적으로 검사하는 경우 빠른 성능을 위해

    • 배열이 잘못된 구조입니다. 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);
      



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

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

거짓 - 없음




이것을 확인하십시오.

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.stream(VALUES).anyMatch(s::equalsIgnoreCase);



Related


Tags

java   arrays