web-dev-qa-db-ja.com

カスタムの並べ替え順序を使用してオブジェクトのArrayListを並べ替える

アドレス帳アプリケーションにソート機能を実装したいと考えています。

ArrayList<Contact> contactArrayをソートしたい。 Contactは、名前、自宅番号、携帯電話番号、住所の4つのフィールドを含むクラスです。 nameでソートしたい。

これを行うカスタムソート関数を作成するにはどうすればよいですか？

javasortingcollectionsarraylist
112
Sameera0

オブジェクトの順序付けに関するチュートリアルは次のとおりです。

いくつか例を挙げますが、とにかく読むことをお勧めします。

ArrayListをソートするにはさまざまな方法があります。 natural（デフォルト）orderingを定義したい場合、 Contactに Comparable を実装させる必要があります。デフォルトでnameでソートしたい場合、次のようにします（簡単にするためにヌルチェックは省略されます）：

public class Contact implements Comparable<Contact> {

    private String name;
    private String phone;
    private Address address;

    public int compareTo(Contact other) {
        return name.compareTo(other.name);
    }

    // Add/generate getters/setters and other boilerplate.
}

あなたができるように

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

Collections.sort(contacts);

外部制御可能順序（自然順序をオーバーライドする）を定義する場合は、 Comparator を作成する必要があります。

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

// Now sort by address instead of name (default).
Collections.sort(contacts, new Comparator<Contact>() {
    public int compare(Contact one, Contact other) {
        return one.getAddress().compareTo(other.getAddress());
    }
});

Comparator自体でContactsを定義して、毎回再作成する代わりに再利用することもできます。

public class Contact {

    private String name;
    private String phone;
    private Address address;

    // ...

    public static Comparator<Contact> COMPARE_BY_PHONE = new Comparator<Contact>() {
        public int compare(Contact one, Contact other) {
            return one.phone.compareTo(other.phone);
        }
    };

    public static Comparator<Contact> COMPARE_BY_ADDRESS = new Comparator<Contact>() {
        public int compare(Contact one, Contact other) {
            return one.address.compareTo(other.address);
        }
    };

}

次のように使用できます。

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

// Sort by address.
Collections.sort(contacts, Contact.COMPARE_BY_ADDRESS);

// Sort later by phone.
Collections.sort(contacts, Contact.COMPARE_BY_PHONE);

そして、トップオフをクリーム状にするために、一般的なjavabeanコンパレータを使用することを検討できます：

public class BeanComparator implements Comparator<Object> {

    private String getter;

    public BeanComparator(String field) {
        this.getter = "get" + field.substring(0, 1).toUpperCase() + field.substring(1);
    }

    public int compare(Object o1, Object o2) {
        try {
            if (o1 != null && o2 != null) {
                o1 = o1.getClass().getMethod(getter, new Class[0]).invoke(o1, new Object[0]);
                o2 = o2.getClass().getMethod(getter, new Class[0]).invoke(o2, new Object[0]);
            }
        } catch (Exception e) {
            // If this exception occurs, then it is usually a fault of the developer.
            throw new RuntimeException("Cannot compare " + o1 + " with " + o2 + " on " + getter, e);
        }

        return (o1 == null) ? -1 : ((o2 == null) ? 1 : ((Comparable<Object>) o1).compareTo(o2));
    }

}

次のように使用できます。

// Sort on "phone" field of the Contact bean.
Collections.sort(contacts, new BeanComparator("phone"));

（コードに見られるように、ソート中のNPEを回避するためにnullフィールドがすでにカバーされている可能性があります）

263
BalusC

既に投稿されたものに加えて、Java 8以降、コードを短くして次のように記述できることを知っておく必要があります。

Collection.sort(yourList, Comparator.comparing(YourClass::getFieldToSortOn));

またはListにsortメソッドが追加されたため

yourList.sort(Comparator.comparing(YourClass::getFieldToSortOn));

説明：

Java 8以降、機能インターフェイス（抽象メソッドが1つだけのインターフェイス-より多くのデフォルトまたは静的メソッドを持つことができる）は、以下を使用して簡単に実装できます。

Comparator<T>には抽象メソッドint compare(T o1, T o2)が1つしかないため、これは機能的なインターフェイスです。

その代わりに（ @ BalusCanswer の例）

Collections.sort(contacts, new Comparator<Contact>() {
    public int compare(Contact one, Contact other) {
        return one.getAddress().compareTo(other.getAddress());
    }
});

このコードを次のように減らすことができます。

Collections.sort(contacts, (Contact one, Contact other) -> {
     return one.getAddress().compareTo(other.getAddress());
});

スキップすることで、この（または任意の）ラムダを単純化できます。

  • 引数の型（Javaはメソッドのシグネチャに基づいて推論します）
  • または{return ... }

代わりに

(Contact one, Contact other) -> {
     return one.getAddress().compareTo(other.getAddress();
}

我々は書ける

(one, other) -> one.getAddress().compareTo(other.getAddress())

また、Comparatorにはcomparing(FunctionToComparableValue)やcomparing(FunctionToValue, ValueComparator)などの静的メソッドがあり、オブジェクトの特定の値を比較する必要があるコンパレータを簡単に作成できます。

つまり、上記のコードを次のように書き換えることができます。

Collections.sort(contacts, Comparator.comparing(Contact::getAddress)); 
//assuming that Address implements Comparable (provides default order).
25
Pshemo

このページ は、ArrayListなどのコレクションの並べ替えについて知っておく必要があるすべての情報を提供します。

基本的にあなたがする必要がある

  • によってContactクラスにComparableインターフェイスを実装させます
    • その中にメソッドpublic int compareTo(Contact anotherContact)を作成します。
  • これを行うと、Collections.sort(myContactList);、を呼び出すことができます。
    • ここで、myContactListはArrayList<Contact>（またはContactのその他のコレクション）です。

Comparatorクラスの作成を含む別の方法もあり、リンクされたページからもそれについて読むことができます。

例：

public class Contact implements Comparable<Contact> {

    ....

    //return -1 for less than, 0 for equals, and 1 for more than
    public compareTo(Contact anotherContact) {
        int result = 0;
        result = getName().compareTo(anotherContact.getName());
        if (result != 0)
        {
            return result;
        }
        result = getNunmber().compareTo(anotherContact.getNumber());
        if (result != 0)
        {
            return result;
        }
        ...
    }
}
8
bguiz

BalusCとbguizは、Javaの組み込みコンパレータの使用方法について非常に完全な答えをすでに出しました。

Google-collectionsには、標準のコンパレータよりも「強力」な Ordering クラスがあることを追加します。チェックアウトする価値があるかもしれません。オブジェクトの関数の結果に応じて、順序付けの複合、反転、順序付けなどのクールなことを実行できます...

ここ は、その利点のいくつかを言及しているブログ投稿です。

5
Etienne Neveu

Contactクラスで Comparable を実装し、compareTo(Contact)メソッドを実装する必要があります。そうすれば、Collections.sortはそれらをあなたのためにソートすることができます。私がリンクしたページごとに、compareToは、このオブジェクトが指定されたオブジェクトより小さい、等しい、または大きいため、負の整数、ゼロ、または正の整数を返します。

たとえば、名前（AからZ）でソートする場合、クラスは次のようになります。

public class Contact implements Comparable<Contact> {

    private String name;

    // all the other attributes and methods

    public compareTo(Contact other) {
        return this.name.compareTo(other.name);
    }
}
4
Kaleb Brasee

lambdaj を使用すると、連絡先のコレクションを次のように（たとえば名前で）並べ替えることができます

sort(contacts, on(Contact.class).getName());

またはそれらのアドレスで：

sort(contacts, on(Contacts.class).getAddress());

等々。より一般的には、条件に基づいて連絡先をフィルタリングまたはグループ化する、プロパティ値の一部を集約するなど、さまざまな方法でコレクションにアクセスして操作するDSLを提供します.

3
Mario Fusco

次の方法でやった。番号と名前は2つの配列リストです。名前を並べ替える必要があります。名前の配列リストに何らかの変更が発生すると、配列番号リストの順序も変更されます。

public void sortval(){

        String tempname="",tempnum="";

         if (name.size()>1) // check if the number of orders is larger than 1
            {
                for (int x=0; x<name.size(); x++) // bubble sort outer loop
                {
                    for (int i=0; i < name.size()-x-1; i++) {
                        if (name.get(i).compareTo(name.get(i+1)) > 0)
                        {

                            tempname = name.get(i);

                            tempnum=number.get(i);


                           name.set(i,name.get(i+1) );
                           name.set(i+1, tempname);

                            number.set(i,number.get(i+1) );
                            number.set(i+1, tempnum);


                        }
                    }
                }
            }



}
0
sarath

この方法を使用します。

private ArrayList<myClass> sortList(ArrayList<myClass> list) {
    if (list != null && list.size() > 1) {
        Collections.sort(list, new Comparator<myClass>() {
            public int compare(myClass o1, myClass o2) {
                if (o1.getsortnumber() == o2.getsortnumber()) return 0;
                return o1.getsortnumber() < o2.getsortnumber() ? 1 : -1;
            }
        });
    }
    return list;
}

`

mySortedlist = sortList(myList);クラスにコンパレータを実装する必要はありません。逆順スワップが必要な場合1と-1

0
Bruno Mulas

Collections.sortは、適切なソートの実装です。 Contactに同等の実装がない場合は、 Comparator implementation を渡す必要があります。

注意事項：

ソートアルゴリズムは修正されたマージソートです（低サブリストの最上位要素が高サブリストの最下位要素よりも小さい場合、マージは省略されます）。このアルゴリズムは、n log（n）のパフォーマンスを保証します。指定されたリストは変更可能でなければなりませんが、サイズ変更可能である必要はありません。この実装は、指定されたリストを配列にダンプし、配列をソートし、配列内の対応する位置から各要素をリセットしてリストを反復処理します。これにより、リンクリストを所定の位置に並べ替えようとすることで生じるn2 log（n）のパフォーマンスが回避されます。

マージソートは、おそらく実行可能なほとんどの検索アルゴリズムよりも優れています。

0
Joshua