将2个数组链接或合并为1并在java中对它们进行排序

Question

是否可以合并两个数组（一维），它是字符串和整数并对它们进行排序？例如：

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。对于初学者有什么方法吗？

Answer 1

这是我平时没有当我还是个菜鸟：

 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]); 
     } 

Answer 2

那么合并一个字符串数组和整数数组是没有意义的。除非性能是您的优先考虑事项，否则以面向对象方式实施解决方案要好得多。 我会创建一个包含名称和标记的类。因此，每个名称和标记对都会有一个此类的实例。然后我会实现Comparable接口，这使得这个类可以排序。

class Grade implements Comparable<Grade>{ 
    String name; 
    int mark; 

    public int compareTo(Grade o) { 
     return name.compareTo(o.name); 
    } 
} 

Answer 3

你问初学者的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()); 
    } 
} 

这将会是超级快，因为它为你插入钥匙真实排序。

Answer 4

它可以通过两种方式

1. 如果仅按名称排序，关键和值，自动排序的名称和标记添加到TreeMap中来完成。
2. 如果需要按两者排序，请使用这些变量创建类并实现可比较的接口。

Answer 5

创建一个新的可比类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); 
} 

Answer 6

尝试是这样的：

 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)); 
     } 

Answer 7

有无标准解决方案。试试这个

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

Answer 8

插入排序算法的修改版本假设你有独特的名字，你可以使用HashMap中有一个名称，标记对。 Map返回它的键集（在这种情况下的名字）排序。

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))); 
} 

Answer 9

使用Map可以很容易地解决您的问题。 A 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