Sắp xếp danh sách mảng theo thứ tự bảng chữ cái (không phân biệt chữ hoa chữ thường)

Tôi có một danh sách mảng chuỗi nameschứa tên của mọi người. Tôi muốn sắp xếp danh sách mảng theo thứ tự bảng chữ cái.

ArrayList<String> names = new ArrayList<String>();
names.add("seetha");
names.add("sudhin");
names.add("Swetha");
names.add("Neethu");
names.add("ananya");
names.add("Athira");
names.add("bala");
names.add("Tony");
names.add("Karthika");
names.add("Nithin");
names.add("Vinod");
names.add("jeena");
Collections.sort(names);
for(int i=0; i<names.size(); i++)
    System.out.println(names.get(i));

Tôi đã cố gắng sắp xếp danh sách theo cách trên. Nhưng nó đang hiển thị mảng được sắp xếp là:

Athira
Karthika
..
..
ananya
bala
...

nhưng tôi không muốn phân biệt chữ hoa chữ thường. Tôi muốn kết quả là:

ananya
Athira
bala

Tùy chỉnh Comparatorsẽ giúp

Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareToIgnoreCase(s2);
    }
});

Hoặc nếu bạn đang sử dụng Java 8:

list.sort(String::compareToIgnoreCase);

Điều đơn giản nhất để làm là:

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

thử mã này

Collections.sort(yourarraylist, new SortBasedOnName());



import java.util.Comparator;
import com.RealHelp.objects.FBFriends_Obj;
import com.RealHelp.ui.importFBContacts;

public class SortBasedOnName implements Comparator
{
public int compare(Object o1, Object o2) 
{

    FBFriends_Obj dd1 = (FBFriends_Obj)o1;// where FBFriends_Obj is your object class
    FBFriends_Obj dd2 = (FBFriends_Obj)o2;
    return dd1.uname.compareToIgnoreCase(dd2.uname);//where uname is field name
}

}

Dựa trên các câu trả lời được đề cập ở trên, tôi đã quản lý để so sánh các Đối tượng Lớp tùy chỉnh của mình như sau:

ArrayList<Item> itemList = new ArrayList<>();
...
Collections.sort(itemList, new Comparator<Item>() {
            @Override
            public int compare(Item item, Item t1) {
                String s1 = item.getTitle();
                String s2 = t1.getTitle();
                return s1.compareToIgnoreCase(s2);
            }

        });

Bạn cần sử dụng bộ so sánh tùy chỉnh sẽ sử dụng compareToIgnoreCase, không phải so sánhTo.

Bắt đầu từ Java 8, bạn có thể sử dụng Stream:

List<String> sorted = Arrays.asList(
                          names.stream().sorted(
                              (s1, s2) -> s1.compareToIgnoreCase(s2)
                          ).toArray(String[]::new)
                      );

Nó nhận được một luồng từ đó ArrayList, sau đó nó sắp xếp nó (bỏ qua trường hợp). Sau đó, luồng được chuyển đổi thành một mảng được chuyển thành một ArrayList.

Nếu bạn in kết quả bằng:

System.out.println(sorted);

bạn nhận được kết quả sau:

[ananya, Athira, bala, jeena, Karthika, Neethu, Nithin, seetha, sudhin, Swetha, Tony, Vinod]

Thật không may, tất cả các câu trả lời cho đến nay không tính đến điều đó "a"không được coi là bình đẳng "A"khi nói đến phân loại.

String[] array = {"b", "A", "C", "B", "a"};

// Approach 1
Arrays.sort(array);
// array is [A, B, C, a, b]

// Approach 2
Arrays.sort(array, String.CASE_INSENSITIVE_ORDER);
// array is [A, a, b, B, C]

// Approach 3
Arrays.sort(array, java.text.Collator.getInstance());
// array is [a, A, b, B, C]

Trong cách tiếp cận 1, bất kỳ chữ thường nào được coi là lớn hơn bất kỳ chữ hoa nào.

Phương pháp 2 làm cho nó tồi tệ hơn, vì CASE_INSENSITIVE_ORDER xem xét "a"và "A"bằng nhau (kết quả so sánh là 0). Điều này làm cho việc sắp xếp không xác định.

Cách tiếp cận 3 (sử dụng java.text.Collator) là IMHO là cách duy nhất để thực hiện chính xác, vì nó xem xét "a"và "A"không bình đẳng, nhưng đặt chúng theo thứ tự chính xác theo ngôn ngữ hiện tại (hoặc bất kỳ ngôn ngữ mong muốn nào khác).