现有两个简单数组A与B:
一、 int[] A = {8,2,3,3,2,7};
二、 String[] B = new String[]{"a","b","c","d","e","f"};现我要求,这两个数组的下标要实现一一对应,即8-a,2-b,3-c,3-d,2-e,7-f此时,我想实现,当我对A数组进行排序时(比如升序排为:{2,2,3,3,7,8})
如何简单的同步实现数组B的跟着A变换化呢?
比如,当A升级排序时,此时,B要变为:{b,e,c,d,f,a}(要据文红色对应的原则)楼主一开始想到用TreeMap来做,当由于A中有相对的数值,不符合KEY唯一性的要求,实现不了,所以就一时似乎卡住了,各位高人怎么看?
一、 int[] A = {8,2,3,3,2,7};
二、 String[] B = new String[]{"a","b","c","d","e","f"};现我要求,这两个数组的下标要实现一一对应,即8-a,2-b,3-c,3-d,2-e,7-f此时,我想实现,当我对A数组进行排序时(比如升序排为:{2,2,3,3,7,8})
如何简单的同步实现数组B的跟着A变换化呢?
比如,当A升级排序时,此时,B要变为:{b,e,c,d,f,a}(要据文红色对应的原则)楼主一开始想到用TreeMap来做,当由于A中有相对的数值,不符合KEY唯一性的要求,实现不了,所以就一时似乎卡住了,各位高人怎么看?
String做K,到时,那我不是要通过值来判断KEY?
问题是,值有相同的啊?
同样是2的值,KEY却有两个,"b"与"e",我取那个?不知道呢?
这里是两个,正常的实例可能有N个相同的,那不是乱了?
类似这样
public class Pair implements Comparable<Pair>{
//
int number;
String name;
//
public int compareTo(Pair p){
return this.number-p.number;
}
}
int[] A = {8,2,3,3,2,7};
int[] SORT = {0,1,2,3,4,5};当A变成{2,2,3,3,7,8}
SORT变成{1,4,2,3,5,0}
类似这样
public class Pair implements Comparable<Pair>{
//
int number;
String name;
//
public int compareTo(Pair p){
return this.number-p.number;
}
}
是不是类似用类的方法来做啊?number,与name做属性的了这样,把这两个做成一个对象的属性,那确实是可行的,但似乎有点杀鸡用牛刀的感觉啊,我再想想看。。
public static void main(String[] args) {
int[] A = { 8, 2, 3, 3, 2, 7 };
String[] B = { "a", "b", "c", "d", "e", "f" }; Set<AB> set = new TreeSet<AB>();//把二个数组内容连同下标封装成对象.放TreeSet里。
for(int i = 0; i< A.length; i++)
{
AB ab = new AB(A[i], i, B[i]);
set.add(ab);
}
//将排序后的容器内容,存放数组输出。
//
int[] A1 = new int[A.length];//排序后的A.
String[] B1 = new String[A.length];//排序后的B
//int[] indexA = new int[A.length];//原数组A的下标顺序。
int k =0;
for(AB ab0:set)
{
A1[k] = ab0.getA();
B1[k] = ab0.getB();
//indexA[k] = ab0.getIndex();
k++;
} System.out.println(" -------- 排序前数组: -------------");
System.out.println(Arrays.toString(A));
System.out.println(Arrays.toString(B));
System.out.println(" ********* 排序后数组:*************");
System.out.println(Arrays.toString(A1));
System.out.println(Arrays.toString(B1));
//System.out.println(Arrays.toString(indexA));
}
}
//类AB 用于封装数组的内容。
//
class AB implements Comparable<AB> {
private int a;
private int index;
private String b; public AB(int a, int index, String b) {
this.a = a;
this.b = b;
this.index = index;
} @Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + a;
result = prime * result + ((b == null) ? 0 : b.hashCode());
result = prime * result + index;
return result;
} @Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AB other = (AB) obj;
if (a != other.a)
return false;
if (b == null) {
if (other.b != null)
return false;
} else if (!b.equals(other.b))
return false;
if (index != other.index)
return false;
return true;
} public int getIndex() {
return index;
} public void setIndex(int index) {
this.index = index;
} public int getA() {
return a;
} public void setA(int a) {
this.a = a;
} public String getB() {
return b;
} public void setB(String b) {
this.b = b;
} public int compareTo(AB other) {
if (this.a > other.a) {
return 1;
} else if ((this.a == other.a) && (this.index > other.index )) {
return 1;
}else if((this.a == other.a) && (this.index == other.index )){
return 0;
}else{
return -1;
}
}
}
package test;public class SortTest { /**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] A = {8,2,3,3,2,7};
String[] B = new String[]{"a","b","c","d","e","f"}; for(int i=0;i<A.length;i++){
System.out.print(A[i]+"--"+B[i]+"\t");
}
System.out.println();
int newSort[]=new int[A.length];
for(int i=0;i<newSort.length;i++){
newSort[i]=i;
}
//每次假设都是最小的
for(int i=0;i<A.length-1;i++){
int min=A[i];
int index=i;
for(int j=i;j<A.length;j++){
if(A[j]<min){
index=j;
min=A[j];
}
}
//交换位置
if(index!=i){
int temp=A[i];
A[i]=A[index];
A[index]=temp;
temp=newSort[i];
newSort[i]=newSort[index];
newSort[index]=temp;
}
}
for(int i=0;i<A.length;i++){
System.out.print(A[i]+"--"+B[newSort[i]]+"\t");
}
}}