在java中对2D数组进行排序（对所有字母进行排序）

我想对以下2D数组进行排序：

String[][] rows = {
            {"M","O","N","K","E","Y"},
            {"D","O","N","K","E","Y"},
            {"M","A","K","E"},
            {"M","U","C","K","Y"},
            {"C","O","O","K","Y"},
            };

我希望得到以下结果：

A C C D E E E K K K K K M M M N N O O O O U Y Y Y Y

但是我不知道怎么做！！我找不到任何2D数组排序的好例子

如您所见，我不想按列或行排序，但我只想对数组中的所有字符进行排序。通过这种方式，我可以计算每个字符中有多少位于2D数组中

---

如果您知道如何计算2D数组中每个字符的数量，这对我来说也是一个很好的解决方案。

我听说您想计算唯一字符串的数量？使用以下命令：

    Map<String, Integer> counter = new HashMap<>();
    for (String[] row : rows) {
        for (String str : row) {
            if (counter.containsKey(str)) {
                counter.put(str, counter.get(str) + 1);
            } else {
                counter.put(str, 1);
            }
        }
    }
    System.out.println(counter);

Map counter=newhashmap（）；
for（字符串[]行：行）{
for（字符串str:row）{
if（集装箱柜（str））{
counter.put（str，counter.get（str）+1）；
}否则{
计数器放置（str，1）；
}
}
}
系统输出打印项次（计数器）；

---

如果要将输出排序为字典式的，请使用<代码> TetrMAP而不是<代码> HashMap < /代码>，并考虑使用<代码>字符< /代码>而不是<代码>字符串 >如果所有的都是单个字符。 这将使用

Collections.sort

将2D数组排序为

列表

对象

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

public class Test {
    public static void main(String[] args) {
        String[][] rows = {
                {"M","O","N","K","E","Y"},
                {"D","O","N","K","E","Y"},
                {"M","A","K","E"},
                {"M","U","C","K","Y"},
                {"C","O","O","K","Y"},
            };

        List<String> list = new ArrayList<String>();

        // Add all strings to list.
        for (String[] row : rows) {
            for (String s : row) {
                    list.add(s);
            }
        }

        Collections.sort(list); // Sort the list.
    }
}

---

对数组中的每一个字符进行计数，查看答案。

< P>我理解你想要一个唯一字符的计数，在一个2维的字符串数组中/每个字符串是1个字符，或者我们只考虑第一个。这段代码假设您希望将“A”计数与“A”分开，否则将字符串改为大写

如果您想要字符串数组（1D）中的字符，也可以这样做。以下是你问题中的2D

import java.util.*;
public class ChrCnt  {
    public static void main(String[] args){

        String[][] rows = {
            {"M","O","N","K","E","Y"},
            {"D","O","N","K","E","Y"},
            {"M","A","K","E"},
            {"M","U","C","K","Y"},
            {"C","O","O","K","Y"},
            };
            Map<Character, Integer> cnts = new HashMap<Character, Integer>();
            for(int i =0; i < rows.length; i++){
                for(int j =0; j < rows[i].length; j++){
                    Character c = rows[i][j].charAt(0);//or .toUpperCase().charAt(0);
                    Integer cnt = cnts.get(c);
                    int cc = 0;
                    if(cnt != null){
                        cc = cnt;
                    }
                    cc++;
                    cnts.put(c, cc);

                }
            }
            Set<Character> st = cnts.keySet();
            prnt(rows);
            int sz = st.size();
            Iterator<Character> it = st.iterator();
            System.out.println("------\nCounts\n");
            while(it.hasNext()){
                Character c = it.next();
                System.out.println(c +  " " + cnts.get(c));
            }


    }

    static void prnt(String[][] rows){

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

import java.util.*；
公共类ChrCnt{
公共静态void main（字符串[]args）{
字符串[][]行={
{“M”，“O”，“N”，“K”，“E”，“Y”}，
{“D”，“O”，“N”，“K”，“E”，“Y”}，
{“M”、“A”、“K”、“E”}，
{“M”、“U”、“C”、“K”、“Y”}，
{“C”，“O”，“O”，“K”，“Y”}，
};
Map cnts=新的HashMap（）；
for（int i=0；i

输出

猴子

驴子

制造

肮脏的

库克

计数

U 1

D 1

E3

A 1

C2

M3

n2

O 4

Y 4

---

K5是一种对二维数组中的每个字符进行排序的方法。我们将看到，通过更改ArrayDatum的数据成员以及如何实现Cmpr，您可以以不同的方式对其他对象进行排序，从而使Cmpr2、Cmpr3

public class ArrayDatum <T>{
    private int locX; //probably do not need this -> original location but keot it for future use
    private int locY;
    private T data;

    public ArrayDatum(T dat, int x, int y){
        data = dat;
        locX = x;
        locY = y;
    }

    public int getLocationX(){
        return locX;
    }

    public void setLocationX(int x){
        locX = x;
    }

    public int getLocationY(){
        return locY;
    }

    public void setLocationY(int y){
        locY = y;
    }

    public T getData(){
        return data;
    }

    public void setData(T d){
        data = d;
    }

}

公共类ArrayDatum{
private int locX；//可能不需要此->原始位置，但将其保留以备将来使用
私家车；
私有T数据；
公共阵列（T dat、int x、int y）{
数据=dat；
locX=x；
locY=y；
}
public int getLocationX（）{
返回locX；
}
公共无效设置位置x（int x）{
locX=x；
}
public int getLocationY（）{
返回洛西；
}
公共无效设置位置y（内部y）{
locY=y；
}
公共T getData（）{
返回数据；
}
公共无效设置数据（TD）{
数据=d；
}
}

//比较器

import java.util.Comparator;

/**
* Comparator for ArrayDatum<String>
* Else not predictable
*/
public class Cmpr  implements Comparator{

    public int compare(Object  c1, Object b1){

        ArrayDatum c = (ArrayDatum )c1;
        ArrayDatum b = (ArrayDatum )b1;
        if(c == null || b == null) return 0;
        return c.getData().toString().compareTo(b.getData().toString());
    }
}    

import java.util.Comparator；
/**
*ArrayDatum比较器
*否则不可预测
*/
公共类Cmpr实现了比较器{
公共整数比较（对象c1、对象b1）{
ArrayDatum c=（ArrayDatum）c1；
ArrayDatum b=（ArrayDatum）b1；
如果（c==null | | b==null）返回0；
返回c.getData（）.toString（）.compareTo（b.getData（）.toString（））；
}
}    

//测试应用程序

import java.util.*;
public class Tst  {
    public static void main(String[] args){

        String[][] rows = {
            {"M","O","N","K","E","Y"},
            {"D","O","N","K","E","Y"},
            {"M","A","K","E"},
            {"M","U","C","K","Y"},
            {"C","O","O","K","Y"},
            };
            prnt(rows);
            List<ArrayDatum> dat = new ArrayList<ArrayDatum>();
            for(int i =0; i < rows.length; i++){
                for(int j =0; j < rows[i].length; j++){
                    ArrayDatum<String> dt = new ArrayDatum<String>(rows[i][j], i, j);
                    dat.add(dt);
                }
            }
            Cmpr cmpr = new Cmpr();
            Collections.sort(dat, cmpr);
            int sz = dat.size();
            System.out.println("------\nsort\n");
            for(int i =0; i < sz; i++){
                System.out.print(dat.get(i).getData() + " " );
            }
            //for(int i =0; i < sz; i++){
            //  ArrayDatum d = dat.get(i);
            //  rows[d.getLocationX()][d.getLocationY()] = d.getData().toString();
            //}
            int loc = 0;

            /*
            lay them into original array again
            for(int i =0; i < rows.length; i++){
                for(int j =0; j < rows[i].length; j++){
                    rows[i][j] = dat.get(loc).getData().toString();
                    loc++;
                }
            }


            prnt(rows);*/


    }

    static void prnt(String[][] rows){

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

import java.util.*；
公共级Tst{
公共静态void main（字符串[]args）{
字符串[][]行={
{“M”，“O”，“N”，“K”，“E”，“Y”}，
{“D”，“O”，“N”，“K”，“E”，“Y”}，
{“M”、“A”、“K”、“E”}，
{“M”、“U”、“C”、“K”、“Y”}，
{“C”，“O”，“O”，“K”，“Y”}，
};
prnt（行）；
List dat=new ArrayList（）；
for（int i=0；iimport java.util.*;
public class Tst  {
    public static void main(String[] args){

        String[][] rows = {
            {"M","O","N","K","E","Y"},
            {"D","O","N","K","E","Y"},
            {"M","A","K","E"},
            {"M","U","C","K","Y"},
            {"C","O","O","K","Y"},
            };
            prnt(rows);
            List<ArrayDatum> dat = new ArrayList<ArrayDatum>();
            for(int i =0; i < rows.length; i++){
                for(int j =0; j < rows[i].length; j++){
                    ArrayDatum<String> dt = new ArrayDatum<String>(rows[i][j], i, j);
                    dat.add(dt);
                }
            }
            Cmpr cmpr = new Cmpr();
            Collections.sort(dat, cmpr);
            int sz = dat.size();
            System.out.println("------\nsort\n");
            for(int i =0; i < sz; i++){
                System.out.print(dat.get(i).getData() + " " );
            }
            //for(int i =0; i < sz; i++){
            //  ArrayDatum d = dat.get(i);
            //  rows[d.getLocationX()][d.getLocationY()] = d.getData().toString();
            //}
            int loc = 0;

            /*
            lay them into original array again
            for(int i =0; i < rows.length; i++){
                for(int j =0; j < rows[i].length; j++){
                    rows[i][j] = dat.get(loc).getData().toString();
                    loc++;
                }
            }


            prnt(rows);*/


    }

    static void prnt(String[][] rows){

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