Java 按名字和姓氏对多维字符串数组排序

我的一个Java类分配要求我对多维字符串数组进行排序。它还需要输入您是想按名字排序还是按姓氏排序。我不太理解这个问题的措辞，也就是主要的排序和粗体部分，所以我会把它贴在这里

A部分：多维数组 编写一个程序，使用以下标题对二维数组进行排序：

Public static void sort string ( nameSort [][]  )

该方法应先对行执行主排序，然后对列执行主排序

使用以下数据测试您的程序：

{  
 {“Bill”,”Jones”}, 
 {“Janet”,”Kline”},
 {“George”,”Bailey”}, 
 {“Ellan”,”Sanches”}, 
 {“Tom”,”Nguyen”}, 
 {“William”,”Walters}, 
 {“Author”,”James”}, 
 {“Henry”,”Daniels”}, 
 {“Mike”,”Franklin”}, 
 {“Julie”,”Andrews"}
}

您的程序应该询问您是希望数组按名字排序还是按最后一个sName排序

数组中的行将包含名字。sortArray中的列将包含姓氏。

---

根据我对这个问题的理解，这个问题只是要求您编写一个程序，根据名字或姓氏对数组进行排序，以数组的形式分别提供这两个字段

不过，这个问题的措辞很奇怪。我认为“行和列”实际上是指“数组的第一个和第二个元素”。我找不到更好的解释

问题没有明确说明是否允许使用方便的库方法，如

Arrays.sort（）

。实际上，

Arrays.sort（）

由于其方便性，我会使用它。如果需要显式编写排序代码，请告诉我，我也可以编写

另外，在设置比较器时，我使用了lambda语句，这是Java8+的一个特性。如果使用Java 7，则使用匿名类

代码：

//测试数组。
字符串[][]test={{“Bill”，“Jones”}，{“Janet”，“Kline”}，{“George”，“Bailey”}，
{“Ellan”、“Sanches”}、{“Tom”、“Nguyen”}、{“William”、“Walters”}、{“Author”、“James”}、，
{“亨利”、“丹尼尔斯”}、{“迈克”、“富兰克林”}、{“朱莉”、“安德鲁斯”}；
//打印未排序的数组。
System.out.println（“未排序数组：”）；
for（字符串[]strArr:test）
{
System.out.println（strArr[0]+“”+strArr[1]）；
}
扫描仪输入=新扫描仪（System.in）；
比较器c；
//循环直到输入正确。
while（true）
{
System.out.println（“按名字或姓氏排序？”）；
System.out.println（“键入f代表名字，或键入l代表姓氏”）；
字符串in=input.nextLine（）；
如果（in.等于（“f”））
{
//将comparator设置为按名字然后按姓氏进行比较。
c=（a1，a2）->
{
int result=a1[0]。与（a2[0]）进行比较；
如果（结果==0）
{
结果=a1[1]。与（a2[1]）相比；
}
返回结果；
};
打破
}
如果（单位：等于（“l”））
{
//将comparator设置为按姓氏然后按姓氏进行比较。
c=（a1，a2）->
{
int result=a1[1]。与（a2[1]）进行比较；
如果（结果==0）
{
结果=a1[0]。与（a2[0]）相比；
}
返回结果；
};
打破
}
System.out.println（“非法输入，请重试”）；
}
//排序。
数组。排序（test，c）；
//打印排序数组。
System.out.println（“排序完成。排序数组：”）；
for（字符串[]strArr:test）
{
System.out.println（strArr[0]+“”+strArr[1]）；
}

通过选择排序对名称进行排序，使用标志确定是否应按名字或姓氏排序

public static void main(String[] args) {
   String[][] names = 
   {{"Bill","Jones"}, 
    {"Janet","Kline"},
    {"George","Bailey"}, 
    {"Ellan","Sanches"}, 
    {"Tom","Nguyen"}, 
    {"William","Walters"}, 
    {"Author","James"}, 
    {"Henry","Daniels"}, 
    {"Mike","Franklin"}, 
    {"Julie","Andrews"}};
   print(names);
   sortNames(names, true);
    System.out.println("-----");
    print(names);
}

public static void print(String[][] name) {
    int n = name.length;
    for (int i = 0; i < n; i++) {
        System.out.println(name[i][0] + " " + name[i][1]);
    }
}

private static void swap(String[][] name, int i, int j) {
    String firstName = name[i][0];
    String lastName = name[i][1];
    name[i][0] = name[j][0];
    name[j][0] = firstName;
    name[i][1] = name[j][1];
    name[j][1] = lastName;
}

public static void sortNames(String[][] name, boolean orderByFirst) {
    int n = name.length;      
    for (int i = 0; i < n - 1; i++) {
        int f = i;
        for (int j = i; j < n; j++) {
            // Sort on first name
            if (orderByFirst) {
                int compFirstName = name[f][0].compareTo(name[j][0]);
                if (compFirstName > 0) {
                    f = j;
                }
                // Same fist name, sort on last name
                else if (compFirstName == 0 && name[f][1].compareTo(name[j][1]) > 0) {
                    f = j;
                }
            } else {
               // sort by last name instead
               int comptLastName = name[f][1].compareTo(name[j][1]);
                if (comptLastName > 0) {
                    f = j;
                }
                // Same last name, sort on first name
                else if (comptLastName == 0 && name[f][0].compareTo(name[j][0]) > 0) {
                    f = j;
                }
            }
        }
        swap(name, i, f);
    }
}

输出（按姓氏排序）：

---

以下是使用Java 8的最低限度代码：

    public static void sort2DArray(boolean sortByFirstName) {
        System.out.println("***** Sorting 2D Array *****");
        String[][] arr = {{"Bill","Jones"}, 
                            {"Janet","Kline"},
                            {"George","Bailey"}, 
                            {"Ellan","Sanches"}, 
                            {"Tom","Nguyen"}};
        List<String> l =  convertToList(arr);
        System.out.println("List = "+l.toString());
        if(sortByFirstName)
            Collections.sort(l, (s1, s2) -> s1.split(" ")[0].compareTo(s2.split(" ")[0]));
        else
            Collections.sort(l, (s1, s2) -> s1.split(" ")[1].compareTo(s2.split(" ")[1]));
        System.out.println("Sorted List = "+l.toString());


    }

    public static List<String> convertToList(String[][] arr){
        List<String> l8 = Arrays.asList(arr).stream().map(a -> a[0] + " "+ a[1]).collect(Collectors.toList());
        return l8;
    }

publicstaticvoidsort2darray（布尔sortByFirstName）{
System.out.println（“****排序2D数组*******”）；
字符串[][]arr={{“比尔”，“琼斯”}，
{“珍妮特”，“克莱恩”}，
{“乔治”，“贝利”}，
{“Ellan”，“Sanches”}，
{“汤姆”、“阮”}；
列表l=转换器列表（arr）；
System.out.println（“List=“+l.toString（））；
如果（sortByFirstName）
Collections.sort（l，（s1，s2）->s1.split（“”[0]。compareTo（s2.split（“”[0]）；
其他的
Collections.sort（l，（s1，s2）->s1.split（“”[1]。compareTo（s2.split（“”[1]）；
System.out.println（“排序列表=“+l.toString（））；
}
公共静态列表转换器列表（字符串[][]arr）{
List l8=Arrays.asList（arr.stream（）.map（a->a[0]+“”+a[1]）.collect（Collectors.toList（））；
返回l8；
}

说明： 1.首先将2D数组转换为字符串列表

然后根据比较器对列表进行排序

---

首先，让我们为要管理的顺序定义一个枚举。这将保存我们要用于排序的索引

private enum SortType { 
    FIRSTNAME(1, 0), 
    LASTNAME(0, 1);

    int sortIndex;
    int sortIndex2;

    private SortType(int sortIndex, int sortIndex2){
        this.sortIndex = sortIndex;
        this.sortIndex2 = sortIndex2;
    }
}

注意：这可能是一个数组，允许我们定义无限量的“回退”列

然后，我们需要做的就是创建比较器，根据这两个索引进行排序：

private static void sort(String[][] array, SortType type){
    Arrays.sort(array, (a1, a2) -> {
        int r = a1[type.sortIndex].compareTo(a2[type.sortIndex]);
        return r == 0 ? a1[type.sortIndex2].compareTo(a2[type.sortIndex2]) : r; 
    });
}

让我们创建从用户获取输入的方法：

private static SortType getType(Scanner sc){
    boolean again = false;
    String input;

    System.out.println("Sort option.\n1 : Firstname\n2: Lastname");
    SortType type = null;

    //Get a valid input for the type.
    do{
        input = sc.nextLine().trim();
        if(input.equals("1")){
            type = SortType.FIRSTNAME;
            again = false;
        } else if(input.equals("2")){
            type = SortType.LASTNAME;
            again = false;
        } else {
            System.out.println("Bad input, try again");
            again = true;
        }
    }while(again);

    return type;
}

让我们运行它：

public static void main(String... args) {
    String[][] array = { { "Bill", "Jones" }, { "Janet", "Kline" }, { "George", "Bailey" }, { "Ellan", "Sanches" }, { "Tom", "Nguyen" },
            { "William", "Walters" }, { "Author", "James" }, { "Henry", "Daniels" }, { "Mike", "Franklin" }, { "Julie", "Andrews" } };

    System.out.println(Arrays.deepToString(array));

    Scanner sc = new Scanner(System.in);
    SortType type = getType(sc);
    sc.close();

    //Sort the array
    sort(array, type);

    //Print the array
    System.out.println(Arrays.deepToString(array)); 
}

[[比尔，琼斯]，[珍妮特，克莱恩]，[乔治，贝利]，[埃兰，桑奇]，[汤姆，阮]，[威廉，沃尔特斯]，[作家，詹姆斯]，[亨利，丹尼尔斯]，[迈克，富兰克林]，[朱莉，安德鲁斯]
排序选项。
1：名字
2：姓氏
sa
输入错误，请重试
5
输入错误，请重试
2
[[作者，詹姆斯]，[比尔，琼斯]，[艾伦，桑奇]，[乔治，贝利]，[亨利，丹尼尔斯]，[珍妮特，克莱恩]，[朱莉，安德鲁斯]，[迈克，富兰克林]，[汤姆，阮]，[威廉，沃尔特斯]]

---

恐怕我也不完全明白。我建议你和设定任务的人谈谈，让他们澄清要求。毕竟，那个人是唯一一个真正

private static void sort(String[][] array, SortType type){
    Arrays.sort(array, (a1, a2) -> {
        int r = a1[type.sortIndex].compareTo(a2[type.sortIndex]);
        return r == 0 ? a1[type.sortIndex2].compareTo(a2[type.sortIndex2]) : r; 
    });
}

private static SortType getType(Scanner sc){
    boolean again = false;
    String input;

    System.out.println("Sort option.\n1 : Firstname\n2: Lastname");
    SortType type = null;

    //Get a valid input for the type.
    do{
        input = sc.nextLine().trim();
        if(input.equals("1")){
            type = SortType.FIRSTNAME;
            again = false;
        } else if(input.equals("2")){
            type = SortType.LASTNAME;
            again = false;
        } else {
            System.out.println("Bad input, try again");
            again = true;
        }
    }while(again);

    return type;
}

public static void main(String... args) {
    String[][] array = { { "Bill", "Jones" }, { "Janet", "Kline" }, { "George", "Bailey" }, { "Ellan", "Sanches" }, { "Tom", "Nguyen" },
            { "William", "Walters" }, { "Author", "James" }, { "Henry", "Daniels" }, { "Mike", "Franklin" }, { "Julie", "Andrews" } };

    System.out.println(Arrays.deepToString(array));

    Scanner sc = new Scanner(System.in);
    SortType type = getType(sc);
    sc.close();

    //Sort the array
    sort(array, type);

    //Print the array
    System.out.println(Arrays.deepToString(array)); 
}