关于二维数组的问题，

Question

现在有1-30这三十个数字，然后后边有三十个数字是跟这三十个数字有关的数字，然后要根据后边这些数字排序，应该采取那种方法，自己能想到的是用二维数组，举例：
[1][10]
[2][20]
[3][90]
[4][50]
[5][30]
[6][60]
[7][100]
[8][200]
[9][40]
...
排序后：
[1][10]
[2][20]
[5][30]
[9][40]
[4][50]
[6][60]
[3][90]
[7][100]
[8][200]

由于这样比较起来不方便，求更好的方法

Answer 1

我能想到的只是for历遍来排序了

Answer 2

历遍顺口吗遍历：
For(String s:st) 
遍历数组的传统方式:
for (int j = 0; j < integers.length; j++) { 
    int i = integers[j]; 
    System.out.println(i); 
}
遍历数组的简单方式:
for (int i : integers) { 
    System.out.println(i);  /* 依次输出“1”、“2”、“3”、“4” */ 
}

Answer 3

写一个Bean类存放数据，继承Compable接口。public class Unit implements Comparable {
int index;
int value; Unit()
{

}
public Unit(int index,int value)
{
this.index=index;
this.value=value;
}
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
if (value == ((Unit) o).value) {
return 0;
} else if (value > ((Unit) o).value) {
return 1;
} else {
return -1;
}
}
}public static void main(String[] args) {
Unit[] units = new Unit[5];
units[0]=new Unit(1,90);
units[1]=new Unit(2,4);
units[2]=new Unit(3,6);
units[3]=new Unit(4,20);
units[4]=new Unit(5,57);

Arrays.sort(units);

for(Unit temp:units)
{
System.out.println("key:"+temp.index+"value"+temp.value);
}
}

Answer 4

我有个不成熟的方法
TreeMap<K,V>
类型参数：
K - 此映射维护的键的类型
V - 映射值的类型把后面对应的数作为K，对应的1——30作为V。然后用put方法放入TreeMap。因为TreeMap的输出是按K值排序的，所以即可得到排序结果。

Answer 5

TreeMap<K,V>
K - 此映射维护的键的类型
V - 映射值的类型
该映射根据其键的自然顺序进行排序
我的想法是将1-30对应的数作为K，然后1-30作为V。输入即使排序好的。

Answer 6

import java.util.Comparator;
import java.util.TreeSet;public class Test {
public static void main(String args[]){
        Integer[][] units ={{1,2},{2,5},{3,6},{4,10},{5,3}};
TreeSet<Integer[]> set = new TreeSet<Integer[]>(new Comparator<Integer[]>(){
public int compare(Integer[] o1, Integer[] o2){
if(o1[1]>o2[1]){
return 1;
}
else if(o1[1]<o2[1]){
return -1;
}
return 0;
}
});
for(Integer[] c:units){
set.add(c);
}
for(Integer[] c:set){
System.out.println("["+c[0]+","+c[1]+"]");
}
}
}

Answer 7

import java.util.*;class Data
{
    public static void main(String[] args)
    {
     //Properties p=System.getProperties();
       // System.out.println(p);
        
        TreeSet<Digital> ts=new TreeSet();
        ts.add(new Digital(1,70));
        ts.add(new Digital(2,60));
        ts.add(new Digital(3,90));
        ts.add(new Digital(4,80));
        ts.add(new Digital(5,50));
        ts.add(new Digital(6,20));
        ts.add(new Digital(7,100));
        ts.add(new Digital(8,10));
        ts.add(new Digital(9,30));
        ts.add(new Digital(10,40));
        
        Iterator<Digital>it=ts.iterator();
    while(it.hasNext())
    { 
     Digital d=it.next();
     System.out.println(d.toString());
    }
    
    }
    
}
class Digital implements Comparable <Digital>
{
private int a;
private int b;
Digital(int a,int b)
{
this.a=a;
this.b=b;
}
public int compareTo(Digital d)
{
int num= this.b-d.b;
if(num==0)
return this.a-d.a;
return num;
}
public String toString()
{
return a+":\t"+b;
}
}运行的结果：
E:\JavaProject\Project>
8:      10
6:      20
9:      30
10:     40
5:      50
2:      60
1:      70
4:      80
3:      90
7:      100不知楼主是不是想要的这种结果 ，那个泛型我搞忘记加了 ，有提示信息可以不用管，只要不是错误就行。或者自己加上也行。
可能定义Map集合更简单一点直接用键值对好操作一点。
新手意见，理性采纳。。谢谢！！

Answer 8

前面的30个数是没有意义的,所以只是简单的排序问题,方法很多,推荐用TreeSet,可以自动排序.如果想用数组,要一维的就行了,只存后面的30个数,每个数的索引值加1就得到前30个数