Question

我想在Java中创建一个类似于结构的表，如图所示

表结构虽然我不是Java专家，但我尝试使用Arraylist结构实现它，如下所示：

List<List<Double>> dataList = new ArrayList<List<Double>>();
for(int x = 0; x < n; x++){
    List<Double> tempList = new ArrayList<Double>();
    dataList.add(tempList);
}

for(int y = 0; y < n; y++){
    double execution = exectime[y];
    double cost= cost[y];
    dataList.get(y).add(execution);
    dataList.get(y).add(cost);
}

for (int z=0;z<dataList.size();z++) {
    Double v1=dataList.get(z).get(0);
    Double v2=dataList.get(z).get(1);

    System.out.println("ID"+z +" Execution time:" + v1 + "cost: " + v2);
}

其中'n'，'exectime [n]'和'cost [n]'的值将从文件中读取，'n'是需要创建的'ids'的总数。

创建表后，我想根据“执行时间”值和“成本”值对其进行排序，包括递增和递减顺序。在这方面请帮助我。

Answer 1

@ snovelli关于使用类封装数据的答案是一个很好的观点。

如果您使用的是Java 8，则可以轻松创建和链接使用访问器的比较器。

对于对象列表的排序，它可能类似于：

List<ExecutionTimeData> dataList = new ArrayList<>();
dataList.sort(Comparator
    .comparing(ExecutionTimeData::getExecutionTime)
    .thenComparing(ExecutionTimeData::getCost));

按执行时间排序，然后是费用。

如果您真的想要，也可以使用它来对List<List<Double>>进行排序。

List<List<Double>> doubleListList = new ArrayList<>();
doubleListList.sort(Comparator
    .comparing((List<Double> l) -> l.get(0))
    .thenComparing(l -> l.get(1)));

按列表的元素0排序，后跟元素1。

或者按相反顺序排序：

List<ExecutionTimeData> dataList = new ArrayList<>();
dataList.sort(Comparator
    .comparing(ExecutionTimeData::getExecutionTime).reversed()
    .thenComparing(ExecutionTimeData::getCost).reversed());

Answer 2

将集合用作列表＆lt; RegisterType＆gt; ，RegisterType是根据表中存在的寄存器类型创建的（例如：带有3个双属性）
实施Comparator接口比较器＆lt; RegisterType＆gt;
以您希望的方式覆盖比较（RegisterType o1，RegisterType o2）方法（定义如何对RegisterType类型的2个元素进行排序）
Inkove Collections.sort（List＆lt; RegisterType＆gt; list，ComparatorClass）

然后，您将按照自己的方式对收藏清单进行排序。

Answer 3

表是一种表示对象列表的方法，为什么不使用对象列表呢？

我想你想要一个SortedSet类，你可以定义为：

public class ExecutionTimeData{

    private final long id;
    private final long executionTime;
    private final int cost;

    public ExecutionTimeData(long id, long executionTime, int cost){
         this.id = id;
         this.executionTime = executionTime;
         this.cost = cost;
    }        

    /* Getters */      

}

然后您将只有一个未排序的列表，如

List<ExecutionTimeData> unsortedList = new ArrayList<>();

正如@VikrantKashyap指出的那样，为了列出价值和成本，你必须实现Chained Comparator

public class ExecutionTimeDataChainedComparator implements Comparator<ExecutionTimeData> {

    private List<Comparator<ExecutionTimeData>> listComparators;

    @SafeVarargs
    public ExecutionTimeDataChainedComparator (Comparator<ExecutionTimeData>... comparators) {
        this.listComparators = Arrays.asList(comparators);
    }

    @Override
    public int compare(ExecutionTimeData etd1, ExecutionTimeData etd2) {
        for (Comparator<ExecutionTimeData> comparator : listComparators) {
            int result = comparator.compare(etd1, etd2);
            if (result != 0) {
                return result;
            }
        }
        return 0;
    }
}

并实现这样的比较器

public class ExecutionTimeDataCostComparator implements Comparator<ExecutionTimeData > {

    @Override
    public int compare(ExecutionTimeData a, ExecutionTimeData b) {
       return b.getCost() > a.getCost()?-1:1;
    }
}

public class ExecutionTimeDataExecutionComparator implements Comparator<ExecutionTimeData > {

    @Override
    public int compare(ExecutionTimeData a, ExecutionTimeData b) {
       return b.getExecutionTime() > a.getExecutionTime()?-1:1;
    }
}

当然，通过实例化提供ASCENDING或DESCENDING订单

的比较器，您可以找到一种简单的方法来反转订单

Answer 4

使用Collections.sort() with Comparator。

但是，您将丢失ID信息，因为它基于您的ArrayList索引。因此，如果您使用此方法并希望保留ID信息，则需要add() ID到您的ArrayList，就像execution和cost一样。

Comparator<List<Double>> ORDER = new Comparator<List<Double>>() {
    @Override
    public int compare(List<Double> lhs, List<Double> rhs) {
        if (lhs.get(1) < rhs.get(1)) return -1;
        if (lhs.get(1) == rhs.get(1)) return 0;
        return 1;
    }
};

Collections.sort(dataList, ORDER);

在上面的代码中，您的dataList将使用cost进行排序，因为它位于ArrayList的索引1处。

但是，更好的方法（可读性）是将列放入Class，而不仅仅是ArrayList。例如，您可以像这样创建一个类：

class Information {
    private int id;
    private double execution;
    private double cost;

    Information(int id, double execution, double cost) {
        this.id = id;
        this.execution = execution;
        this.cost = cost;
    }
}

在该类中实现静态Comparator。它将提高代码的可读性。

Answer 5

我认为你应该使用链式Comparator来使用多个属性来实现sorting。因为如果单独使用单个Comparator它会根据自己的Compare()方法实现对数据进行排序。

最好使用链式Comparator对多个属性的数据进行排序...尝试以下链接==＆gt; Sorting a list by multiple attributes example

排序在Java中具有多个值的列表/ Arraylists / Hashmaps列表

5 个答案:

表是一种表示对象列表的方法，为什么不使用对象列表呢？