Question

我正在比较ArrayList和LinkedList。例如：

ArrayList => {2,4,5}
LinkedList => 1->3->8->7->6
Final Output => 1->2->3->4->5->8->7->6

我需要将数组列表中的元素与链接列表中的元素进行比较，并且需要插入，以便使用 JAVA 8 Streams / Filter / Map / Collections ...按排序顺序插入最终的链接列表。不知道）
请勿更改现有元素的顺序（在上面的示例8-> 7-> 6中未更改顺序）

我尝试通过使用两个for循环来比较并插入链接列表来使用简单的Core java

    for(int i=0;i<arrayList.size();i++){
         for(int j=0;j<linkedList.size();j++){
              if(linkedList.get(j)>arrayList.get(i)){
                  linkedList.add(j,arrayList.get(i));
                  break;
               }
          }
    }

我需要在Java 8中使用流，地图，过滤器，集合等替换代码

Answer 1

您的任务中有一些奇怪的要求。首先，可以完全根据列表描述逻辑，无需强制要求一个列表必须是ArrayList，而另一个列表必须是LinkedList。

对于任务，尤其是对于不适合Stream API的任务，要求使用Stream API也是没有用的。

如果授权LinkedList的目的是要利用其廉价插入任意位置的功能，那将更有意义。只有在使用 iterator 来实现此优势时，LinkedList才能使所有基于索引的访问方法实际上降低性能。

这种解决方案可能看起来像

// prerequisites
List<Integer> arrayList = new ArrayList<>(Arrays.asList(2,4,5));
List<Integer> linkedList = new LinkedList<>(Arrays.asList(1,3,8,7,6));

// changing linkedList
ListIterator<Integer> iterator = linkedList.listIterator();
for(Integer i: arrayList) {
    while(iterator.hasNext()) {
        if(iterator.next() > i) {
            iterator.previous();
            break;
        }
    }
    iterator.add(i);
}

// 1->2->3->4->5->8->7->6
System.out.println(linkedList.stream()
    .map(Object::toString).collect(Collectors.joining("->")));

这是针对LinkedList量身定制的，因为它避免了在迭代器已经链接的位置插入时多次迭代。

该逻辑不能用Stream API表示，至少不能不违反其某些规则。阅读Non-interference和Stateless behaviors了解更多详细信息。

Answer 2

您可以尝试一下。

List<Integer> arrayList = new ArrayList<>(Arrays.asList(1,3,8,7,6));
List<Integer> linkedList = new LinkedList<>(Arrays.asList(2,4,5));      

arrayList.stream().forEach(linkedList::add);        
Collections.sort(linkedList);

System.out.println(linkedList);

Out Put就像>> [1、2、3、4、5、6、7、8]

Answer 3

下面的代码只是为了达到要求。这可能不是流使用的好方法。但达到效果。希望对您有帮助。

   public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();
        List<Integer> linkedList = new LinkedList<>();

        arrayList.add(2);
        arrayList.add(4);
        arrayList.add(5);

        linkedList.add(1);
        linkedList.add(3);
        linkedList.add(8);
        linkedList.add(7);
        linkedList.add(6);

        arrayList.stream().forEach((l) -> {
                    final ReadOnlyBooleanWrapper br = new ReadOnlyBooleanWrapper(true);
                    IntStream.range(0, linkedList.size()).forEach(jIdx -> {
                        if (linkedList.get(jIdx) > l && br.get()) {
                            linkedList.add(jIdx, l);
                            br.set(false);
                        }
                    });
                }
        );

        System.out.println(linkedList);
    }

O / P：[1、2、3、4、5、8、7、6]

Answer 4

ArrayList => {2,4,5}
LinkedList => 1->3->8->7->6

使用“减少/不增加/ ...”子列表来工作很有意义：

ArrayList => [[2],[4],[5]]
LinkedList => [[1],[3],[8,7,6]]

现在合并非常简单

实际上并不需要 actual 子列表，到达AL 5，LL 8时会继续8,7,6 直到找到下一个大于8的元素：8,7,4,6,9]将为[[8,7,4,6]，[9]]。

其余的家庭作业是您的工作。

Answer 5

正如我的问题帖子中所述，我所需要的只是指定的相同实现 Java 8语法出现问题（即使用流，过滤器等）

for (Integer integer : arrayList) { 
           IntStream.range(0, linkedList.size()) 
                 .filter(j -> linkedList.get(j) > integer) 
                 .findFirst() 
                 .ifPresent(j -> linkedList.add(j, integer)); 
}

通过使用Java 8将元素添加到链接列表中来比较数组列表和链接列表

5 个答案: