Java 为什么不是'；我的方法不能按照我想要的方式对矩阵中的列进行排序吗？

我想获取用户输入的关键字，并按字母顺序排序，然后将其下的col置于排序后关键字字符的位置，例如：

之前：

   K E Y S
   V V V X 
   D V G G 
   D F D V 

之后：

   E K S Y
   V V X V
   V D G G
   F D V D

我的输出：

 E K S Y
 V V V X 
 D V G G 
 D F D V 

我的方法无法按我想要的方式对信息进行排序：

public String sortMatrix(String a [][]){



        System.out.println("\nAlphabetically rearranged: ");
        char[] key = polyCipher.getKeyword().toCharArray();
        char[] alphaKey = polyCipher.getKeyword().toCharArray();
        String alphaOut = "";

        //sort the key
        Arrays.sort(alphaKey);
        // set up temp array x

       //String a [][] = {{"V", "V", "V", "X"},{"D", "V", "G", "G"},{"D", "F", "D", "V"}};

        char[][] x = new char[a.length+1][];
        x[0] = alphaKey;

        for(int loop1 = 0; loop1 < a.length; loop1++){
            x[loop1+1] = new char[a[loop1].length];
            for (int loop2 = 0; loop2 < a[loop1].length; loop2++){
                x[loop1+1][loop2] = a[loop1][loop2].charAt(0);
            }
        }

        for(int loop1 = 0; loop1 < a.length; loop1++){
            x[loop1+1] = new char[a[loop1].length];
            for (int loop2 = 0; loop2 < a[loop1].length; loop2++){
                x[loop1+1][loop2] = a[loop1][loop2].charAt(0);
            }
        }


            /* x[0] = new char[]{'J', 'A', 'V', 'A'};
               x[1] = new char[]{'A', 'B', 'C', 'D'};
               x[2] = new char[]{'A', 'B', 'C', 'D'};
               x[3] = new char[]{'A', 'B', 'C', 'D'}; */


            String [] strArray = new String[x[0].length];

            for (int loop1 = 0; loop1 < x.length; loop1++){
                for (int loop2 = 0; loop2 < x[0].length; loop2++){
                    if(strArray[loop2] == null){
                        strArray[loop2] = "";
                    }
                    strArray[loop2] += x[loop1][loop2];
                }
            }

            Arrays.sort(strArray);


            for (int loop1 = 0; loop1 < strArray.length; loop1++){
                for (int loop2 = 0; loop2 < strArray[loop1].length(); loop2++){
                    x[loop2][loop1] = strArray[loop1].charAt(loop2);
                }
            }

            Arrays.sort(key);
            alphaOut += "\n";
            for (int i = 0; i < x.length; i++) {
           //     keyOut += PHRASE_KEY[i] + " ";
               for (int j = 0; j < x[i].length; j++) {
                   alphaOut += x[i][j] + " ";
                }
               alphaOut += "\n";
            }

           return alphaOut.toUpperCase();


    }

公共字符串sortMatrix（字符串a[]{
System.out.println（“\n按字母顺序重新排列：”）；
char[]key=polyCipher.getKeyword（）.toCharArray（）；
char[]alphaKey=polyCipher.getKeyword（）.toCharArray（）；
字符串alphaOut=“”；
//排序键
数组。排序（字母键）；
//设置临时阵列x
//字符串a[][]={{“V”、“V”、“V”、“X”}、{“D”、“V”、“G”、“G”}、{“D”、“F”、“D”、“V”}；
char[][]x=新字符[a.length+1][]；
x[0]=字母键；
for（int loop1=0；loop1

我稍微更改了代码。我希望它能帮助你。我知道应该对代码进行更改才能使其工作，但这里有一个工作示例：）

**

如果列的大小是固定的，则：

public static void main(String[] args) {
        String[] list = {"KVDD", "EVVF", "YVGD", "SXGV"};
        List<String> data = Arrays.asList(list);
        Collections.sort(data, new CustomComparator());
        int maxLen = 4;
        for (int i = 0; i < maxLen; i++) {
            for (String str : data) {
                System.out.print(str.charAt(i));
            }
            System.out.println();
        }
    }

publicstaticvoidmain（字符串[]args）{
字符串[]列表={“KVDD”、“EVVF”、“YVGD”、“SXGV”}；
列表数据=数组.asList（列表）；
Collections.sort（数据，新CustomComparator（））；
int maxLen=4；
对于（int i=0；i

我添加了二维排序。我用了气泡排序法。输出完全相同。2D排序更好，因为在关键部分可以有多个字符。字符串排序只查看第一个字符，它可能看起来像一个限制

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

/**
 *
 * @author Pasban
 */
public class sortmatrix {

    public static String[] sortString(String[] inp) {
        List<String> data = Arrays.asList(inp);
        Collections.sort(data, new CustomComparator());
        return data.toArray(new String[0]);
    }

    public static String[][] sortString2D(String[][] inp) {

        String[][] out = inp;

        //inp.length number columns
        for (int i = 0; i < inp.length; i++) { // bubble sort
            for (int j = i + 1; j < inp.length; j++) {
                if (out[i][0].compareTo(out[j][0]) > 0) { // string comparison :)
                    String[] tmp;
                    tmp = out[i];
                    out[i] = out[j];
                    out[j] = tmp;
                }
            }
        }

        return out;
    }

    public static void main(String[] args) {


        String[][] list2D = new String[][]{
            {"K", "V", "D", "D"},
            {"E", "V", "V", "F"},
            {"Y", "V", "G", "D"},
            {"S", "X", "G", "V"}
        };

        String[][] data2D = sortString2D(list2D);

        for (int j = 0; j < data2D[0].length; j++) {
            for (int i = 0; i < data2D.length; i++) {
                System.out.print(data2D[i][j]);
            }
            System.out.println();
        }

        System.out.println(" ----- ");


        String[] list = {"KVDD", "EVVF", "YVGD", "SXGV"};
        String[] data = sortString(list);

        int maxLen = data[0].length();
        for (int i = 0; i < maxLen; i++) {
            for (String str : data) {
                System.out.print(str.charAt(i));
            }
            System.out.println();
        }
    }

    public static class CustomComparator implements Comparator<String> {

        @Override
        public int compare(String o1, String o2) {
            return (o1.charAt(0) + "").compareTo(o2.charAt(0) + "");
        }
    }
}

导入java.util.array；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
/**
*
*@作者帕斯班
*/
公共类sortmatrix{
公共静态字符串[]排序字符串（字符串[]inp）{
列表数据=数组.asList（inp）；
Collections.sort（数据，新CustomComparator（））；
返回data.toArray（新字符串[0]）；
}
公共静态字符串[][]sortString2D（字符串[][]inp）{
字符串[][]out=inp；
//inp.length数字列
对于（inti=0；i0{//字符串比较：）
字符串[]tmp；
tmp=输出[i]；
out[i]=out[j]；
out[j]=tmp；
}
}
}
返回；
}
公共静态void main（字符串[]args）{
字符串[][]列表2D=新字符串[][]{
{“K”、“V”、“D”、“D”}，
{“E”、“V”、“V”、“F”}，
{“Y”、“V”、“G”、“D”}，
{“S”、“X”、“G”、“V”}
};
字符串[][]data2D=sortString2D（list2D）；
对于（int j=0；j

以下是我所做的更改：

在矩阵类中，填写矩阵[][]

发件人：

到

请注意，使用拆分（“”）时，第一项始终为空字符串。空字符串没有任何字符，因此获取第一个字符毫无意义。这让我犯了一些错误，但我终于发现了。嘿，你可以通过charAt（）直接得到char

public static void main(String[] args) {
        String[] list = {"KVDD", "EVVF", "YVGD", "SXGV"};
        List<String> data = Arrays.asList(list);
        Collections.sort(data, new CustomComparator());
        int maxLen = 4;
        for (int i = 0; i < maxLen; i++) {
            for (String str : data) {
                System.out.print(str.charAt(i));
            }
            System.out.println();
        }
    }

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

/**
 *
 * @author Pasban
 */
public class sortmatrix {

    public static String[] sortString(String[] inp) {
        List<String> data = Arrays.asList(inp);
        Collections.sort(data, new CustomComparator());
        return data.toArray(new String[0]);
    }

    public static String[][] sortString2D(String[][] inp) {

        String[][] out = inp;

        //inp.length number columns
        for (int i = 0; i < inp.length; i++) { // bubble sort
            for (int j = i + 1; j < inp.length; j++) {
                if (out[i][0].compareTo(out[j][0]) > 0) { // string comparison :)
                    String[] tmp;
                    tmp = out[i];
                    out[i] = out[j];
                    out[j] = tmp;
                }
            }
        }

        return out;
    }

    public static void main(String[] args) {


        String[][] list2D = new String[][]{
            {"K", "V", "D", "D"},
            {"E", "V", "V", "F"},
            {"Y", "V", "G", "D"},
            {"S", "X", "G", "V"}
        };

        String[][] data2D = sortString2D(list2D);

        for (int j = 0; j < data2D[0].length; j++) {
            for (int i = 0; i < data2D.length; i++) {
                System.out.print(data2D[i][j]);
            }
            System.out.println();
        }

        System.out.println(" ----- ");


        String[] list = {"KVDD", "EVVF", "YVGD", "SXGV"};
        String[] data = sortString(list);

        int maxLen = data[0].length();
        for (int i = 0; i < maxLen; i++) {
            for (String str : data) {
                System.out.print(str.charAt(i));
            }
            System.out.println();
        }
    }

    public static class CustomComparator implements Comparator<String> {

        @Override
        public int compare(String o1, String o2) {
            return (o1.charAt(0) + "").compareTo(o2.charAt(0) + "");
        }
    }
}

matrix[i][j] = validChars.split("")[random].charAt(0);

matrix[i][j] =  validChars.charAt(random);

public String[][] rotateMatrix(String inp[][]) {
    int L1 = inp.length;
    int L2 = inp[0].length;
    String[][] ret = new String[L2][L1];
    for (int i = 0; i < L1; i++) {
        for (int j = 0; j < L2; j++) {
            ret[j][i] = inp[i][j];
        }
    }
    return ret;
}

public String[][] sortMatrix(String a[][]) {

    System.out.println("\nAlphabetically rearranged: ");
    char[] key = polyCipher.getKeyword().toCharArray();

    //sort the key
    //Arrays.sort(alphaKey); // 

    //copy the array
    String[][] out = rotateMatrix(a);

    //inp.length number columns
    for (int i = 0; i < key.length; i++) { // bubble sort
        for (int j = i + 1; j < key.length; j++) {
            if (key[i] > key[j]) { // string comparison :)
                //sort the header
                char c = key[i];
                key[i] = key[j];
                key[j] = c;
                //sort the column
                String[] tmp;
                tmp = out[i];
                out[i] = out[j];
                out[j] = tmp;
            }
        }
    }

    System.out.print("Sorted Key: ");
    for (int i = 0; i < key.length; i++) {
        System.out.print(key[i]);
    }
    System.out.println();

    /*
    for (int i = 0; i < out.length; i++) {
    for (int j = 0; j < out[0].length; j++) {
    System.out.print(out[i][j]);
    }
    System.out.println();
    }*/

    return rotateMatrix(out);
}