複数 - java 配列 検索 位置




配列にJavaで特定の値が含まれているかどうかを調べるにはどうすればよいですか? (17)

  1. 制限された長さの配列の場合は、以下を使用します( camickrによって与えられます )。 これは繰り返しチェック、特に長い配列(直線検索)の場合は遅くなります。

     Arrays.asList(...).contains(...)
    
  2. より大きな要素のセットに対して繰り返しチェックを行うと高速なパフォーマンスが得られます

    • 配列が間違った構造です。 TreeSetを使用して、各要素をTreeSetに追加します。 要素をソートし、高速のexist()メソッド(バイナリ検索)を持っています。

    • 要素がComparable実装していて、それに応じてTreeSetソートする必要がある場合:

      ElementClass.compareTo()メソッドはElementClass.compareTo()と互換性がなければなりません。 (Java Setに項目がありません)

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

私はString[]ような値を持っています:

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

String sVALUESsが含まれているかどうかをテストする良い方法がありますか?


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

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

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

booleanを最初にfalseに設定します。 ループを実行して、配列内のすべての値をチェックし、チェックしている値と比較します。 一致した場合は、ブール値をtrueに設定してループを停止します。 次にブール値が真であると主張します。


配列に値が含まれているかどうかを確認する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

Arraysクラスを使用すると、値のバイナリ検索を実行できます。 配列がソートされていない場合は、同じクラスのソート関数を使用して配列をソートし、それを検索する必要があります。


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

これを試して:

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.asListメソッドを使用して同様の方法でListとしてすぐに初期化することができます。例:

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

次に、あなたは(上記のように)行うことができます: STRINGS.contains("the string you want to find");


コードを最初からクリアするだけです。 我々は(訂正した):

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

実際には、Tom Hawtinが提案したようにHashSetを使用すると、並べ替えを心配する必要はなく、速度はプリソートされた配列のバイナリ検索と同じでしょう。

それはすべてあなたのコードがどのように設定されているかによって異なりますが、私が立っている場所から順番は次のようになります:

UNソートされた配列:

  1. HashSet
  2. asList
  3. ソート&バイナリ

ソートされた配列:

  1. HashSet
  2. バイナリ
  3. asList

どちらにしても、HashSet ftw


私は誰も手でそれを単に実装することを提案して驚いています:

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が大きければ、この条件を1回だけ評価する方が効率的であり、結果に基づいて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;
}

配列がソートされていない場合は、すべてを繰り返し処理し、それぞれに対してequalsを呼び出す必要があります。

配列がソートされている場合は、バイナリ検索ができますArraysクラスにはバイナリ検索があります。

一般的に言えば、多くのメンバシップチェックを行う場合は、すべてを配列ではなくSetに格納することができます。


Arrays.asList(yourArray).contains(yourValue)

警告:これはプリミティブの配列では機能しません(コメントを参照)。

java-8以降、Streamsを使用できるようになりました。

String[] values = {"AB","BC","CD","AE"};
boolean contains = Arrays.stream(values).anyMatch("s"::equals);

intdoubleまたはlong配列に値が含まれているかどうかを確認するには、それぞれIntStreamDoubleStreamまたはLongStream使用します。

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




arrays