使用Java中的通用类创建的排序列表列表

Question

我创建了一个名为Pair的类，该类是L和R的通用类型，它基本上允许我存储对。

我正在使用Arraylist来存储类型Pair，但我不知道如何根据key/value排列（并潜在搜索所有元素）数组列表，并打印ArrayList。

ArrayList<Pair> a = new ArrayList<Pair>(); 

    Pair p = new Pair(1,1); 
    a.add(p); 
    a.add(new Pair(1,3)); 

    //System.out.println(help please); 

下面是Pair类

class Pair<L,R> { 

     L left; 
     R right; 

     public Pair(L left, R right) { 
     this.left = left; 
     this.right = right; 
     } 

     public L getLeft() { return left; } 
     public R getRight() { return right; } 

     @Override 
     public int hashCode() { return left.hashCode()^right.hashCode(); } 

     @Override 
     public boolean equals(Object o) { 
     if (!(o instanceof Pair)) return false; 
     Pair pairo = (Pair) o; 
     return this.left.equals(pairo.getLeft()) && 
       this.right.equals(pairo.getRight()); 
     } 




    } 

Answer 1

下面是一个适用于您的工作代码示例（它使用了一些Java 8功能，但如果您限制为较低版本，则可以将它们换出）。希望这可以帮助！

感谢， 邓肯

package com.hiveit; 

import java.util.ArrayList; 
import java.util.List; 
import java.util.stream.Collectors; 

public class Pair<L extends Comparable<L>, R extends Comparable<R>> implements Comparable<Pair<L, R>> { 

    L left; 
    R right; 

    public Pair(final L left, final R right) { 
    this.left = left; 
    this.right = right; 
    } 

    public L getLeft() { 
    return left; 
    } 

    public R getRight() { 
    return right; 
    } 

    @Override 
    public int hashCode() { 
    final int prime = 31; 
    int result = 1; 
    result = prime * result + (left == null ? 0 : left.hashCode()); 
    result = prime * result + (right == null ? 0 : right.hashCode()); 
    return result; 
    } 

    @Override 
    public boolean equals(final Object obj) { 
    if (this == obj) { 
     return true; 
    } 
    if (obj == null) { 
     return false; 
    } 
    if (getClass() != obj.getClass()) { 
     return false; 
    } 
    final Pair<?, ?> other = (Pair<?, ?>) obj; 
    if (left == null) { 
     if (other.left != null) { 
     return false; 
     } 
    } else if (!left.equals(other.left)) { 
     return false; 
    } 
    if (right == null) { 
     if (other.right != null) { 
     return false; 
     } 
    } else if (!right.equals(other.right)) { 
     return false; 
    } 
    return true; 
    } 

    @Override 
    public int compareTo(final Pair<L, R> other) { 

    final int compareLeft = left.compareTo(other.left); 

    if (compareLeft != 0) { 
     return compareLeft; 
    } 

    return right.compareTo(other.right); 
    } 

    @Override 
    public String toString() { 
    return "Pair [left=" + left + ", right=" + right + "]"; 
    } 

    public static String listToString(final List<?> list) { 
    return list.stream().map((pair) -> { 
     return pair.toString(); 
    }).collect(Collectors.joining(", ")); 
    } 

    public static void main(final String[] args) { 

    final List<Pair<Integer, Integer>> a = new ArrayList<>(); 

    a.add(new Pair<>(1, 1)); 
    a.add(new Pair<>(2, 1)); 
    a.add(new Pair<>(2, 3)); 
    a.add(new Pair<>(1, 2)); 
    a.add(new Pair<>(1, 3)); 
    a.add(new Pair<>(2, 2)); 

    final List<Pair<Integer, Integer>> sortedByKey = new ArrayList<>(a); 
    sortedByKey.sort((o1, o2) -> { 
     return o1.getLeft().compareTo(o2.getLeft()); 
    }); 

    sortedByKey.stream().map((pair) -> { 
     return pair.toString(); 
    }).collect(Collectors.joining(", ")); 

    final List<Pair<Integer, Integer>> sortedByValue = new ArrayList<>(a); 
    sortedByValue.sort((o1, o2) -> { 
     return o1.getRight().compareTo(o2.getRight()); 
    }); 

    final List<Pair<Integer, Integer>> sortedByKeyAndValue = new ArrayList<>(a); 
    sortedByKeyAndValue.sort((o1, o2) -> { 
     return o1.compareTo(o2); 
    }); 

    System.out.println("Original     = " + listToString(a)); 
    System.out.println("Sorted by Left   = " + listToString(sortedByKey)); 
    System.out.println("Sorted by Right   = " + listToString(sortedByValue)); 
    System.out.println("Sorted by Left then Right = " + listToString(sortedByKeyAndValue)); 

    } 
} 

Answer 2

集合API提供是sort效用此。

http://docs.oracle.com/javase/tutorial/collections/interfaces/order.html

您只需编写一个类来实现一个Comparator您Pair类。

Answer 3

你的Pair类可以例如implement Comparator<Pair>接口。之后，您执行方法

@Override 
public int compare(Pair o1, Pair o2) { 
    // here you need to implement how one Pair can be compared to another 
    // in the scope of ordering them 
    // you need to fulfil the contract of the Comparator.compare interface 
} 

Answer 4

请勿使用Pair类。如果您需要的是使用TreeMap对带有泛型类型的键/值对进行排序，遍历和有效的集合。