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

질문자 :Mike Sickler

다음과 같은 값을 가진 String[]

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

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

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

예시

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

camickr

Java SE 9에 대한 간결한 업데이트

참조 배열이 잘못되었습니다. 이 경우 우리는 세트 후에 있습니다. Java SE 9 이후로 Set.of 있습니다.

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

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

 VALUES.contains(s)

오(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 에 싸여 있으면 더 편안할 수 있습니다. 그러면 공개될 수도 있습니다.)

(*브랜드에 대해 조금 더 설명하자면 컬렉션 API에는 여전히 변경할 수 없는 컬렉션 유형이 누락되어 있고 구문은 내 취향에 여전히 너무 장황합니다.)

Tom Hawtin - tackline

Apache Commons Lang 에서 ArrayUtils.contains 를 사용할 수 있습니다.

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

전달된 배열이 null 이면 이 메서드는 false 반환합니다.

모든 종류의 기본 배열에 사용할 수 있는 메서드도 있습니다.

예시:

 String[] fieldsToInclude = { "id", "name", "location" }; if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) { // Do some stuff. }

Intracer

간단히 손으로 구현하십시오.

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

icza

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

1. List 사용:

    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) { return Arrays.binarySearch(arr, targetValue) >= 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

Sireesh Yarlagadda

배열이 정렬되지 않은 경우 모든 항목을 반복하고 각각에 대해 equals를 호출해야 합니다.

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

일반적으로 말하면, 멤버십 검사를 많이 하려는 경우 배열이 아닌 Set에 모든 것을 저장하는 것이 좋습니다.

Uri

가치가 있는 것에 대해 속도에 대한 3가지 제안을 비교하는 테스트를 실행했습니다. 임의의 정수를 생성하여 문자열로 변환하고 배열에 추가했습니다. asList().contains() 대한 최악의 시나리오가 될 가능한 가장 높은 숫자/문자열을 검색했습니다.

10K 배열 크기를 사용할 때 결과는 다음과 같습니다.

 Sort & Search : 15 Binary Search : 0 asList.contains : 0

100K 어레이를 사용할 때 결과는 다음과 같습니다.

 Sort & Search : 156 Binary Search : 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)); } }

camickr

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

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

그런 다음 위와 같이 할 수 있습니다.

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

Mark Rhodes

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

assylias

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

Thomas Owens

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

 enum Values { AB, BC, CD, AE } try { Values.valueOf(s); return true; } catch (IllegalArgumentException exc) { return false; }

Tom Hawtin - tackline

실제로 Tom Hawtin이 제안한 대로 HashSet<String>을 사용하면 정렬에 대해 걱정할 필요가 없으며 속도는 사전 정렬된 배열에서 이진 검색과 같으며 아마도 더 빠를 것입니다.

분명히 코드가 어떻게 설정되었는지에 따라 다르지만 내가 서 있는 순서는 다음과 같습니다.

정렬되지 않은 배열에서:

1. 해시셋
2. asList
3. 정렬 및 이진

정렬된 배열에서:

1. 해시셋
2. 바이너리
3. asList

그래서 어느 쪽이든, HashSet이 승리합니다.

not

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

jhodges

한 가지 가능한 솔루션:

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

Christian Giménez

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

 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;

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

AndroidGeek

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

Shineed Basheer

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

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

Programcreek 제공

Ryan

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

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

2. 더 큰 요소 집합에 대해 반복적으로 확인하는 경우 빠른 성능을 위해

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

Glen Best

다음을 사용하십시오(이 코드에서 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()

Abhishek Oza

이 시도:

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

Mr.G

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

TheArchon

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

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

Akhil babu K

이것을 확인

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

SubbaRao Boddu

배열에서 주어진 객체를 찾으려면 Array.BinarySearch(array,obj) 를 사용하십시오.

예시:

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

거짓 -- 존재하지 않음

Avenger

가장 짧은 솔루션
배열 VALUES 중복 항목이 포함될 수 있습니다.
자바 9 이후

 List.of(VALUES).contains(s);

Kaplan

처음에 false로 설정된 부울을 만듭니다. 루프를 실행하여 배열의 모든 값을 확인하고 확인 중인 값과 비교합니다. 일치하는 항목이 있으면 부울을 true로 설정하고 반복을 중지합니다. 그런 다음 부울 값이 참이라고 주장합니다.

mandy1339

기본 유형 byte 및 byte[]를 사용하여 저수준 Java를 다룰 때 지금까지 얻은 최고는 bytes-java https://github.com/patrickfav/bytes-java 에서 가져온 것입니다.

eigenfield

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://mytechnologythink.blogspot.com/2019/10/java-8-predicate-test-method-example.html

https://github.com/VipulGulhane1/java8/blob/master/Test.java

Vipul Gulhane

두 가지 방법으로 확인할 수 있습니다

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

Syed Salman Hassan

출처 : http:www.stackoverflow.com/questions/1128723/how-do-i-determine-whether-an-array-contains-a-particular-value-in-java