求助！！两个不同数组输出的问题？

Question

我是一个新学程序的学生，目前只学过简单的Java基础语法，目前遇到了数组输出的问题，希望各位大哥大姐指导下我！
    5--------"a"
    2--------"c"
    3--------"k"
    7--------"f"
    9--------"b"
要求就是 前面的数组进行排序后，后面的数组也能相应的对应变化输出！
    9--------"b"
    7--------"f"
    5--------"a"
    3--------"k"
    2--------"c"
我想过在第一个数组排序的时候，记录原始下标，也想过把它们两做为一个新数组输出，可是怎么也实现不了··我哭死了
我的脑筋不灵活··怎么也想不出其他方法·恳请各位大哥大姐指点一下 

Answer 1

我有个笨方法，说错了不要怪我。
原来有两个数组，数字数组A（5，2，3，7,9），字母数组B（a,c,k,f,b)
对数组A进行排序得到数组C。遍历数组C，找到数组A中与之对应的元素，然后得到该元素的下标。这样就可以根据得到的下标排序数组B了。

Answer 2

import java.util.*;public class TestArraySort {
    private int id;
    private String name;    public TestArraySort(int id, String name) {
this.id = id;
this.name = name;
    }    public String toString() {
return "[" + id + "," + name + "]";
    }    class CmpTypeComparator implements Comparator<TestArraySort> { public int compare(TestArraySort o1, TestArraySort o2) {
    if (o1.id > o2.id)
return -1;
    else if (o1.id == o2.id) {
if (o1.name.compareTo(o2.name) > 1)
    return -1;
else if (o1.name == o2.name)
    return 0;
    }
    return 1;
}
    }    public static void main(String[] args) {
TestArraySort[] a = { new TestArraySort(5, "a"),
new TestArraySort(2, "c"), new TestArraySort(3, "k"),
new TestArraySort(7, "f"), new TestArraySort(9, "b"), };
System.out.println("before sort:" + Arrays.toString(a));
Arrays.sort(a, new TestArraySort(0, "0").new CmpTypeComparator());
System.out.println("after  sort:" + Arrays.toString(a));
    }
}//
// //结果：
// before sort:[[5,a], [2,c], [3,k], [7,f], [9,b]]
// after sort:[[9,b], [7,f], [5,a], [3,k], [2,c]]

Answer 3

初学者,写了一下,望各位指正public static void main(String[] args){
int[] a = {5, 2, 3, 7, 9};
char[] b= {'a','c','k','f','b'};
int i, j, tmpa;
char tmpb;
for(i = 0; i < 5 - 1; i++){//冒泡排序
for(j = 0; j < 5 - i - 1; j++){
if(a[j] > a[j + 1]){
tmpa = a[j];
a[j] = a[j + 1];
a[j + 1] = tmpa;
tmpb = b[j];
b[j] = b[j + 1];
b[j + 1] = tmpb;
}
}
}
for(i = 0; i < 5; ++i)
System.out.println(a[i]+"--------"+b[i]);
}这个是输出结果
2--------c
3--------k
5--------a
7--------f
9--------b

Answer 4

import java.util.*;public class TestArraySort {
    private int id;
    private String name;    public TestArraySort(int id, String name) {
    this.id = id;
    this.name = name;
    }    public String toString() {
    return "[" + id + "," + name + "]";
    }    class CmpTypeComparator implements Comparator<TestArraySort> {    public int compare(TestArraySort o1, TestArraySort o2) {
        if (o1.id > o2.id)
        return -1;
        else if (o1.id == o2.id) {
        if (o1.name.compareTo(o2.name) > 1)
            return -1;
        else if (o1.name == o2.name)
            return 0;
        }
        return 1;
    }
    }    public static void main(String[] args) {
    TestArraySort[] a = { new TestArraySort(5, "a"),
        new TestArraySort(2, "c"), new TestArraySort(3, "k"),
        new TestArraySort(7, "f"), new TestArraySort(9, "b"), };
    System.out.println("before sort:" + Arrays.toString(a));
    Arrays.sort(a, new TestArraySort(0, "0").new CmpTypeComparator());
    System.out.println("after  sort:" + Arrays.toString(a));
    }
}//
// //结果：
// before sort:[[5,a], [2,c], [3,k], [7,f], [9,b]]
// after sort:[[9,b], [7,f], [5,a], [3,k], [2,c]]

Answer 5

public class Test2 
{
public static void main(String[] args) 
{
int[] num=new int[]{5,2,3,7,9};
char[] cha=new char[]{'a','c','k','f','b'};
int[] count=Arrays.copyOf(num,num.length);//主要目的是判定相等时候的下标
System.out.println("数组NUM未排序前输出为：");
for(int i=0;i<num.length;i++)
{
System.out.println(num[i]+"---------"+cha[i]);
}
int n;
//排序NUM数组
for(int i=0;i<num.length;i++)
{
for(int j=0;j<num.length;j++)
{
if(num[i]>num[j])
{
n=num[i];
num[i]=num[j];
num[j]=n;
}
}
}
System.out.println("数组NUM排序后输出为：");
for(int i=0;i<num.length;i++)
{
for(int j=0;j<num.length;j++)
{
if(num[i]==count[j])
{
System.out.println(num[i]+"---------"+cha[j]);
}
}
}
}
}

Answer 6

输出错了,把后面的改了一下for(i = 4; i >= 0; --i)
System.out.println(a[i]+"--------"+b[i]);

Answer 7

public class A {
public static void main(String[] args)
{
String[] a = {"5","2","3","7","9"};
String[] b = {"a","c","k","f","b"};

String[][] c= new String[a.length][2];

for(int i=0;i<a.length;i++)
{
c[i][0]=a[i];
c[i][1]=b[i];
}

System.out.println("排序前");
for(int i=0;i<a.length;i++)
{
System.out.print(c[i][0]);
System.out.print("------");
System.out.println(c[i][1]);
}

Arrays.sort(a);   
System.out.println("排序后");
for(int i=(a.length-1);i>=0;i--)
{
System.out.print(a[i]);
System.out.print("------");
for(int j=0;j<a.length;j++)
{
if(c[j][0].equals(a[i]))
{
System.out.println(c[j][1]);
}
}
}
}
}输出：排序前
5------a
2------c
3------k
7------f
9------b
排序后
9------b
7------f
5------a
3------k
2------c

Answer 8

用List排序
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class CompareClient {
 
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  List list = new ArrayList();
  list.add(new Content(15000,"1asdfasd5000"));
  list.add(new Content(10000,"10000"));
  list.add(new Content(20000,"20000"));
  list.add(new Content(30000,"30000"));
  list.add(new Content(25000,"25000"));
  list.add(new Content(13000,"13000"));
  list.add(new Content(15000,"15000"));  
  list.add(new Content(89000,"89000"));
  
  ContentComparator comp = new ContentComparator(); 
 
  Collections.sort(list,comp);
  
  Content content;
  for(int i = 0; i < list.size(); i++){
   content = (Content)list.get(i);
   System.out.println(" content.getName() " + content.getName());
  }
 
 }
 
}
package com.tom.compare;
 
import java.util.Comparator;
 
public class ContentComparator implements Comparator {
 
 public int compare(Object o1, Object o2) {
  // TODO Auto-generated method stub
  Content c1 = (Content) o1;
  Content c2 = (Content) o2;
  if (c1.getKey() > c2.getKey()) {
   return 1;
  } else {
   if (c1.getKey() == c2.getKey()) {
    return 0;
   } else {
    return -1;
   }
  }
 }
}
package com.tom.compare;
 
public class Content {
 
 private long key;
 
 private String name;
 
 public Content(long key, String name) {
  this.key = key;
  this.name = name;
 }
 
 public long getKey() {
  return key;
 }
 
 public void setKey(long key) {
  this.key = key;
 }
 
 public String getName() {
  return name;
 }
 
 public void setName(String name) {
  this.name = name;
 }
}

Answer 9

package com.cn;public class Sort {
public static void main(String[] args) {
int[] a = new int[]{5, 2, 3, 7, 9};
char[] b = new char[]{'a','c','k','f','b'};
bubble(a , b);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
for (int i = 0; i < a.length; i++) {
System.out.println(b[i]);
}
} private static void bubble(int[] a, char[] b) {
for (int i = 0; i < a.length - 1; i ++) {
for (int j = 1; j < a.length - i; j++) {
if (a[j] < a[j - 1]) {
int temp = a[j];
a[j] = a[j - 1];
a[j - 1] = temp;

char temp1 = b[j];
b[j] = b[j - 1];
b[j - 1] = temp1;
}
}

}

}
}a交换的时候，别跟着交换就行了嘛，，，

Answer 10

刚好两个数组都是一个字符的，所以不用自己写排序：
import java.util.*;
public class Test{
public static void main(String[] args){
String[] arr={"5a","2c","3k","7f","9b"};
Arrays.sort(arr);
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i].substring(0,1)+" "+arr[i].substring(1));
}
}
}
ps: Arrays.sort是升序，就将它反过来输出 -- 逆序 -- 降序了。

Answer 11

如下所示，实现了Arrays.sort的降序，要自写一Comparator,好麻烦好啰嗦呵，当然也很炫很强大。
import java.util.Arrays;
import java.util.Comparator;public class Test{
public static void main(String[] args){
String[] arr={"5a","2c","3k","7f","9b"};
Arrays.sort(arr,new myComparator());
for(String a:arr){
System.out.println(arr[i].substring(0,1)+" "+arr[i].substring(1));
}
}
}class myComparator implements Comparator<String> {
    public int compare(String o1, String o2) {
        return o2 - o1;
    }

Answer 12

上一贴的代码有错，取消。import java.util.Arrays;
import java.util.Comparator;public class Test{
public static void main(String[] args){
String[] arr={"5a","2c","3k","7f","9b"};
Arrays.sort(arr,new myComparator());
for(String a:arr){
System.out.println(a.substring(0,1)+" "+a.substring(1));
}
}
}class myComparator implements Comparator<String> {
    public int compare(String o1, String o2) {
        return o2.compareTo(o1);
    }
}

Answer 13

  String[] arr={"5a","2c","3k","7f","9b"};    
这想法不错  学习了  呵呵

Answer 14

最好的方法是用Map，这是一种键值对的形式，最容易理解和掌握，也是一种高级的技术。在没学习Map之前呢，我通常会用对象的形式先封装在一个对象里，然后再对对象排序，这也是比较高级的技术，选择覆盖已有的排序方法，如果这些都能想到了你的面向对象编程才算有了个突破。

Answer 15

用集合类里的Map是种高效率的方法

Answer 16

我一看到这题目，首先想到的也是map，这个结构跟数组里装map，太贴切了

Answer 17

楼上几位大哥，我也“首先想到的也是map”，奈何map里无sort()。查了手册，java的sort()只有Arrays.sort、Collections.sort，还有两个属swing的，所以只能在Arrays、Collections里突破。当然，不用java的sort()，自写也行，前面已有人贴出代码。摸索、修改一番，居然也弄出来了，没想象中复杂，只是对Comparator还是很困惑。
import java.util.*;public class Test{
public static void main(String[] args){
String[][] arr={{"5","a"},{"2","c"},{"3","k"},{"7","f"},{"9","b"}};
Arrays.sort(arr,new myComparator());
for(String[] aa:arr){
for(String a:aa){
System.out.print(a+" ");
}
System.out.println();
}
}
}class myComparator implements Comparator<String[]> {
    public int compare(String[] o1, String[] o2) {
        return o2[0].compareTo(o1[0]);
    }
}

Answer 18

通过再次学习，虽map里无sort()，但象TreeSet、TreeMap等原本就是有序的，这样大家想用map来排序的心愿可以达成：
import java.util.*;public class Test{
public static void main(String[] args){
String[] arr1={"5","2","3","7","9"};
String[] arr2={"a","c","k","f","b"};
Map<String,String> tm=new TreeMap<String,String>(new myComparator());
for (int i = 0; i < arr1.length; i++) 
         tm.put(arr1[i], arr2[i]); 
System.out.println(tm);
}
}class myComparator implements Comparator<String> {
    public int compare(String o1, String o2) {
        return o2.compareTo(o1);
    }
}
以上代码与21楼的二维数组类似，JDK 1.6有descendingMap()，故如下也行：
public class Test{
public static void main(String[] args){
String[] arr1={"5","2","3","7","9"};
String[] arr2={"a","c","k","f","b"};
TreeMap<String,String> tm=new TreeMap<String,String>();
for (int i = 0; i < arr1.length; i++) 
         tm.put(arr1[i], arr2[i]); 
System.out.println(tm.descendingMap());
}
}
不过，用MAP缺点也是明显的，就是作为key的序列不能有相同的，否则会丢失数据啊。

Answer 19

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;public class TestArraySort {

public static void main(String[] args) {
List<User> userList = new ArrayList<User>();
userList.add(new User("5","a"));
userList.add(new User("2","c"));
userList.add(new User("3","k"));
userList.add(new User("7","f"));  
userList.add(new User("9","b"));

//排序前
System.out.println("------排序前------");
for (int i=0;i<userList.size();i++){
   User user = userList.get(i);
   System.out.println(user.getId()+"------"+user.getName()); 
}

//排序
UserComparator uc =new UserComparator();
Collections.sort(userList, uc);
//没说清楚按第一个字段的正序还是逆序
//若逆序，加上下面一句就可以了
//Collections.reverse(userList);

//排序后
System.out.println("------排序后------");
for (int k=0;k<userList.size();k++){
   User user = userList.get(k);
   System.out.println(user.getId()+"------"+user.getName()); 
}

}
}class User { private String id;
private String name; public User(String id, String name) {
super();
this.id = id;
this.name = name;
} public String getId() {
return id;
} public void setId(String id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}}class UserComparator implements Comparator<User> { public int compare(User o1, User o2) {
return o1.getId().compareTo(o2.getId());
}
}