어레이에 Java에서 특정 값이 포함되어 있는지 확인하려면 어떻게 해야 합니까?

어레이에 Java에서 특정 값이 포함되어 있는지 확인하려면 어떻게 해야 합니까?

는 나나 a a a가 있다String[]하다

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

의 「」String s 「 「」의 유무를 할 수 있는 ?VALUESs

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

Java SE 9의 간결한 업데이트

참조 배열이 불량입니다.이번 사건에서 우리는 한 세트를 찾고 있다. 9 Java SE 9 후 java javaSet.of.

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

"String s를 지정하면 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 - 공개될 수도 있습니다.)

(*브랜드에 대해 좀 더 자세히 설명하자면, 컬렉션 API에는 불변의 컬렉션 타입이 아직 없고, 구문도 너무 상세해서 제 취향에 맞지 않습니다.

하시면 됩니다.ArrayUtils.containsApache Commons Lang에서

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. 「」를 사용합니다.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():

   다음 코드는 올바르지 않습니다.완전성을 위해 여기에 기재되어 있습니다.정렬된 어레이에서만 사용할 수 있습니다.결과가 이상하다는 것을 알게 될 것입니다.어레이를 정렬할 때는 이것이 가장 좋은 옵션입니다.

   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

어레이가 정렬되지 않은 경우 모든 것을 반복하여 각각 동등하게 호출해야 합니다.

배열이 정렬된 경우 이진 검색을 수행할 수 있습니다. 이 검색은 배열 클래스에 있습니다.

일반적으로 멤버십 체크를 많이 하는 경우에는 모든 것을 배열이 아닌 세트에 저장하는 것이 좋습니다.

중요한 것은 속도에 대한 세 가지 제안을 비교하는 테스트를 실시했습니다.랜덤 정수를 생성하여 String으로 변환하여 배열에 추가했습니다.한 한 했는데, 이 .이것은, 다음의 경우에 최악의 시나리오가 됩니다.asList().contains().

10K 어레이 사이즈를 사용했을 때의 결과는 다음과 같습니다.

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

10K 어레이를 사용했을 때의 결과는 다음과 같습니다.

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

퀵 어레이 초기화 구문을 사용하는 대신 Arrays.asList 메서드를 사용하여 동일한 방법으로 바로 목록으로 초기화할 수 있습니다.다음은 예를 제시하겠습니다.

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

그런 다음 (위와 같이) 다음을 수행할 수 있습니다.

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

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

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

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

enum Values {
    AB, BC, CD, AE
}

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

실제로 Tom Hawtin의 제안대로 HashSet <String>을 사용하면 정렬에 대해 걱정할 필요가 없습니다.또한 미리 정렬된 어레이에서의 바이너리 검색과 같은 속도이며, 아마도 더 빠를 것입니다.

이 모든 것은 코드가 어떻게 설정되어 있는지에 따라 달라집니다만, 제 견해로는, 순서는 다음과 같습니다.

정렬되지 않은 배열:

1. 해시 세트
2. 리스트
3. 정렬 및 바이너리

정렬된 배열:

1. 해시 세트
2. 바이너리
3. 리스트

어느 쪽이든 승리를 위한 HashSet입니다.

구글 컬렉션 라이브러리가 있다면, Tom의 답변은 UnmutableSet(http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableSet.html)을 통해 많이 단순화할 수 있습니다.

이것에 의해, 제안된 초기화에 수반하는 많은 혼란이 해소됩니다.

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

생각할 수 있는 해결책 1개요

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;

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

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

이를 위해서는 단순 루프를 사용하는 것이 가장 효율적인 방법입니다.

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

Programcreek에 대한 예의

것을 하세요.contains()는 「」입니다.ArrayUtils.in(): : : : : 。

오브젝트 Utils.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);
    }
}

어레이 Utils.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()하다

1. 길이가 제한된 배열의 경우 다음을 사용하십시오(camickr에서 지정).이것은 반복적인 확인, 특히 긴 배열(선형 검색)의 경우 느립니다.

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

2. 더 큰 요소 세트와 반복적으로 대조하는 경우 빠른 성능을 위해

   • 배열이 잘못된 구조입니다.를 사용하여 각 요소를 추가합니다.요소를 분류하고 빠른 속도를 가지고 있습니다.exist()method(방법)

   • 가 「」를 실장하고 있는 .Comparable160;&#160;&#160;&#160;&#160;를 .TreeSet따라 분류하다: 라라 따 sorted sorted sorted sorted sorted sorted sorted sorted sorted sorted

     ElementClass.compareTo().ElementClass.equals()삼합회가 안 오는 거 봤어? (Java 세트에 아이템이 누락됨)

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

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

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

체크해 주세요

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

VALUES 을 포함할 수 .
9Java 9

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

Array.BinarySearch(array,obj)배열에서 지정된 개체를 찾을 수 있는지 여부를 지정합니다.

예:

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

false --존재하지 않음

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

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

원시적인 타입의 바이트와 바이트[]를 사용하여 낮은 수준의 Java를 다루고 있기 때문에 지금까지 얻은 것 중 최고는 바이트 수에서 얻은 것입니다.https://github.com/patrickfav/bytes-java는 훌륭한 작품인 것 같습니다.

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

A)한 후 을 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));
}

언급URL : https://stackoverflow.com/questions/1128723/how-do-i-determine-whether-an-array-contains-a-particular-value-in-java