6

是否可以合并两个字符串和 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 新手。那么初学者有什么方法吗？

4

9 回答 9

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

它会非常快，因为它会在您插入键时进行排序。

于 2013-10-26T03:32:39.153 回答
1

您的问题可以使用Map. AMap是一个类，可用于存储链接的数据对，其中每对数据都有一个“键”和一个“值”。一旦存储在地图中，如果您有相应的键，您可以快速查找任何值。还有一种方法可以迭代或列出地图中的所有键。

这是一个简单的程序，展示了如何使用 aMap来解决问题：

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
于 2013-10-26T04:23:42.783 回答
1

假设您有唯一名称，您可以使用 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)));
}
于 2013-10-26T04:17:07.870 回答
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));
        }
于 2013-10-26T04:05:58.080 回答
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 中插入排序算法的修改版本

于 2013-10-26T04:10:47.670 回答
0

可以使用两种方式完成

  1. 如果仅按名称排序，则将名称和标记添加到 TreeMap 作为键和值，它会自动排序。
  2. 如果需要按两者排序，请使用这些变量创建类并实现可比较的接口。
于 2013-10-26T03:37:05.810 回答
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);
}
于 2013-10-26T03:44:55.157 回答
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]);
        }
于 2013-10-26T04:31:11.793 回答
0

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

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

    public int compareTo(Grade o) {
        return name.compareTo(o.name);
    }
}
于 2013-10-26T03:30:09.420 回答