reduce a parallel stream of arrays into a single array

i'm trying to reduce a parallel stream of arrays Stream<ArrayList<T>> into a single array ArrayList<T> so
i used the reduce method with accumulator and combiner as follows:-

	public static void main(String [] args) {
ArrayList<String> l1 = new ArrayList<>();
l1.add("a1");
l1.add("a2");
List<String> l2 = new ArrayList<>();
l2.add("a3");
l2.add("a4");
List<List<String>> l = new ArrayList<>();
l.add(l1);
l.add(l2);
Stream<List<String>> stream = l.stream();
join(stream).forEach(System.out::println);
}
private  static  <T> List<T> join(Stream<List<T>> stream) {
return stream.parallel().reduce(new ArrayList<>(),  (total, element) -> {
System.out.println("total: " + total);
System.out.println("element: " + element);
total.addAll(element);
return total;
},  (total1, total2) -> {
System.out.println("total1: " + total1);
System.out.println("total2: " + total2);
total1.addAll(total2);
return total1;
});
}

i knew the combiner is used to combine the parallel streams..but it is not working as i expected,
as i got duplicated results as follows:-

total: []
element: [a3, a4]
total: []
element: [a1, a2]
total1: [a3, a4, a1, a2]
total2: [a3, a4, a1, a2]
a3
a4
a1
a2
a3
a4
a1
a2

so why the result is duplicated ? also is it thread safe to use array list in accumulator ?

You should just use flatMap:

> Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element. Each mapped stream is closed after its contents have been placed into this stream. (If a mapped stream is null an empty stream is used, instead.)
>
> This is an intermediate operation.

l.stream().flatMap(x -> x.stream()).collect(Collectors.toList()); // is [a1, a2, a3, a4]

or

l.stream().flatMap(List::stream).collect(Collectors.toList());

The problem with your code is that you are mixing functional-style code with side-effects. That doesn't bode well. If you remove the side-effects, the output is as expected:

	private static <T> List<T> join(Stream<List<T>> stream) {
		return stream.parallel().reduce(new ArrayList<>(), (total, element) -> {
			System.out.println("total: " + total);
			System.out.println("element: " + element);
			//total.addAll(element);
			//return total;
			var list = new ArrayList<T>(total);
			list.addAll(element);
			return list;
		}, (total1, total2) -> {
			System.out.println("total1: " + total1);
			System.out.println("total2: " + total2);
			//total1.addAll(total2);
			//return total1;
			var list = new ArrayList<T>(total1);
			list.addAll(total2);
			return list;
		});
	}

You should also avoid using parallel() unless you have a clear, objective reason to. Parallelism is an overhead, and it only becomes more performant if there is heavy work to do. Otherwise, the synchronization overhead will be a bigger penalty than any gains.