急！急！~~~两数组排序

Question

如题 2个数组
 String[]a ={};
 int []b ={};
a[i] 与b[i]的值是一一对应的
如果对b数组升排序 使得a数组对应也随之排序这怎么做 请教大神！！或者有什么其他方法来使得一一对应的两组数 同时排序改变？ 

Answer 1

String类型的数组里面的字符串是以第一个为基准的，你可以试着传递值进去，一下影响两组数组

Answer 2

可以写一个method
同时对这两个数组排序
传递一个标识符来判断是升序或者降序

Answer 3

  写个方法把int[] 再转化成 String[]

Answer 4

楼主，给一个我很早之前的处理办法：
for(int i=0;i<b.length;i++){
  b[i]=b[i]*100+i;
}mysort(b);String[] c=new String[a.length];
for(int i=0;i<a.length;i++){
  c[i]=a[b[i]%100];
}明白？简单的说，先给b后面加一个序号，拍完序后，根据这个序号，重排a就ok了
当然缺陷很多，你自己改吧

Answer 5

我先说下一思路  有空的话再上代码  你说的那两个数组是一一对应 这个就太简单了 就算不用map  依然可以让他们一一对应的把两个数组合并成一个数组c 如果对int数组排序的话  然后写个方法对C数组进行排序 使得c数组里面的b部分顺序和b数组一样 再输出c数组a数组的部分就行了

Answer 6

把对应关系存起来。类似map

Answer 7

import java.util.Arrays;public class Array {

/**
 * @param 原String数组:a
 * @param 原int数组:b
 * @param 排序后的b数组:sortedB
 * @return
 */
public String[] ArrayUtil(String[] a,int[] b,int[] sortedB){
StringBuilder temp=new StringBuilder();
for (int i = 0; i < a.length; i++) {
temp.append(b[i]);
}
String str=temp.toString();
String[] sortedA=new String[a.length];
for (int i = 0; i < a.length; i++) {
sortedA[i]=a[str.indexOf(sortedB[i]+"")];
}
return sortedA;
}
public static void main(String[] args) {
String[] a={"a","h","s","c"};
int[] b={2,5,4,3};
System.out.println("没有对a排序之前:");
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
System.out.println("对a进行特殊排序后:");
int[] temp={4,5,3,2};
System.out.println(Arrays.toString(new Array().ArrayUtil(a, b, temp)));
System.out.println(Arrays.toString(temp));
}
}打印输出:
没有对a排序之前:
[a, h, s, c]
[2, 5, 4, 3]
对a进行特殊排序后:
[s, h, c, a]
[4, 5, 3, 2]
实在不好意思了  实现起来和跟之前说的有点出入。。

Answer 8

这里b数组相当于keys  且不能有重复。。有点像map的key不能重复一样

Answer 9

public class ArrSort {
public static void main(String[] args){
int[] arrInt = {4, 2, 3, 1, 6};
String[] arrStr = {"ab", "cd", "ef", "gh", "ij"};
int tmpInt;
String tmpStr;
for(int i = 0; i < arrInt.length - 1; ++i){
for(int j = 0; j < arrInt.length - i - 1; ++j){
if(arrInt[j] > arrInt[j+1]){
tmpInt = arrInt[j];
arrInt[j] = arrInt[j+1];
arrInt[j+1] = tmpInt;
tmpStr = arrStr[j];
arrStr[j] = arrStr[j+1];
arrStr[j+1] = tmpStr;
}
}
}
for(int i = 0; i < arrInt.length; ++i){
System.out.println(arrInt[i] + "------" + arrStr[i]);
}
}}
1------gh
2------cd
3------ef
4------ab
6------ij

Answer 10

映射关系 用map好些 map(K,V)
   

Answer 11

大家都不知道你所谓的对应关系
你可以自己定义一个Map结构的类型
Map<String,Integer> map=new Map<String ,Integer>();
然后在定义下key和value的关系，就好了，排序
你也可以随时get等方法随时取出你需要的集合转化成数组

Answer 12

基本思路:
把俩个数组都变成对应的List集合,因为都是简单类型,所以可以直接使用集合对应的排序方法排序.
代码如下:public void sortArys(){
String[] strArys=new String[]{"3","2","4"};
//把数组变成集合
List<String> strList=Arrays.asList(strArys);
//升序
Collections.sort(strList);
//给升序反序就是降序
//Collections.reverse(strList);
for(String str:strList){
System.out.println(str);
} Integer[] intArys=new Integer[]{3,2,4};
List<Integer> intList=Arrays.asList(intArys);
//同上
}

Answer 13

靠，collections.sort，一句就OK，为神马写那么多代码？

Answer 14

首先 数组也可以一句话搞定Arrays.sort(数组)   其次 楼主并没有说一定是升序或者降序   所以我提供了比较万能的方法  不管数组里面的元素怎么移动  照样保持两数组元素的相对顺序（当然包括升序降序了）

Answer 15

public static void main(String[] args) {
String[] ss={"2-asds","5-asjdsj","1-sdfjsfh","3-asdjsaj",null,"as"};
for(int i=0;i<ss.length;i++){
System.out.println(ss[i]);
}
System.out.println("---------------------------");
Arrays.sort(ss, new MyComparable());
for(int i=0;i<ss.length;i++){
System.out.println(ss[i]);
}

} public static class MyComparable implements Comparator { public int compare(Object arg0, Object arg1) {
if(arg0==null||"".equals(arg0.toString())||arg0.toString().indexOf("-")==-1){
return -1;
}else if(arg1==null||"".equals(arg1.toString())||arg1.toString().indexOf("-")==-1){
return 1;
}else if(arg0.toString().equals(arg1.toString())){
return 0;
}else{
String s0=arg0.toString().substring(0, arg0.toString().indexOf("-"));
String s1=arg1.toString().substring(0, arg1.toString().indexOf("-"));
// System.out.println("s0:"+s0+"---s1:"+s1);
if(!s0.matches("\\d*")){
return -1;
}else if(!s1.matches("\\d*")){
return 1;
}else{
if(Integer.parseInt(s0)>Integer.parseInt(s1)){
// System.out.println("arg0:"+arg0+"大于arg1:"+arg1+"");
return 1;
}else{
// System.out.println("arg0:"+arg0+"小于arg1:"+arg1+"");
return 0;
}
}
}
} }