Java，按日期排序列出不同的类型

我有三个列表<代码>列表a，

列表b和
列表c。
类型A、B和C具有日期属性。
如何按日期排列三个列表并按日期打印所有项目，如本例所示

        List<A> a = new ArrayList<A>();
        a.add(new A("1", "22/04/2017", "", ""));
        a.add(new A("2", "25/04/2017", "", ""));
        a.add(new A("3", "30/04/2017", "", ""));
        a.add(new A("4", "01/04/2017", "", ""));


        List<B> b = new ArrayList<B>();
        b.add(new B("5", "23/04/2017", "", ""));
        b.add(new B("6", "05/04/2017", "", ""));

        List<C> c = new ArrayList<C>();
        c.add(new C("7", "26/04/2017", "", ""));
        c.add(new C("8", "02/04/2017", "", ""));

如果您使用的是Java8

如果我能理解你的课堂设计是这样的：

List<List<String>> k = new ArrayList<>();
a.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));
b.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));
b.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));


Collections.sort(k, (o1, o2) -> {
    return o1.get(1).compareTo(o2.get(1));
});

k.forEach((v) -> System.out.println(v.get(0) + "____" + v.get(1)));

A类

class A {

    String s1;
    String s2;
    String s3;
    String s4;

    public A(String s1, String s2, String s3, String s4) {
        this.s1 = s1;
        this.s2 = s2;
        this.s3 = s3;
        this.s4 = s4;
    }
    //..getters and setter
}

B类

class B extends A {

    public B(String s1, String s2, String s3, String s4) {
        super(s1, s2, s3, s4);
    }

}

C类

class C extends A {

    public C(String s1, String s2, String s3, String s4) {
        super(s1, s2, s3, s4);
    }
}

在这种情况下，您可以使用：

//Create a List, and add all the a, b, c List to this list
List<A> k = new ArrayList<>();
k.addAll(a);
k.addAll(b);
k.addAll(c);

List<String> k = new ArrayList<>();
a.forEach((v)-> k.add(v.s2));
b.forEach((v)-> k.add(v.s2));
c.forEach((v)-> k.add(v.s2));

Collections.sort(k, String::compareTo);

k.forEach((v) -> System.out.println(v));

打印您的列表

k.forEach((v) -> System.out.println(v.getS2()));


编辑

解决方案2

如果您的班级之间没有关系，您可以使用：

//Create a List, and add all the a, b, c List to this list
List<A> k = new ArrayList<>();
k.addAll(a);
k.addAll(b);
k.addAll(c);

List<String> k = new ArrayList<>();
a.forEach((v)-> k.add(v.s2));
b.forEach((v)-> k.add(v.s2));
c.forEach((v)-> k.add(v.s2));

Collections.sort(k, String::compareTo);

k.forEach((v) -> System.out.println(v));

List k=new ArrayList（）；
a、 forEach（（v）->k.add（v.s2））；
b、 forEach（（v）->k.add（v.s2））；
c、 forEach（（v）->k.add（v.s2））；
Collections.sort（k，String:：compareTo）；
k、 forEach（（v）->System.out.println（v））；


解决方案3

如果你想走得更远，你可以：

创建一个公共类（CommonClass），该类接受三个类之间的公共属性
创建此类型的列表（CommonClass）
循环抛出这3个列表，创建CommonClass的新对象，并将它们添加到新列表中
然后对最终列表进行排序
或：

解决方案4

您可以像这样创建一个
列表
：

List<List<String>> k = new ArrayList<>();
a.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));
b.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));
b.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));


Collections.sort(k, (o1, o2) -> {
    return o1.get(1).compareTo(o2.get(1));
});

k.forEach((v) -> System.out.println(v.get(0) + "____" + v.get(1)));

List k=new ArrayList（）；
a、 forEach（（v）->k.add（Arrays.asList（v.s1、v.s2、v.s3、v.s4））；
b、 forEach（（v）->k.add（Arrays.asList（v.s1、v.s2、v.s3、v.s4））；
b、 forEach（（v）->k.add（Arrays.asList（v.s1、v.s2、v.s3、v.s4））；
集合。排序（k，（o1，o2）->{
返回o1.get（1）。与（o2.get（1））进行比较；
});
k、 forEach（（v）->System.out.println（v.get（0）+“\uuuuuuuuuuuuuuu”+v.get（1））；
如果您使用的是Java 8

如果我能理解你的课堂设计是这样的：

List<List<String>> k = new ArrayList<>();
a.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));
b.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));
b.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));


Collections.sort(k, (o1, o2) -> {
    return o1.get(1).compareTo(o2.get(1));
});

k.forEach((v) -> System.out.println(v.get(0) + "____" + v.get(1)));

A类

class A {

    String s1;
    String s2;
    String s3;
    String s4;

    public A(String s1, String s2, String s3, String s4) {
        this.s1 = s1;
        this.s2 = s2;
        this.s3 = s3;
        this.s4 = s4;
    }
    //..getters and setter
}

B类

class B extends A {

    public B(String s1, String s2, String s3, String s4) {
        super(s1, s2, s3, s4);
    }

}

C类

class C extends A {

    public C(String s1, String s2, String s3, String s4) {
        super(s1, s2, s3, s4);
    }
}

在这种情况下，您可以使用：

//Create a List, and add all the a, b, c List to this list
List<A> k = new ArrayList<>();
k.addAll(a);
k.addAll(b);
k.addAll(c);

List<String> k = new ArrayList<>();
a.forEach((v)-> k.add(v.s2));
b.forEach((v)-> k.add(v.s2));
c.forEach((v)-> k.add(v.s2));

Collections.sort(k, String::compareTo);

k.forEach((v) -> System.out.println(v));

打印您的列表

k.forEach((v) -> System.out.println(v.getS2()));


编辑

解决方案2

如果您的班级之间没有关系，您可以使用：

//Create a List, and add all the a, b, c List to this list
List<A> k = new ArrayList<>();
k.addAll(a);
k.addAll(b);
k.addAll(c);

List<String> k = new ArrayList<>();
a.forEach((v)-> k.add(v.s2));
b.forEach((v)-> k.add(v.s2));
c.forEach((v)-> k.add(v.s2));

Collections.sort(k, String::compareTo);

k.forEach((v) -> System.out.println(v));

List k=new ArrayList（）；
a、 forEach（（v）->k.add（v.s2））；
b、 forEach（（v）->k.add（v.s2））；
c、 forEach（（v）->k.add（v.s2））；
Collections.sort（k，String:：compareTo）；
k、 forEach（（v）->System.out.println（v））；


解决方案3

如果你想走得更远，你可以：

创建一个公共类（CommonClass），该类接受三个类之间的公共属性
创建此类型的列表（CommonClass）
循环抛出这3个列表，创建CommonClass的新对象，并将它们添加到新列表中
然后对最终列表进行排序
或：

解决方案4

您可以像这样创建一个
列表
：

List<List<String>> k = new ArrayList<>();
a.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));
b.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));
b.forEach((v) -> k.add(Arrays.asList(v.s1, v.s2, v.s3, v.s4)));


Collections.sort(k, (o1, o2) -> {
    return o1.get(1).compareTo(o2.get(1));
});

k.forEach((v) -> System.out.println(v.get(0) + "____" + v.get(1)));

List k=new ArrayList（）；
a、 forEach（（v）->k.add（Arrays.asList（v.s1、v.s2、v.s3、v.s4））；
b、 forEach（（v）->k.add（Arrays.asList（v.s1、v.s2、v.s3、v.s4））；
b、 forEach（（v）->k.add（Arrays.asList（v.s1、v.s2、v.s3、v.s4））；
集合。排序（k，（o1，o2）->{
返回o1.get（1）。与（o2.get（1））进行比较；
});
k、 forEach（（v）->System.out.println（v.get（0）+“\uuuuuuuuuuuuuuu”+v.get（1））；
您可以创建所有项目的流，并使用自定义比较器对其进行排序：

Stream.of(a, b, c).flatMap(List::stream)
        .sorted(Comparator.comparing(o -> {
            if (o instanceof A) return ((A) o).date;
            if (o instanceof B) return ((B) o).date;
            if (o instanceof C) return ((C) o).date;
            throw new RuntimeException("illegal type");
        }))
        .forEach(System.out::println);

您可以创建所有项目的流，并使用自定义比较器对其进行排序：

Stream.of(a, b, c).flatMap(List::stream)
        .sorted(Comparator.comparing(o -> {
            if (o instanceof A) return ((A) o).date;
            if (o instanceof B) return ((B) o).date;
            if (o instanceof C) return ((C) o).date;
            throw new RuntimeException("illegal type");
        }))
        .forEach(System.out::println);

当你说要对三个不同类型的列表进行排序时，你实际上是在说要创建一个集合并对其进行排序。这意味着（至少对Java而言）这些项需要有一个公共类型

一旦它们在一个共同的集合中，就需要有一套共同的方法来处理这些项目。在您在问题中给出的示例中，它们唯一能做的就是转换为字符串，尽管我希望您最终需要能够对它们执行其他操作

因此，我建议您创建一个包含要在排序列表上执行的方法的接口，然后将该类型的对象添加到列表中：

public interface ABC {
    Date getDate();
}

List<ABC> abcList;

类似地，对于
B
和
C

现在，对列表进行排序和打印非常简单：

abcList.stream()
    .sorted(Comparator.comparing(ABC::getDate))
    .map(ABC::toString)
    .forEach(System.out::println);

当你说要对三个不同类型的列表进行排序时，你实际上是在说要创建一个集合并对其进行排序。这意味着（至少对Java而言）这些项需要有一个公共类型

一旦它们在一个共同的集合中，就需要有一套共同的方法来处理这些项目。在您在问题中给出的示例中，它们唯一能做的就是转换为字符串，尽管我希望您最终需要能够对它们执行其他操作

因此，我建议您创建一个包含要在排序列表上执行的方法的接口，然后将该类型的对象添加到列表中：

public interface ABC {
    Date getDate();
}

List<ABC> abcList;

类似地，对于
B
和
C

现在，对列表进行排序和打印非常简单：

abcList.stream()
    .sorted(Comparator.comparing(ABC::getDate))
    .map(ABC::toString)
    .forEach(System.out::println);

如果您的类根本不相关，那么除了首先将所有A、B和C组合成Object类型之一之外，没有其他方法：

List<Object>

列表

然后，通过提供一个比较器对其进行排序，该比较器以艰难的方式提取所有需要的值（使用if..else与instanceof级联）

如果至少不同类的getter方法具有相同的名称（例如，第一个字符串为getId（），第二个字符串为getDate（），等等），您可以通过使用内省来避免If..else的实例。
如果您的类根本不相关，那么除了首先组装所有，将B和C转换为对象类型之一：

List<Object>

列表

然后，通过提供一个比较器对其进行排序，该比较器以艰难的方式提取所有需要的值（使用if..else与instanceof级联）

如果至少不同类的getter方法具有相同的名称（例如，第一个字符串为getId（），第二个字符串为getDate（），等等），您可以使用内省来避免If..else的实例。
您能更好地解释对