Java 如何在忽略区分大小写的情况下按字母顺序排序？

我有这个代码，但只适用于小写字母。我想让它在忽略大写字母的同时对列表进行排序

package sortarray.com;

import java.util.ArrayList;
import java.util.List;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

public class SortArray extends Activity {
    ArrayList<String[]> matchedFruits = new ArrayList<String[]>();
    TextView selection;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        String fruits[] = new String[7];// Sorted array
        fruits[0] = "apple";
        fruits[1] = "apricot";
        fruits[2] = "banana";
        fruits[3] = "mango";
        fruits[4] = "melon";
        fruits[5] = "pineapple";
        fruits[6] = "peach";
        char currChar = fruits[0].charAt(0);// Get first char of first element

        boolean match = false;
        int len = fruits.length;
        List<String> tmp = new ArrayList<String>();

        for (int i = 1; i < len; i++) {
            Log.d("Comparing ", fruits[i].charAt(0) + "," + currChar);
            if (fruits[i].charAt(0) == currChar) {
                if (match == false)// new match?
                {
                    match = true;// Reset search
                    tmp.clear();// clear existing items
                    tmp.add(fruits[i - 1]);
                    Log.d("Started new list ", fruits[i - 1]);
                } else {
                    tmp.add(fruits[i - 1]);
                    Log.d("Added to list ", fruits[i - 1]);
                }
            } else {
                match = false;
                tmp.add(fruits[i - 1]);
                matchedFruits.add(tmp.toArray(new String[tmp.size()]));// add to
                                                                        // final
                                                                        // list
                Log.d("Finished a list ", fruits[i - 1]);
                tmp.clear();// clear existing items

            }
            currChar = fruits[i].charAt(0);

        }
        tmp.add(fruits[len - 1]);
        matchedFruits.add(tmp.toArray(new String[tmp.size()]));// add left over
                                                                // items
        printList();
    }

    void printList()
    {
    //Print the list 
        TextView selection = (TextView) findViewById(R.id.tv);
        String mssg="";
    for(int i=0;i<matchedFruits.size();i++)
    {
            String tmp2[]= matchedFruits.get(i);

            for (int j = 0; j < tmp2.length; j++) {
                //Log.d("Final list", "Array #" + i + "[" + j + "]," + tmp2[j]);
                mssg += tmp2[j].toString();

            }
            //selection.setText("\n");
            selection.setText(mssg);

    }
    }
}

package sortarray.com；
导入java.util.ArrayList；
导入java.util.List；
导入android.app.Activity；
导入android.os.Bundle；
导入android.util.Log；
导入android.widget.TextView；
公共类Sortaray扩展活动{
ArrayList matchedFruits=新的ArrayList（）；
文本视图选择；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
字符串结果[]=新字符串[7]；//已排序数组
水果[0]=“苹果”；
水果[1]=“杏”；
水果[2]=“香蕉”；
水果[3]=“芒果”；
水果[4]=“甜瓜”；
水果[5]=“菠萝”；
水果[6]=“桃”；
char currChar=fruits[0]。charAt（0）；//获取第一个元素的第一个字符
布尔匹配=假；
int len=水果长度；
List tmp=new ArrayList（）；
对于（int i=1；i对于（int i=0；i您是否尝试过在
if（fruits[i].charAt（0）=currChar）
和
char currChar=fruits[0].charAt（0）
语句中将字符串的第一个字符转换为小写？
不清楚您想做什么，但您可以对列表进行如下排序：

List<String> fruits = new ArrayList<String>(7);

fruits.add("Pineapple");
fruits.add("apple");
fruits.add("apricot");
fruits.add("Banana");
fruits.add("mango");
fruits.add("melon");        
fruits.add("peach");

System.out.println("Unsorted: " + fruits);

Collections.sort(fruits, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {              
        return o1.compareToIgnoreCase(o2);
    }
});

System.out.println("Sorted: " + fruits);

 private static final Comparator<String> MYSTRING_COMPARATOR = new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
      return s1.compareToIgnoreCase(s2);
    }
  };

  public static Comparator<String> getMyStringComparator() {
    return MYSTRING_COMPARATOR;

List<String> myArray = new ArrayList<String>();
//fill your array here    
Collections.sort(MyArray, MyComparators. getMyStringComparator());

public class UserBean implements Comparable<UserBean> {

   private String name;
   private String surname;        
   private Integer phone;

   // GETTERS AND SETTERS

   public int compareTo(UserBean bean) {
       return name.compareToIgnoreCase(bean.name);
   }

}

myList.sort(String.CASE_INSENSITIVE_ORDER); // reads as the problem statement and cleaner

List fruits=newarraylist（7）；
水果。加入（“菠萝”）；
水果。添加（“苹果”）；
水果。添加（“杏”）；
水果。添加（“香蕉”）；
水果。添加（“芒果”）；
水果。添加（“甜瓜”）；
水果。添加（“桃子”）；
System.out.println（“未分类：+水果）；
Collections.sort（水果，新比较器（）{
@凌驾
公共整数比较（字符串o1，字符串o2）{
返回o1.比较信号（o2）；
}
});
System.out.println（“分类：+水果）；
下面是一个简单的java示例，它说明了最好的方法：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Sorter {
    String fruits[] = new String[7];
    List<String> lst;

    Sorter() {
        lst = new ArrayList<String>();
        // initialise UNSORTED array
        fruits[0] = "Melon"; fruits[1] = "apricot"; fruits[2] = "peach";
        fruits[3] = "mango"; fruits[4] = "Apple";   fruits[5] = "pineapple";
        fruits[6] = "banana";
    }

    public static void main(String[] args) {
        Sorter srt = new Sorter();
        srt.anyOldUnstaticMethod();

    }
    public void anyOldUnstaticMethod() {
        Collections.addAll(lst, fruits);
        System.out.println("Initial List");
        for (String s : lst)
            System.out.println(s);
        Collections.sort(lst);
        System.out.println("\nSorted List");
        for (String s : lst)
            System.out.println(s);
        Collections.sort(lst, new SortIgnoreCase());
        System.out.println("\nSorted Ignoring Case List");
        for (String s : lst)
            System.out.println(s);
    }

    public class SortIgnoreCase implements Comparator<Object> {
        public int compare(Object o1, Object o2) {
            String s1 = (String) o1;
            String s2 = (String) o2;
            return s1.toLowerCase().compareTo(s2.toLowerCase());
        }
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
公共类分拣机{
串水果[]=新串[7]；
列表lst；
分拣机（）{
lst=新的ArrayList（）；
//初始化未排序的数组
水果[0]=“瓜”；水果[1]=“杏”；水果[2]=“桃”；
水果[3]=“芒果”；水果[4]=“苹果”；水果[5]=“菠萝”；
水果[6]=“香蕉”；
}
公共静态void main（字符串[]args）{
分拣机srt=新分拣机（）；
srt.anyOldUnstaticMethod（）；
}
public void anyOldUnstaticMethod（）{
集合。添加所有（第一阶段，水果）；
System.out.println（“初始列表”）；
用于（字符串s:lst）
系统输出打印项次；
集合。排序（lst）；
System.out.println（“\n被选中的列表”）；
用于（字符串s:lst）
系统输出打印项次；
Collections.sort（lst，new SortIgnoreCase（））；
System.out.println（“\n忽略案例列表”）；
用于（字符串s:lst）
系统输出打印项次；
}
公共类SortIgnoreCase实现了Comparator{
公共整数比较（对象o1、对象o2）{
字符串s1=（字符串）o1；
字符串s2=（字符串）o2；
返回s1.toLowerCase（）.compareTo（s2.toLowerCase（））；
}
}
}
我喜欢comparator类
SortIgnoreCase
，但我会使用它

public class SortIgnoreCase implements Comparator<String> {
    public int compare(String s1, String s2) {
        return s1.compareToIgnoreCase(s2);    // Cleaner :)
    }
}

公共类SortIgnoreCase实现了Comparator{
公共整数比较（字符串s1、字符串s2）{
返回s1.compareToIgnoreCase（s2）；//Cleaner:）
}
}
使用集合和数组列表的示例：

开发一个实习生静态类，如“CompareStrings”示例

在main方法中调用intern静态类

易于理解，工作良好

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class MainClass {
    public static void main(String[] args) {
        ArrayList<String> myArray = new ArrayList<String>();
        myArray.add("zzz");
        myArray.add("xxx");
        myArray.add("Aaa");
        myArray.add("bb");
        myArray.add("BB");
        Collections.sort(myArray, new MainClass.CompareStrings());
        for(String s : myArray) {
            System.out.println(s);
        }
    }

    public static class CompareStrings implements Comparator<String> {
        @Override
        public int compare(String s1, String s2) {
           return s1.compareToIgnoreCase(s2);
        }
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
公共类主类{
公共静态void main（字符串[]args）{
ArrayList myArray=新的ArrayList（）；
myArray.add（“zzz”）；
myArray.add（“xxx”）；
myArray.add（“Aaa”）；
myArray.add（“bb”）；
myArray.add（“BB”）；
Collections.sort（myArray，newmainclass.CompareStrings（））；
for（字符串s:myArray）{
系统输出打印项次；
}
}
公共静态类CompareStrings实现Comparator{
@凌驾
公共整数比较（字符串s1、字符串s2）{
返回s1.compareToIgnoreCase（s2）；
}
}
}
在comparator factory类中，执行以下操作：
Collections.sort(caps, String.CASE_INSENSITIVE_ORDER);

        ArrayList<String> myArray = new ArrayList<String>();
        myArray.add("zzz");
        myArray.add("xxx");
        myArray.add("Aaa");
        myArray.add("bb");
        myArray.add("BB");
        Collections.sort(myArray,Collator.getInstance());

public class UserBean implements Comparable<UserBean> {

   private String name;
   private String surname;        
   private Integer phone;

   // GETTERS AND SETTERS

   public int compareTo(UserBean bean) {
       return name.compareToIgnoreCase(bean.name);
   }

}

import java.text.Collator;
import java.util.Arrays;

public class Main {
  public static void main(String args[]) {

    String[] myArray = new String[] { "A", "B", "b" };
    Arrays.sort(myArray, Collator.getInstance());

  System.out.println(Arrays.toString(myArray));

 }

}

List<String> fruits = Arrays.asList("apple", "Apricot", "banana");

List<String> sortedFruit = fruits.stream()
      .sorted(String.CASE_INSENSITIVE_ORDER)
      .collect(Collectors.toList())

myList.sort(String.CASE_INSENSITIVE_ORDER); // reads as the problem statement and cleaner

myList.sort(String::compareToIgnoreCase);  // reads as the problem statement and cleaner

String[] names = {"Alexis", "Tim", "Kyleen", "KRISTY"};

  Arrays.sort(names, String::compareToIgnoreCase);