TL;DR: см. два полных примера кода ниже и заголовки их разделов для контекста.

Подходы

Императивный подход

Императивное программирование обычно описывается как "инструктирование отдельных шагов для достижения определенную цель».

Мы можем использовать циклы for — языковую функцию связанный с императивным программированием — для перебора списков A и B, а различия их элементов собрать в список C:

import java.util.ArrayList;
import java.util.Arrays;

public class ImperativeApproach {
  public static void main(String[] args) {
    ArrayList<Double> A = new ArrayList<>(Arrays.asList(new Double[] {1d,2d,3d,4d,5d}));
    ArrayList<Double> B = new ArrayList<>(Arrays.asList(new Double[] {0d,1d,2d,3d,4d}));
    
    ArrayList<Double> C = new ArrayList<>();
    
    assert A.size() == B.size();
    int size = A.size();
    for (int i = 0; i < size; ++i) {
      C.add(A.get(i) - B.get(i));
    }
    
    System.out.println(C); // [1.0, 1.0, 1.0, 1.0, 1.0]
  }
}

Функциональный подход

Функциональное программирование более декларативно, чем императивное: оно может можно описать как «запрос определенного результата при выполнении определенных шагов».

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

Кроме того: обратите внимание, что и императивное, и функциональное программирование — это всего лишь парадигмы; способы классификации кода или языков по определенным «чертам». Пример: с добавлением потоков (см. ниже) на Java стало проще писать функциональный код на Java.

Как упоминалось ранее, мы можем использовать потоки Java. Пример:

1. Создайте поток индексов, к которым мы хотим получить доступ A/B; а именно, от 0 до size of A or B.
2. Сопоставьте индексы с различиями элементов A и B.
3. Соберите (потоковые) результаты в виде списка с именем C.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.IntStream;

public class FunctionalApproach {
  public static void main(String[] args) {
    ArrayList<Double> A = new ArrayList<>(Arrays.asList(new Double[] {1d,2d,3d,4d,5d}));
    ArrayList<Double> B = new ArrayList<>(Arrays.asList(new Double[] {0d,1d,2d,3d,4d}));
    
    assert A.size() == B.size();
    int size = A.size();
    Double[] arrayC = IntStream.range(0, size)
        .mapToDouble((index) -> A.get(index) - B.get(index))
        .boxed()
        .toArray(Double[]::new);
    
    ArrayList<Double> C = new ArrayList<>(Arrays.asList(arrayC));
    
    System.out.println(C); // [1.0, 1.0, 1.0, 1.0, 1.0]
  }
}

(@GrzegorzPiwowarek предоставил альтернативные и, возможно, лучшие реализации на похожий, но более старый вопрос.)

Дополнение

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

Утверждения

Утверждения в Java — это инструмент разработки, обеспечивающий правильную функциональность вашего кода. Если утверждения терпят неудачу, они выдают исключение. Они будут работать только в том случае, если вы правильно компилируете и включить их.

Обратите внимание, что утверждения не заменяют правильную проверку! У Oracle есть сводка того, когда использовать утверждения.

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

Примитивы и коробочные значения

(Auto-)boxing в Java относится к преобразованию примитивного значения в соответствующий класс-оболочку.

Это требуется в местах, где нельзя использовать примитивы или, скорее, там, где ожидается Object. Примерами являются Общие, такие как List, для которых вы найдете простые объяснения в < href="https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html" rel="nofollow noreferrer">руководство Oracle по автоматической упаковке.

Будьте особенно осторожны, если в вашем коде ссылки на такие классы-оболочки могут быть нулевыми: Java не может распаковать null в примитив, вместо этого вызовет исключение во время выполнения! В выше код, такой сценарий не может произойти.

В обоих подходах

Поскольку массивы более удобочитаемы и статически компилируются, я решил предоставить начальные значения списков в виде массивов. Моя реализация пришла со следующими требованиями:

1. Для построения ArrayList с начальными значениями требуется Collection.^[1]
2. Arrays.asList() возвращает Collection, но требует массив не-примитивов (здесь: массив упакованных значений; далее: упакованный массив).^[2]
3. Инициализация упакованного массива (Double[]) требует, чтобы элементы относились к соответствующему примитивному типу; нам нужно предоставить числа в виде double.^[3]
4. Объявление числовых литералов как double требует, чтобы мы добавляли к ним суффикс d (или использовали десятичную точку).^[4]

Это означает, что этот неверный код:

ArrayList<double> A = new double[]{1, 2, 3, 4, 5};

Необходимо написать, например. следующим образом:

ArrayList<Double> A = new ArrayList<>(Arrays.asList(new Double[]{1d, 2d, 3d, 4d, 5d}));

В императивном подходе

В примере с императивным подходом дальнейших изменений кода не требуется. Добавление чисел в список C автоматически упаковывает числа, потому что здесь не используется промежуточный объект с определенными ограничениями, такими как new Double[].

В функциональном подходе

В примере Потоки IntStream.mapToDouble()возвращает DoubleStream (поток, действующий на примитивы). Его toArray() вернет примитивный массив (double[]), который мы не можем легко предоставить для построения списка C, как упоминалось ранее.

Поэтому сначала нам нужно упаковать его (см. DoubleStream.boxed()), который возвращает Stream<Double>. Затем элементы этого потока можно собрать в упакованный массив (предоставив конструктор массива Double[]::new; см. Руководство Oracle "Справочники по методам").

Затем такой массив можно использовать для создания списка, как обсуждалось ранее.