Java 比较每个索引处每个列表的项目

我有一个字符串列表的数组列表

ArrayList<List<String>> temp = new ArrayList<List<String>>();

ArrayList temp=new ArrayList（）；

现在，假设我们有3个类似的列表：

• 清单1:[3,8,15,98]
• 清单2:[3,4,21,98]
• 清单3:[5,4,76,90]

我只想打印最小的列表。我指的是升序最小的列表。例如，如果我们采用以下三种列表：

• 在索引0处：

清单1和2的项目=3

清单项目3=5

---

3任何比较算法都可以使用Java比较器轻松编写。但是首先让我们假设您正在比较整数列表，而不是字符串列表，因为这是您正在做的。如果原始数据是以字符串格式显示的，那么显然必须将数据转换为数字类型，以便将其作为数字进行比较

通过使用自定义比较算法，您可以拥有一个树集，它可以保持其元素的顺序

您可以编写一个比较器，它可以通过多个对象属性进行比较。如果您想比较员工列表中的名字，而不是第二个名字（第1列和第2列）。在我们的例子中，我们可以按第一个索引进行比较，然后按第二个索引进行比较，然后按第三个索引进行比较，这条链可以根据需要深入到列表中

public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(3,8,15,98);
        List<Integer> list2 = Arrays.asList(3,4,21,98);
        List<Integer> list3 = Arrays.asList(5,4,76,90);

        int comparisonLength = 4;

        Comparator<List<Integer>> comparator = Comparator.comparing(list -> list.get(0));
        for(int i = 1; i< comparisonLength; i++) {
            final int comparedIndex = i;
            comparator = comparator.thenComparing(list -> list.get(comparedIndex));
        }

        TreeSet<List<Integer>> treeSet = new TreeSet<>(comparator);

        treeSet.add(list1);
        treeSet.add(list2);
        treeSet.add(list3);

        System.out.println(treeSet.iterator().next()); //prints the first element in the collection
    }

publicstaticvoidmain（字符串[]args）{
list1=Arrays.asList（3,8,15,98）；
list2=Arrays.asList（3,4,21,98）；
list3=Arrays.asList（5,4,76,90）；
int comparisonLength=4；
Comparator-Comparator=Comparator.comparing（list->list.get（0））；
for（int i=1；ilist.get（comparedIndex））；
}
TreeSet TreeSet=新的TreeSet（比较器）；
treeSet.add（列表1）；
treeSet.add（列表2）；
treeSet.add（列表3）；
System.out.println（treeSet.iterator（）.next（））；//打印集合中的第一个元素
}

公共静态void main（字符串[]args）{
列表l1=数组。asList（“3”、“8”、“15”、“98”）；
listl2=Arrays.asList（“3”、“4”、“21”、“98”）；
listl3=Arrays.asList（“5”、“4”、“76”、“90”）；
ArrayList list=（ArrayList）Stream.of（l1、l2、l3.collect（Collectors.toList（））；
System.out.println(
list.stream（）
闵先生(
（a、b）->{
对于（inti=0；i

下面是另一种方法，使用Java流：

List<Integer> list1 = Arrays.asList(3, 8, 15, 98);
List<Integer> list2 = Arrays.asList(3, 4, 21, 98);
List<Integer> list3 = Arrays.asList(5, 4, 76, 90);

Optional<List<Integer>> result = Stream.of(list1, list2, list3)
    .sorted((a, b) -> IntStream.range(0, a.size())
        .map(i -> Integer.compare(a.get(i), b.get(i)))
        .filter(i -> i != 0)
        .findFirst()
        .orElse(0))
    .findFirst();

System.out.println(result);

---

.

如果一个列表的大小小于其他列表，会发生什么情况？基本上得到列表的数量，对于每个列表，得到索引i并进行比较，然后得到索引i+1。不需要很多循环。对所有列表的索引访问已足够。通常，“我的所有列表”的大小必须相同。这不符合预期。它打印[3,4,21,98]，但应该打印我读到的[3,4,15,90]——作者是在比较列表，而不是列表中的元素，所以我假设输出是原始列表中的一个，而不是一个全新的列表？在输入中没有[3,4,15,90]这样的列表在我的示例中，列表1和列表2以3开头，所以要打印列表2，我应该比较以下元素。我认为我的答案中的代码正是您想要的？比较器由TreeSet使用，TreeSet是一个集合，它实现了SortedSet接口。在我的示例中，每当您将一个元素添加到TreeSet中时，TreeSet的内部代码通过将我们的比较器应用于这些元素来保持迭代顺序。Comparator和TreeSet保持不变，但您需要知道数组的长度以定义“comparisonLength”变量，将列表对象转换为列表对象并将其放入TreeSet。您可以使用addAll（）方法一次将它们全部放置。

public static void main(String[] args) {
        List<String> l1 = Arrays.asList("3", "8", "15", "98");
        List<String> l2 = Arrays.asList("3", "4", "21", "98");
        List<String> l3 = Arrays.asList("5", "4", "76", "90");
        ArrayList<List<String>> list = (ArrayList<List<String>>) Stream.of(l1, l2, l3).collect(Collectors.toList());

        System.out.println(
                list.stream()
                .min(
                        (a, b) -> {
                            for (int i = 0; i < Math.min(a.size(), b.size()); i++) {
                                if (!a.get(i).equals(b.get(i))) {
                                    return Integer.parseInt(a.get(i)) - Integer.parseInt(b.get(i));
                                }
                            }
                            throw new RuntimeException();
                        }
                ).orElseThrow(RuntimeException::new)
        );
    }

List<Integer> list1 = Arrays.asList(3, 8, 15, 98);
List<Integer> list2 = Arrays.asList(3, 4, 21, 98);
List<Integer> list3 = Arrays.asList(5, 4, 76, 90);

Optional<List<Integer>> result = Stream.of(list1, list2, list3)
    .sorted((a, b) -> IntStream.range(0, a.size())
        .map(i -> Integer.compare(a.get(i), b.get(i)))
        .filter(i -> i != 0)
        .findFirst()
        .orElse(0))
    .findFirst();

System.out.println(result);

(a, b) -> IntStream.range(0, Math.min(a.size(), b.size()))
    .map(i -> Integer.compare(a.get(i), b.get(i)))
    .filter(i -> i != 0)
    .findFirst()
    .orElse(Integer.compare(a.size(), b.size()))