나는String[]값은 다음과 같습니다.
public static final String[] VALUES = new String[] {"AB","BC","CD","AE"};
주어진String s, 여부를 테스트하는 좋은 방법입니다VALUES포함하다s?
Arrays.asList(yourArray).contains(yourValue)
경고 : 프리미티브 배열 (주석 참조)에서는 작동하지 않습니다.
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);
ArrayList, 하지만java.util.ArrayList예상대로, 리턴 된 실제 클래스는 다음과 같습니다.java.util.Arrays.ArrayList<E>로써 정의 된:public class java.util.Arrays {private static class ArrayList<E> ... {}}. - TWiStErRob
처음부터 코드를 삭제하십시오. 우리는 (수정) :
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).
Arrays.asList)? - Basil BourqueTreeSet~ 될거야.O(log n).HashSet버킷의 평균 요소 수가 대략 일정하도록 스케일됩니다. 최소한 2 ^ 30까지의 배열에 대해서. big-O 분석이 무시하는 하드웨어 캐시의 영향이있을 수 있습니다. 또한 해시 함수가 효과적으로 작동한다고 가정합니다. - Tom Hawtin - tackline
당신이 사용할 수있는ArrayUtils.contains...에서아파치 커먼즈 랭
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;
}
Collection.contains(Object) - Steve KuoArrays과ArrayList이 버전이 사용하는 버전보다 반드시 빠르지는 않습니다.Arrays.asList(...).contains(...). 창작의 오버 헤드ArrayList매우 작고ArrayList.contains()(JDK 7)보다 똑똑한 루프를 사용합니다. 실제로는 두 개의 다른 루프를 사용합니다. - Axel
배열이 정렬되지 않으면 모든 것을 반복하고 각각에 대해 equals를 호출해야합니다.
배열이 정렬 된 경우 이진 검색을 수행 할 수 있습니다.배열수업.
일반적으로 말하자면, 많은 멤버십 검사를 수행하려는 경우 배열이 아닌 Set에 모든 것을 저장해야 할 수 있습니다.
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
(a >= 0)올바른지, 그냥 확인했다.문서그들은 "이것은 키가 발견되는 경우에만 리턴 값이 > = 0이 될 것이라는 것을 보장한다"라고 말한다. - Yoory N.
그 가치가 무엇인지에 대해서는 속도에 대한 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));
}
}
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.asList 메서드를 사용하여 비슷한 방식으로 곧바로 목록으로 초기화 할 수 있습니다 (예 :
public static final List<String> STRINGS = Arrays.asList("firstString", "secondString" ...., "lastString");
그런 다음 위와 같이 할 수 있습니다.STRINGS.contains("the string you want to find");
당신은배열 클래스값에 대한 2 진 검색을 수행합니다. 배열이 정렬되지 않은 경우 동일한 클래스의 정렬 함수를 사용하여 배열을 정렬 한 다음 검색해야합니다.
ObStupidAnswer (하지만 어딘가에 여기에 교훈이 있다고 생각합니다) :
enum Values {
AB, BC, CD, AE
}
try {
Values.valueOf(s);
return true;
} catch (IllegalArgumentException exc) {
return false;
}
실제로 Tom Hawtin이 제안한 HashSet을 사용하면 정렬에 대해 걱정할 필요가 없으며 사전 정렬 된 배열에서 Binary Search와 속도가 동일 할 수도 있습니다.
그것은 모두 당신의 코드가 어떻게 설정되었는지에 달려 있습니다. 그러나 내가 서있는 곳에서부터 순서는 다음과 같습니다.
정렬되지 않은 배열에서 :
정렬 된 배열에서 :
그래서 어느 쪽이든, HashSet ftw
Google 콜렉션 라이브러리가있는 경우 Tom의 대답은 ImmutableSet (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");
가능한 한 가지 해결책 :
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스트림을 사용하십시오.
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;
}
길이가 제한된 배열의 경우 다음을 사용합니다 (Camickr). 이는 반복 검사, 특히 긴 배열 (선형 검색)의 경우 느립니다.
Arrays.asList(...).contains(...)
보다 큰 요소 집합에 대해 반복적으로 검사하는 경우 빠른 성능을 위해
배열이 잘못된 구조입니다. 사용TreeSet각 요소를 추가하십시오. 요소를 정렬하고 빠릅니다.exist()메소드 (2 진 검색).
요소가 구현하는 경우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);
TreeSet?HashSet(O (1)) 빠르며 주문이 필요하지 않습니다. - Sean Owen
이것을 확인하십시오.
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
}
}
else...에 대한...마다(해당 배열에서 " AB "를 (를) 찾으려는 경우 값 중 3 개가 'AB'가 아니므로 3 번 반복됩니다). - Dukeling
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.
}
Arrays.asListO (n)이 아닙니다. 그것은 가벼운 포장지입니다. 구현을 살펴보십시오. - Patrick Parker
용도Array.BinarySearch(array,obj)지정된 객체를 배열로 찾는 지 여부.
전의:
if (Array.BinarySearch(str, i) > -1)-> 참 - 존재
거짓 - 없음
이 시도:
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");
}
나는이 토론에 참여하기가 너무 늦었지만이 문제를 해결하기위한 나의 접근 방식은 몇 년 전에 직면했을 때 이미 여기에 게시 된 다른 답변 들과는 조금 달랐다. 그 당시 내가 사용했던 해결책을 게시하고있다. 누군가가 유용하다고 여기는 경우에 여기에서 : (Thecontains()방법은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);
최초로 false로 설정된 boolean를 작성합니다. 루프를 실행하여 배열의 모든 값을 검사하고 비교 대상 값과 비교하십시오. 일치하는 항목이 있으면 부울을 true로 설정하고 반복을 중지하십시오. 그런 다음 부울이 참이라고 주장합니다.