Stream.toArray: примеры (JAVA)

Примеры применения

Ниже простые варианты использования с кодом и результатом.

1. toArray() без аргумента

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Stream s = Stream.of("a", "b", "c");
    Object[] arr = s.toArray();
    for (Object o : arr) System.out.print(o + " ");
  }
}

a b c 

2. toArray с генератором (типизированный массив)

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Stream s = Stream.of("one", "two", "three");
    String[] a = s.toArray(String[]::new);
    for (String x : a) System.out.print(x + ",");
  }
}

one,two,three,

3. Преобразование обёрток в примитивный массив через mapToInt

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Stream s = Stream.of(1, 2, 3);
    int[] ia = s.mapToInt(Integer::intValue).toArray();
    for (int v : ia) System.out.print(v + " ");
  }
}

1 2 3 

4. Параллельный стрим с генератором

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    String[] a = Stream.of("x","y","z").parallel().toArray(String[]::new);
    for (String s : a) System.out.print(s);
  }
}

xyz

Аналоги в Java и их отличия

• Collectors.toList() + List.toArray(T[]::new) - альтернативный путь: сначала собрать в коллекцию, затем получить массив. Удобно, когда требуются промежуточные операции коллекции или модификация размера; при этом лишняя аллокация и копирование возможны.
• Stream.collect(...) (с кастомным коллектором) - позволяет сложные сценарии заполнения и более гибкое управление памятью; полезно при параллельной агрегации со специфическими требованиями.
• IntStream/LongStream/DoubleStream.toArray() - специализированные версии для примитивов. Предпочтительнее при работе с примитивами ради отсутствия упаковки в объекты и экономии памяти.
• Arrays.copyOf(...) - служит для изменения размера уже существующего массива, но не собирает стрим напрямую; может работать вместе с ранее полученным массивом.

Аналоги в других языках

Краткие примеры эквивалентов и отличия.

JavaScript: коллекции в массив - Array.from или spread.

const it = new Set(["a","b","c"]);
const arr = Array.from(it);
const arr2 = [...it];
console.log(arr);
console.log(arr2);

[ 'a', 'b', 'c' ]
[ 'a', 'b', 'c' ]

Python: list() или comprehension; отличие - динамическая типизация и отсутствие статических массивов фиксированного типа.

it = (x for x in ['a','b','c'])
arr = list(it)
print(arr)

['a', 'b', 'c']

C#: LINQ ToArray()

using System.Linq;

var seq = new[] {"a","b","c"}.AsEnumerable();
var arr = seq.ToArray();
Console.WriteLine(string.Join(',', arr));

a,b,c

Kotlin: toTypedArray() и toIntArray() для примитивов; синтаксически ближе к Java, но более лаконично.

val list = listOf("a","b","c")
val arr = list.toTypedArray()
println(arr.joinToString())

a, b, c

Go: нет встроенных массивов из итераторов - используются срезы (slices).

items := []string{"a","b","c"}
// уже срез, можно использовать напрямую
fmt.Println(items)

[a b c]

Lua: таблицы используются как массивы.

local t = {"a","b","c"}
for i=1,#t do io.write(t[i].." ") end

a b c 

PHP: массивы являются смешанными структурами; приведение коллекции в массив - встроенное поведение.

$arr = array('a','b','c');
print_r($arr);

Array
(
    [0] => a
    [1] => b
    [2] => c
)

SQL: в реляционном контексте используется агрегат, например PostgreSQL array_agg для коллекции строк в массив.

-- PostgreSQL
SELECT array_agg(name) FROM (VALUES ('a'),('b'),('c')) AS t(name);

{a,b,c}

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

Типичные ошибки и примеры

Ниже распространённые ошибки при использовании Stream.toArray.

1. NullPointerException при передаче null в качестве генератора

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Stream s = Stream.of("a");
    String[] a = s.toArray(null); // вызовет NPE
  }
}

Exception in thread "main" java.lang.NullPointerException
	at java.base/java.util.Objects.requireNonNull(Objects.java:221)
	at java.base/java.util.stream.ReferencePipeline.toArray(ReferencePipeline.java:...)
	... 

2. IllegalStateException при повторном использовании одного и того же стрима

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Stream s = Stream.of("a","b");
    s.toArray();
    s.toArray(); // вызовет ISE
  }
}

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:...)
	... 

3. ClassCastException при приведении результатa toArray() без генератора

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Stream s = Stream.of("a","b");
    Object[] oa = s.toArray();
    String[] sa = (String[]) oa; // ClassCastException
  }
}

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
	at Main.main(Main.java:...)

4. ArrayStoreException при создании массива неправильного типа генератором

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Stream s = Stream.of(1,2,3);
    Integer[] arr = s.toArray(size -> new Number[size]); // неверный компонент массива
  }
}

Exception in thread "main" java.lang.ArrayStoreException: java.lang.Integer
	at java.base/java.lang.System.arraycopy(Native Method)
	... 

Советы по предотвращению ошибок: всегда передавать корректный генератор типа, избегать приведения из Object[], не вызывать терминальные операции повторно для одного стрима.

Изменения и оптимизации в релизах Java

Сам метод Stream.toArray появился в Java 8 и сохраняет обратную совместимость. В последующих релизах не вносилось изменений в сигнатуру API, но происходили внутренние оптимизации реализации, особенно для параллельного выполнения и уменьшения числа копирований при сборке массива. В новых версиях JVM может быть улучшена оценка размера и стратегия копирования для повышения производительности.

Для примитивных стримов специальные методы были добавлены также в Java 8 и остаются рекомендованными при работе с примитивами.

Расширенные и редкие сценарии использования

Несколько детальных примеров с пояснениями.

1. Получение массива с использованием отражения для сложного типа

import java.lang.reflect.Array;
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Stream s = Stream.of(1, 2.5, 3L);
    Number[] arr = s.toArray(size -> (Number[]) Array.newInstance(Number.class, size));
    for (Number n : arr) System.out.print(n + " ");
  }
}

1 2.5 3 

Пояснение: генератор создает массив через Array.newInstance, что полезно когда тип известен только во время выполнения.

2. Преобразование дженерик-стрима в массив заданного типа при наличии Class

import java.util.stream.Stream;
import java.lang.reflect.Array;

public class Main {
  public static  T[] toArrayOf(Stream s, Class<T> cls) {
    return s.toArray(size -> (T[]) Array.newInstance(cls, size));
  }

  public static void main(String[] args) {
    Stream s = Stream.of("x","y");
    String[] sa = toArrayOf(s, String.class);
    System.out.println(java.util.Arrays.toString(sa));
  }
}

[x, y]

Пояснение: обход ограничений дженериков за счёт передачи Class.

3. Сокращение аллокаций при повторном создании массивов: генератор возвращает заранее выделенный массив, но это опасно и не рекомендуется в параллельном контексте. Пример для однопоточного использования.

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    String[] cache = new String[10];
    Stream s = Stream.of("a","b");
    String[] arr = s.toArray(size -> new String[size]); // правильный подход
    System.out.println(java.util.Arrays.toString(arr));
  }
}

[a, b]

Комментарий: попытка переиспользовать один и тот же массив между вызовами может привести к гонкам данных в параллельных стримах и неверным результатам.

4. Преобразование коллекции в примитивный массив с использованием mapToX

import java.util.List;

public class Main {
  public static void main(String[] args) {
    List list = java.util.List.of(10,20,30);
    int[] ia = list.stream().mapToInt(Integer::intValue).toArray();
    System.out.println(java.util.Arrays.toString(ia));
  }
}

[10, 20, 30]

Пояснение: избегается упаковка в Integer и экономится память.

5. Применение в потоке с большим количеством элементов и параллельной обработкой

import java.util.stream.IntStream;

public class Main {
  public static void main(String[] args) {
    int[] arr = IntStream.range(0, 1_000_000).parallel().toArray();
    System.out.println(arr.length);
  }
}

1000000

Подсказка: для больших данных использование специализированных примитивных стримов и параллельного режима даёт прирост скорости, но потребление памяти остаётся существенным из-за полного копирования в массив.