使用java对具有多个列的对象列表进行排序
我有一些数据，比如名字，订单，估计数，实际值使用java对具有多个列的对象列表进行排序,java,sorting,Java,Sorting,我有一些数据，比如名字，订单，估计数，实际值 "Id1",4,230,350 "Id2",1,530,340 "Id3",4,530,150 "Id4",1,660,540 "Id5",2,530,540 "Id6",3,650,230 "Id7",4,530,120 "Id8",3,650,330 需要使用顺序、估计值和实际值对它们进行排序，输出应该如下 "Id2",1,530,340 "Id4",1,660,540 "Id5",2,530,540 "Id6",3,650,230 "Id8"
"Id1",4,230,350
"Id2",1,530,340
"Id3",4,530,150
"Id4",1,660,540
"Id5",2,530,540
"Id6",3,650,230
"Id7",4,530,120
"Id8",3,650,330
"Id2",1,530,340
"Id4",1,660,540
"Id5",2,530,540
"Id6",3,650,230
"Id8",3,650,330
"Id1",4,230,350
"Id7",4,530,120
"Id3",4,530,150
使用什么样的最佳数据结构以及如何仅按整数值排序顺序、估计值、实际值而不是名称创建实现可比较的记录，然后将记录放入列表并调用：
Collections.sort(list);
import java.util.Collections;
import org.apache.commons.lang.builder.CompareToBuilder;
public class Record implements Comparable<Record> {
String cad;
Integer x, y, z;
public int compareTo(final Record o) {
return new CompareToBuilder().append(this.x, o.x).append(this.y, o.y).append(this.z, o.z).toComparison();
}
import java.util.Collections；
导入org.apache.commons.lang.builder.CompareToBuilder；
公共类记录实现可比性{
字符串cad；
整数x，y，z；
公共int比较（最终记录o）{
返回新的CompareToBuilder（）.append（this.x，o.x）.append（this.y，o.y）.append（this.z，o.z）.toComparison（）；
}
}创建一个实现Compariable的记录，然后将记录放入列表并调用：
Collections.sort(list);
import java.util.Collections;
import org.apache.commons.lang.builder.CompareToBuilder;
public class Record implements Comparable<Record> {
String cad;
Integer x, y, z;
public int compareTo(final Record o) {
return new CompareToBuilder().append(this.x, o.x).append(this.y, o.y).append(this.z, o.z).toComparison();
}
import java.util.Collections；
导入org.apache.commons.lang.builder.CompareToBuilder；
公共类记录实现可比性{
字符串cad；
整数x，y，z；
公共int比较（最终记录o）{
返回新的CompareToBuilder（）.append（this.x，o.x）.append（this.y，o.y）.append（this.z，o.z）.toComparison（）；
}
}编写一个实现
公共类MyObject实现了可比较的
{
私有字符串id；
私人内部订单；
私人投资估算；
私人实际价值；
@凌驾
公共内部比较（MyObject o）
{
//定义你的逻辑
返回0；
}
}
List List=new ArrayList（）；
//list.add（）；
集合。排序（列表）；
公共类MyObject实现了可比较的
{
私有字符串id；
私人内部订单；
私人投资估算；
私人实际价值；
@凌驾
公共内部比较（MyObject o）
{
//定义你的逻辑
返回0；
}
}
List List=new ArrayList（）；
//list.add（）；
集合。排序（列表）；
class myClass implements Comparator<object> {
@Override
public int compare(object o1, object o2) {
// write comparison logic here
return o1.getID().compareTo(o2.getID());
}
}
您可以根据自己的要求修改逻辑。当您想要排序并将其传递给比较器时，使用接受比较器的方法 例如：
class myClass implements Comparator<object> {
@Override
public int compare(object o1, object o2) {
// write comparison logic here
return o1.getID().compareTo(o2.getID());
}
}
您可以根据需要修改逻辑。您可以创建一个类，该类的属性顺序、估计值和实际值如下
public class Data {
private String name;
private int order;
private int estimate;
private int actual;
List<Data> dataList=new ArrayList<Data>();
Comparator<Data> dataComparator = new DataComparator();
Collections.sort(dataList, dataComparator);
Comparator-dataComparator=新的dataComparator（）；
Collections.sort（dataList、dataComparator）；
使用单独的比较器而不是comparable具有将排序逻辑分离到单独类中的优势。您可以创建一个具有以下属性的类：顺序、估计值和实际值
public class Data {
private String name;
private int order;
private int estimate;
private int actual;
List<Data> dataList=new ArrayList<Data>();
Comparator<Data> dataComparator = new DataComparator();
Collections.sort(dataList, dataComparator);
Comparator-dataComparator=新的dataComparator（）；
Collections.sort（dataList、dataComparator）；
使用单独的比较器而不是comparable具有将排序逻辑分离到单独类中的优势。我建议使用我在前面的回答中提到的不同类，但如果无法避免，您可以使用如下数据结构：
Map<String, List<Integer>> dataMap = new HashMap<String, List<Integer>>();
ArrayList<Data> data = new ArrayList<Data>();
// ....
data.add(new Data("Id1", 4, 230, 350));
data.add(new Data("Id2", 1, 530, 340));
data.add(new Data("Id3", 3, 340, 340));
data.add(new Data("Id4", 2, 300, 200));
// ....
System.out.println("Unsorted: " + data);
data.sort(new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
if(o1.x > o2.x)
{
return 1;
}
else
{
return -1;
}
}
});
System.out.println("Sorted by x: " + data);
public class Data {
Data(String id, int x, int y, int z)
{
this.id = id;
this.x = x;
this.y = y;
this.z = z;
}
String id;
int x; // Sort by x
int y;
int z;
@Override
public String toString() {
return id;
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public Map sortByValue(Map map) {
List list = new LinkedList(map.entrySet());
Collections.sort(list, new Comparator() {
public int compare(Object o1, Object o2) {
//Your custom sorting logic
if (((List<Integer>) (((Map.Entry) (o1)).getValue())).get(0) > ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(0)) {
return 1;
} else if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
.get(0) < ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(0)) {
return -1;
} else {
if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
.get(1) > ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(1)) {
return 1;
} else if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
.get(1) < ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(1)) {
return -1;
} else {
if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
.get(2) > ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(2)) {
return 1;
} else if (((List<Integer>) (((Map.Entry) (o1))
.getValue())).get(2) > ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(2)) {
return -1;
} else {
return 0;
}
}
}
}
});
Map result = new LinkedHashMap();
for (Iterator it = list.iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
result.put(entry.getKey(), entry.getValue());
}
return result;
}
我建议使用我在上一个答案中提到的不同类，但如果无法避免，可以使用如下数据结构：
Map<String, List<Integer>> dataMap = new HashMap<String, List<Integer>>();
ArrayList<Data> data = new ArrayList<Data>();
// ....
data.add(new Data("Id1", 4, 230, 350));
data.add(new Data("Id2", 1, 530, 340));
data.add(new Data("Id3", 3, 340, 340));
data.add(new Data("Id4", 2, 300, 200));
// ....
System.out.println("Unsorted: " + data);
data.sort(new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
if(o1.x > o2.x)
{
return 1;
}
else
{
return -1;
}
}
});
System.out.println("Sorted by x: " + data);
public class Data {
Data(String id, int x, int y, int z)
{
this.id = id;
this.x = x;
this.y = y;
this.z = z;
}
String id;
int x; // Sort by x
int y;
int z;
@Override
public String toString() {
return id;
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public Map sortByValue(Map map) {
List list = new LinkedList(map.entrySet());
Collections.sort(list, new Comparator() {
public int compare(Object o1, Object o2) {
//Your custom sorting logic
if (((List<Integer>) (((Map.Entry) (o1)).getValue())).get(0) > ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(0)) {
return 1;
} else if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
.get(0) < ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(0)) {
return -1;
} else {
if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
.get(1) > ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(1)) {
return 1;
} else if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
.get(1) < ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(1)) {
return -1;
} else {
if (((List<Integer>) (((Map.Entry) (o1)).getValue()))
.get(2) > ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(2)) {
return 1;
} else if (((List<Integer>) (((Map.Entry) (o1))
.getValue())).get(2) > ((List<Integer>) (((Map.Entry) (o2))
.getValue())).get(2)) {
return -1;
} else {
return 0;
}
}
}
}
});
Map result = new LinkedHashMap();
for (Iterator it = list.iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
result.put(entry.getKey(), entry.getValue());
}
return result;
}
我总是使用比较器。如果不想创建新类，可以这样做：
Map<String, List<Integer>> dataMap = new HashMap<String, List<Integer>>();
ArrayList<Data> data = new ArrayList<Data>();
// ....
data.add(new Data("Id1", 4, 230, 350));
data.add(new Data("Id2", 1, 530, 340));
data.add(new Data("Id3", 3, 340, 340));
data.add(new Data("Id4", 2, 300, 200));
// ....
System.out.println("Unsorted: " + data);
data.sort(new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
if(o1.x > o2.x)
{
return 1;
}
else
{
return -1;
}
}
});
System.out.println("Sorted by x: " + data);
public class Data {
Data(String id, int x, int y, int z)
{
this.id = id;
this.x = x;
this.y = y;
this.z = z;
}
String id;
int x; // Sort by x
int y;
int z;
@Override
public String toString() {
return id;
}
}
Map<String, List<Integer>> dataMap = new HashMap<String, List<Integer>>();
ArrayList<Data> data = new ArrayList<Data>();
// ....
data.add(new Data("Id1", 4, 230, 350));
data.add(new Data("Id2", 1, 530, 340));
data.add(new Data("Id3", 3, 340, 340));
data.add(new Data("Id4", 2, 300, 200));
// ....
System.out.println("Unsorted: " + data);
data.sort(new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
if(o1.x > o2.x)
{
return 1;
}
else
{
return -1;
}
}
});
System.out.println("Sorted by x: " + data);
public class Data {
Data(String id, int x, int y, int z)
{
this.id = id;
this.x = x;
this.y = y;
this.z = z;
}
String id;
int x; // Sort by x
int y;
int z;
@Override
public String toString() {
return id;
}
}
我总是使用比较器。如果不想创建新类，可以这样做：
Map<String, List<Integer>> dataMap = new HashMap<String, List<Integer>>();
ArrayList<Data> data = new ArrayList<Data>();
// ....
data.add(new Data("Id1", 4, 230, 350));
data.add(new Data("Id2", 1, 530, 340));
data.add(new Data("Id3", 3, 340, 340));
data.add(new Data("Id4", 2, 300, 200));
// ....
System.out.println("Unsorted: " + data);
data.sort(new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
if(o1.x > o2.x)
{
return 1;
}
else
{
return -1;
}
}
});
System.out.println("Sorted by x: " + data);
public class Data {
Data(String id, int x, int y, int z)
{
this.id = id;
this.x = x;
this.y = y;
this.z = z;
}
String id;
int x; // Sort by x
int y;
int z;
@Override
public String toString() {
return id;
}
}
Map<String, List<Integer>> dataMap = new HashMap<String, List<Integer>>();
ArrayList<Data> data = new ArrayList<Data>();
// ....
data.add(new Data("Id1", 4, 230, 350));
data.add(new Data("Id2", 1, 530, 340));
data.add(new Data("Id3", 3, 340, 340));
data.add(new Data("Id4", 2, 300, 200));
// ....
System.out.println("Unsorted: " + data);
data.sort(new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
if(o1.x > o2.x)
{
return 1;
}
else
{
return -1;
}
}
});
System.out.println("Sorted by x: " + data);
public class Data {
Data(String id, int x, int y, int z)
{
this.id = id;
this.x = x;
this.y = y;
this.z = z;
}
String id;
int x; // Sort by x
int y;
int z;
@Override
public String toString() {
return id;
}
}
我能够使用comparator，将数据保存在Map>中，并制定出解决方案
public class SortMapOnValueInteger {
public static void main(String[] args) {
Map<String, List<Integer>> unsortMap = new HashMap<String, List<Integer>>();
unsortMap.put("z", new ArrayList(Arrays.asList( 3, 1, 56)));
unsortMap.put("b", new ArrayList(Arrays.asList( 0, 2, 65)));
unsortMap.put("x", new ArrayList(Arrays.asList( 0, 2, 35)));
unsortMap.put("a", new ArrayList(Arrays.asList( 3, 3, 12)));
unsortMap.put("c", new ArrayList(Arrays.asList( 1, 4, 65)));
unsortMap.put("d", new ArrayList(Arrays.asList( 2, 4, 65)));
unsortMap.put("e", new ArrayList(Arrays.asList( 4, 3, 34)));
unsortMap.put("y", new ArrayList(Arrays.asList( 4, 2, 23)));
unsortMap.put("n", new ArrayList(Arrays.asList( 3, 1, 23)));
unsortMap.put("j", new ArrayList(Arrays.asList( 2, 2, 54)));
unsortMap.put("m", new ArrayList(Arrays.asList( 1, 3, 96)));
unsortMap.put("f", new ArrayList(Arrays.asList( 0, 4, 54)));
System.out.println("Unsort Map......");
printMap(unsortMap);
System.out.println("\nSorted Map......");
Map<String, List<Integer>> sortedMap = sortByComparator(unsortMap);
printMap(sortedMap);
}
private static Map<String, List<Integer>> sortByComparator(Map<String, List<Integer>> unsortMap) {
// Convert Map to List
List<Map.Entry<String, List<Integer>>> list;
list = new ArrayList<>(unsortMap.entrySet());
// Sort list with comparator, to compare the Map values
Collections.sort(list, new Comparator<Map.Entry<String, List<Integer>>>() {
public int compare(Map.Entry<String, List<Integer>> o1,
Map.Entry<String, List<Integer>> o2) {
int comparison = Integer.compare(o1.getValue().get(0), o2.getValue().get(0));
if (comparison != 0) return comparison;
comparison = Integer.compare(o1.getValue().get(1), o2.getValue().get(1));
if (comparison != 0) return comparison;
return Integer.compare(o1.getValue().get(2), o2.getValue().get(2));
}
});
// Convert sorted map back to a Map
Map<String, List<Integer>> sortedMap = new LinkedHashMap<String, List<Integer>>();
for (Iterator<Map.Entry<String, List<Integer>>> it = list.iterator(); it.hasNext();) {
Map.Entry<String, List<Integer>> entry = it.next();
sortedMap.put(entry.getKey(), entry.getValue());
}
return sortedMap;
}
public static void printMap(Map<String, List<Integer>> map) {
for (Map.Entry<String, List<Integer>> entry : map.entrySet()) {
System.out.println("[Key] : " + entry.getKey()
+ " [Value] : " + entry.getValue());
}
}
}
我能够使用comparator，将数据保存在Map>中，并制定出解决方案
public class SortMapOnValueInteger {
public static void main(String[] args) {
Map<String, List<Integer>> unsortMap = new HashMap<String, List<Integer>>();
unsortMap.put("z", new ArrayList(Arrays.asList( 3, 1, 56)));
unsortMap.put("b", new ArrayList(Arrays.asList( 0, 2, 65)));
unsortMap.put("x", new ArrayList(Arrays.asList( 0, 2, 35)));
unsortMap.put("a", new ArrayList(Arrays.asList( 3, 3, 12)));
unsortMap.put("c", new ArrayList(Arrays.asList( 1, 4, 65)));
unsortMap.put("d", new ArrayList(Arrays.asList( 2, 4, 65)));
unsortMap.put("e", new ArrayList(Arrays.asList( 4, 3, 34)));
unsortMap.put("y", new ArrayList(Arrays.asList( 4, 2, 23)));
unsortMap.put("n", new ArrayList(Arrays.asList( 3, 1, 23)));
unsortMap.put("j", new ArrayList(Arrays.asList( 2, 2, 54)));
unsortMap.put("m", new ArrayList(Arrays.asList( 1, 3, 96)));
unsortMap.put("f", new ArrayList(Arrays.asList( 0, 4, 54)));
System.out.println("Unsort Map......");
printMap(unsortMap);
System.out.println("\nSorted Map......");
Map<String, List<Integer>> sortedMap = sortByComparator(unsortMap);
printMap(sortedMap);
}
private static Map<String, List<Integer>> sortByComparator(Map<String, List<Integer>> unsortMap) {
// Convert Map to List
List<Map.Entry<String, List<Integer>>> list;
list = new ArrayList<>(unsortMap.entrySet());
// Sort list with comparator, to compare the Map values
Collections.sort(list, new Comparator<Map.Entry<String, List<Integer>>>() {
public int compare(Map.Entry<String, List<Integer>> o1,
Map.Entry<String, List<Integer>> o2) {
int comparison = Integer.compare(o1.getValue().get(0), o2.getValue().get(0));
if (comparison != 0) return comparison;
comparison = Integer.compare(o1.getValue().get(1), o2.getValue().get(1));
if (comparison != 0) return comparison;
return Integer.compare(o1.getValue().get(2), o2.getValue().get(2));
}
});
// Convert sorted map back to a Map
Map<String, List<Integer>> sortedMap = new LinkedHashMap<String, List<Integer>>();
for (Iterator<Map.Entry<String, List<Integer>>> it = list.iterator(); it.hasNext();) {
Map.Entry<String, List<Integer>> entry = it.next();
sortedMap.put(entry.getKey(), entry.getValue());
}
return sortedMap;
}
public static void printMap(Map<String, List<Integer>> map) {
for (Map.Entry<String, List<Integer>> entry : map.entrySet()) {
System.out.println("[Key] : " + entry.getKey()
+ " [Value] : " + entry.getValue());
}
}
}
我不想有一个新的类，我可以用列表或映射来完成这个任务吗？我不想有一个新的类，我可以用列表或映射来完成这个任务吗？不创建一个新的类是否可能？MyObject您的数据是一个包含1个字符串和3个整数的复合数据。当您根据顺序、估计值和实际值进行排序时，您如何确保您的数据绑定在一起（即您的数据未被置乱）我可以有一个地图列表，id为键，值为[顺序、估计值、实际值]列表，并根据值进行排序，但是，我不知道如何对列表中的值进行排序。如果不创建一个新的类MyObject，是否可能？您的数据是一个包含1个字符串和3个整数的复合数据。当您根据顺序、估计值和实际值进行排序时，您如何确保您的数据绑定在一起（即您的数据未被置乱）我可以有一个地图列表，id为键，值为[顺序、估计值、实际值]列表，并根据值进行排序，但我不知道如何对值进行排序list@User007-我建议您使用一个单独的类，因为它使代码更干净，更面向对象