Сравните список массивов со связанным списком, добавив элемент в связанный список, используя Java 8

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 ... (I понятия не имею)
Не меняйте порядок уже существующих элементов (в приведенном выше примере 8-> 7-> 6 не меняли порядок)

Я пытался использовать простой Core Java, используя два цикла for для сравнения и вставки в связанный список

    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

Как описано в моем посте с вопросом, все, что мне нужно, это та же реализация указанного проблема с использованием синтаксиса Java 8 (т. е. с использованием потоков, фильтров и т. д.)

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

Answer 2

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

Имеет смысл работать с использованием подсписков "убывающий / не увеличивающийся / ...":

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

Теперь объединение происходит просто.

Действительно, фактических подсписков не требуется, достигая AL 5, LL 8, один продолжается 8,7,6 пока следующий больше 8 элемента не будет найден: 8,7,4,6,9] будет [[8,7,4,6], [9]].

Остальная домашняя работа - ваша работа.

Answer 3

Вы можете попробовать это ..

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 4

Ниже код только для достижения требования.Это не может быть хорошим способом использования потока.Но добивается результата.Надеюсь, что это помогает.

   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 5

В вашей задаче есть странные требования.Во-первых, логика может быть полностью описана в терминах списков, нет необходимости указывать, что один список должен быть ArrayList, а другой - LinkedList.

Также нецелесообразно требовать использованияStream API для задачи, особенно для задачи, которая не подходит для Stream API.

Было бы более разумно, если бы LinkedList был назначен с намерением использовать его возможность дешевых вставок при произвольномпозиции.Это преимущество может быть использовано только при использовании итератора , для которого при 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, по крайней мерене без нарушения некоторых его правил.Прочитайте Невмешательство и Режимы без сохранения состояния для получения более подробной информации.