是否可以合并两个数组（一维），即string和int并对它们进行排序？例如：
String name[] = {"Percy", "Daniel, "Layla"};
int marks[] = {90, 87, 91};
Arrays.sort (name);
for(int i = 0; i < name.length; i++)
System.out.println( (i+1) + ". "+ name[i] + "\t\t" + marks[i]);
如果我想对它们进行排序，我希望输出如下：
// before sorting
1. Percy 90
2. Daniel 87
3. Layla 91
// after sorting
1. Daniel 90
2. Layla 87
3. Percy 91
// the actual output that i wanted
1. Daniel 87
2. Layla 91
3. Percy 90
你建议我做什么？如何链接这两个数组并根据它们的名称对它们进行排序？或者我该如何合并它们？有什么简单的方法我能理解吗？正如我在网上随处可读使用比较器，合并一切，但我不是很清楚。
我是java的新手。对于初学者有什么方法吗？
答案 0 :(得分：2)
您要求初学者使用Java类。关于比较器，树集以及Java中的所有其他内容，网上有很多例子。你肯定需要花时间阅读你所看到的一切，但很多例子都很清楚。如果您正在尝试学习某些东西，并且它不适合您，请不要花费更多时间。再次谷歌，即使这是最终适合你的第15或第20个解释。这很常见。在你理解之前，不要读过去的任何内容。
当然有一个类来存储实现Comparable的字符串，正如@regulus建议的那样，除了使用名称而不是标记:)将标记存储在类中，以备将来参考，或者如果你希望将它用于二次比较（比较名称后）。这将为您的元素提供自然的顺序。在创建每个对象实例时，......
将它们插入Java的TreeSet实例中。以下是其用法示例：
import java.util.TreeSet;
import java.util.Iterator;
public class IterateThroughElementsOfTreeSetExample {
public static void main(String[] args) {
//create object of TreeSet
TreeSet tSet = new TreeSet();
//add elements to TreeSet object
tSet.add(new Integer("1"));
tSet.add(new Integer("2"));
tSet.add(new Integer("3"));
//get the Iterator
Iterator itr = tSet.iterator();
System.out.println("TreeSet contains : ");
while(itr.hasNext())
System.out.println(itr.next());
}
}
它会超级快，因为它会在您插入密钥时进行排序。
答案 1 :(得分：1)
尝试这样的事情：
String name[] = {"Percy", "Daniel", "Layla"};
int marks[] = {90, 87, 91};
ArrayList<String> arrayList = new ArrayList<String>();
System.out.println("Before Sorting..");
for (int i = 0; i < name.length; i++) {
arrayList.add(name[i] + " " + marks[i]);
//Before Sorting
System.out.println(i + 1 + " " + name[i] + " " + marks[i]);
}
Collections.sort(arrayList);
//After Sorting
System.out.println("After Sorting..");
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(i + 1 + " " + arrayList.get(i));
}
答案 2 :(得分：1)
没有标准的解决方案。试试这个
static void sort(String[] name, int[] marks) {
for (int i = 0; i < name.length; i++) {
for (int j = i; j > 0 && (name[j - 1]).compareTo(name[j]) > 0; j--) {
swap(name, j, j - 1);
swap(marks, j, j - 1);
}
}
}
private static void swap(String[] x, int a, int b) {
String t = x[a];
x[a] = x[b];
x[b] = t;
}
private static void swap(int[] x, int a, int b) {
int t = x[a];
x[a] = x[b];
x[b] = t;
}
这是Arrays.sort
的插入排序算法的修改版本答案 3 :(得分：1)
假设您具有唯一名称，则可以使用HashMap具有名称 - 标记对。 Map返回其键集（在本例中为name）已排序。
String name[] = {"Percy", "Daniel", "Layla"};
int marks[] = {90, 87, 91};
if (name.length!=marks.length){
System.exit(0);
}
HashMap<String, Integer> hm = new HashMap<String, Integer>();
for(int i=0;i<name.length;i++){
hm.put(name[i], marks[i]);
}
ArrayList<String> keys = new ArrayList<String>(hm.keySet()); //for descending order
for(int i=keys.size()-1, j=0; i>=0;j++,i--){
System.out.println((j+1)+". "+keys.get(i)+"\t\t"+hm.get(keys.get(i)));
}
答案 4 :(得分：1)
使用Map可以轻松解决您的问题。 Map是一个可用于存储链接数据对的类，其中每对具有“键”和“值”。存储在地图中后，如果您有相应的密钥，则可以快速查找任何值。还有一种方法可以迭代或列出地图中的所有键。
这是一个简单的程序，展示了如何使用Map来解决问题：
import java.util.*;
public class Example
{
public static void main(String[] args)
{
String[] name = new String[] {"Percy", "Daniel", "Layla"};
int[] marks = new int[] {90, 87, 91};
// First create a TreeMap to hold the data. A TreeMap is a special
// kind of Map which keeps the keys in sorted order for you.
// In this TreeMap, the keys will be Strings and the values
// will be Integers.
TreeMap<String, Integer> map = new TreeMap<String, Integer>();
// Next, link each name in the names array to the corresponding mark
// by putting them in the TreeMap. Each name becomes a key
// in the map, and each mark is a value.
for (int i = 0; i < name.length; i++)
{
map.put(name[i], marks[i]);
}
// Now we can iterate over the keys in the map, and for each key
// retrieve the corresponding value. The TreeMap guarantees
// the keys will be in sorted order.
for (String key : map.keySet())
{
System.out.println(key + "\t" + map.get(key));
}
}
}
这是输出：
Daniel 87
Layla 91
Percy 90
答案 5 :(得分：0)
合并String数组和整数数组没有意义。除非性能是您的首要问题，否则以面向对象的方式实现解决方案要好得多。 我会创建一个包含名称和标记的类。因此，每个名称和标记对都会有一个此类的实例。然后我将实现Comparable接口，使这个类可以排序。
class Grade implements Comparable<Grade>{
String name;
int mark;
public int compareTo(Grade o) {
return name.compareTo(o.name);
}
}
答案 6 :(得分：0)
可以使用两种方式完成
答案 7 :(得分：0)
创建一个新的Comparable类NameScore
public class NameScore implements Comparable<NameScore> {
private final String name;
private final int marks;
public NameScore(String name, int marks) {
this.name = name;
this.marks = marks;
}
@Override
public int compareTo(NameScore other) {
// compare by name
return this.name.compareTo(other.name);
// compare by (ascending) marks
//return this.marks - other.marks;
}
@Override
public String toString() {
return "" + name + " (" + marks + ")";
}
}
以下是使用NameScore解决问题的方法：
public static void main(String[] args) {
String name[] = {"Percy", "Daniel", "Layla"};
int marks[] = {90, 87, 91};
List<NameScore> list = new LinkedList<NameScore>();
for (int i = 0; i < marks.length; i++) {
NameScore element = new NameScore(name[i], marks[i]);
list.add(element);
}
System.out.println("BEFORE : "+list);
Collections.sort(list);
System.out.println(" AFTER : "+list);
}
答案 8 :(得分：0)
这是我在新手时常常做的事情：
String name[] = {"Percy","Daniel","Layla"};
int marks[] = {90, 87, 91};
String merged[] = new String[name.length];
for (int i=0; i< name.length; i++) {
merged[i] = name[i]+"=="+marks[i];
}
Arrays.sort(merged);
for(int i = 0; i < merged.length; i++) {
System.out.println( (i+1) + ". "+ merged[i].split("==")[0] + "\t\t" + merged[i].split("==")[1]);
}