Java 按LastName排序二维字符串数组，然后按FirstName排序，而不使用任何API

大家好，我对Java非常陌生。我想在字符串数组下面按照LastName排序，然后在FirstName上排序，而不使用任何API，即我不应该使用Arrays.sort（）、compareTo（）、equals（）等

输入数组字符串

String [][]name={{"Jen","Eric"},
              {"Brain","Adams"},
              {"Jon","Methew"},
              {"Antino","Ronald"},
              {"Cris","Ronald"}
             };

我的输出应该是这样的

             Brain,Adams
             Jen,Eric
             Jon,Methew
             Antino,Ronald
             Cris,Ronald

请帮忙

public class StringArraySort {

public static void main(String[] args) {



    //System.out.println(str.length);
    String [][]name={{"Jen","Eric"},
            {"Brain","Adams"},
            {"Jon","Methew"},
            {"Antino","Ronald"},
              {"Cris","Ronald"}
           };

    String []str1= new String [name.length];
    String []str2= new String [name.length];

    for(int i=1;i<name.length;i++)
    {
        int j=i;
        str1[i]=name[i][j];
        str2[i]=name[i-1][j];
        //System.out.println(str1[i]+" "+str2[i]);


    }

    /*for(String tmp:name)
    {
        char a[] = new char[tmp.length()] ;
        //System.out.println(tmp);
        for(int i=0;i<tmp.length();i++)
        {
            a[i]=tmp.charAt(i);
            System.out.println(a[i]);
        }
    }*/
}

公共类StringArraySort{
公共静态void main（字符串[]args）{
//系统输出打印长度（str.length）；
字符串[][]名称={{{“Jen”，“Eric”}，
{“大脑”，“亚当斯”}，
{“Jon”，“Methew”}，
{“安蒂诺”，“罗纳德”}，
{“克里斯”，“罗纳德”}
};
String[]str1=新字符串[name.length]；
String[]str2=新字符串[name.length]；
对于（int i=1；i我不会给你任何代码，因为这显然是一个任务，但这里有一些一般性的指导：

不要试图将所有内容放入
main
。可能不允许使用任何现有API，但可以定义自己的API！编写自己的
compare
和
sort
方法
从方法
compare（String，String）->int
或
isSmaller（String，String）->boolean
开始。使用
String.toCharArray
从两个字符串中获取单个字符并成对比较。确保处理长度不同的字符串的大小写
现在编写一个方法
compare（String[]，String[]）->int
。这个方法看起来非常类似于上面的方法（事实上，您可以为这两种方法创建一个通用的方法），但是对于“lastname firstname”情况，将这个方法指定为特定的方法可能更简单，特别是因为您希望首先按第二个元素进行排序
最后，编写您自己的排序方法。就地气泡排序应该是最简单的，并且可以在internet上轻松找到该算法。其他排序算法更快，但如果速度有问题，则不使用任何API的要求首先是毫无意义的。不过，如果您想获得额外分数，您可以尝试在pla中实现ce快速排序，但只有在使用气泡排序运行之后
另外，您应该单独测试这些方法。在确保
比较
方法实际工作之前，不要尝试运行
排序
方法。使用不同的输出分别调用它们，看看它们是否产生正确的结果。
为了让您至少学到一些东西，我将给您介绍答案用psuedo代码表示，并让您进行编码。解决方案基于冒泡排序和通过循环字符比较名称（=字符串）

在冒泡排序中，我们对数组进行迭代，在每次迭代中，我们比较两个相邻的单元格，并可能交换它们，以便它们的顺序正确。
在第一次迭代结束时，最大的单元将位于正确的位置（=最后一个）。因此，我们开始另一次迭代，但跳过最后一个单元。在第二次迭代结束时，第二大单元将位于正确的位置。我们继续迭代，每次遍历一个较少的单元，直到没有更多的单元可迭代

我给你比较的方法：
该解决方案假定允许您调用String类的
length（）
和
charAt（）
方法

/**
 * returns negative, zero or positive value 
 * if s1 is smaller, equal or bigger than s2, respectively
 * comparison is lexicographical
 */
static int compareStrings(String s1, String s2)
{
    int i = 0;
    for (i = 0; i < s1.length() && i < s2.length(); i++) {
        int diff = s1.charAt(i) - s2.charAt(i);
        if (diff != 0) return diff;
    }
    if (i == s1.length()) {
        if (i == s2.length()) return 0; // equal lengths
        else return 1; // exhausted s2 before s1
    }
    return -1; // exhausted s1 before s2
}

/**
*返回负值、零值或正值
*如果s1分别小于、等于或大于s2
*比较是词典编纂的
*/
静态整数比较字符串（字符串s1、字符串s2）
{
int i=0；
对于（i=0；i

看到代码中的循环，我认为最后一点是正确的：您应该知道Java中的数组以索引0开头，最后一个单元格的长度为-1。
public class NameSort{
public class NameSort {

    public static void main(String[] args) {

        String [][] names={{"Jen","Eric"},
          {"Brain","Adams"},
          {"Jon","Methew"},
          {"Antino","Ronald"},
          {"Cris","Ronald"}
         };

        for(int m=0;m<names.length;m++)
        {
            for(int n=m+1;n<names.length;n++)
            {
                if(myCompare(names[m][1],names[n][1])==1)
                {
                    swap(names, names[m], names[n], m, n);
                }
                else if (myCompare(names[m][1],names[n][1])==0)
                {
                    if(myCompare(names[m][0],names[n][0])==1)
                    {
                        swap(names, names[m], names[n], m, n);
                    }
                }
            }
        }
        for (int i=0;i<names.length;i++)
        {
            System.out.println(names[i][0]+" " +names[i][1] );
        }

    }

    public static void swap(String [][] names,String[] a,String[] b,int m,int n)
    {
        names[n]=a;
        names[m]=b;
    }

    public static int myCompare(String a, String b)
    {
        int minLength= a.length()<b.length()?a.length():b.length();
        for(int i=0;i<minLength;i++)
        {
            if(a.charAt(i)>b.charAt(i))
            {
                return 1;
            }
            else if(a.charAt(i)<b.charAt(i)){
                return -1;
            }
        }
        if(a.length()>minLength)
            return 1;
        else if (b.length()> minLength )
            return -1;
        else
            return 0;
    }
}

公共静态void main（字符串[]args）{
字符串[][]名称={{{“Jen”，“Eric”}，
{“大脑”，“亚当斯”}，
{“Jon”，“Methew”}，
{“安蒂诺”，“罗纳德”}，
{“克里斯”，“罗纳德”}
};
对于（int m=0；mUsing bogosort将是最简单的。随机洗牌数组并检查它是否已排序。如果未排序，请重复。编写自己的
equals（）
方法并不困难，但您可以开始在char级别比较字符串。您可以使用
someString.charAt（）
两者都要做。然后实现你想要的任何排序算法。@Manu你建议如何在没有任何随机方法的情况下进行洗牌？我认为气泡排序是没有方法最容易做到的。请通过向上投票和/或接受来显示你的感谢