Как конвертировать list в string[]?
Привет, обитатели тостера. Я только начал изучать C++. Я свободно работаю с ООП в PHP. Умею мыслить логически. Но понять си пока не могу.
Нужно мне отпарсить строку. Разбить ее на массив по разделителю (как explode в php). Нашел много обрывков кода. Пытаюсь собрать вместе. Но как же мне это сделать?
string* parse(string s, int sort = -1) < listwords; istringstream ist(s); string tmp; int i = 1; while (ist >> tmp) < words.push_back(tmp); i++; >string* string_array = new string[i]; switch (sort) < case -1: // UNSORTED copy(words.begin(), words.end(), ostream_iterator(cout, "\n")); break; case 0: // ASC words.sort(); copy(words.begin(), words.end(), ostream_iterator(cout, "\n")); break; case 1: // DESC words.sort(greater()); copy(words.begin(), words.end(), ostream_iterator(cout, "\n")); break; > return string_array; >Код может разбить строку и вывести результат в консоль. А мне нужен результат в виде массива строк. 3 часа уже безрезультатно гуглю.
P.S. Если не трудно, объясните по русски, что такое iterator
- Вопрос задан более трёх лет назад
- 1104 просмотра
1 комментарий
Оценить 1 комментарий
Да, вообще-то, там вектор надо сделать, заполнить его и вернуть.
Решения вопроса 1
Программист на «си с крестами» и не только
Итератор — это объект с семантикой указателя, который может указывать на N+1 точку в объекте.
Раз он с семантикой указателя, у него есть операции «унарная звезда» и −> (разыменование и разыменование+взятие поля). Также у итератора есть операция ++ (сдвинуться на следующую позицию). Если это т.н. «однонаправленный итератор» — всё, больше ничего.
Также бывают т.н. двунаправленные итераторы (есть операция −−), и итераторы произвольного доступа (их можно свободно складывать с числами — ну совсем как указатели). В частности, у std::list итераторы двунаправленные.
У итераторов неопределённое поведение…
• при попытке выйти за начало или конец;
• при попытке разыменовать, если он смотрит на последнюю позицию (отмеченную как «конец»).
Конкретно о задаче.
1. std::vector предпочтительнее std::list.
2. Не нужно возвращать string*, хватает какого-нибудь контейнера (std::vector или std::list).
3. Если функциональности и скорости istringstream хватает, флаг в руки! Я бы написал по хардкору, с нуля. Вот мой код, выдранный из моего проекта, наверно, будет несложно переделать его в учебный.
void parseCommaList( const char *aStart, // указатель на начало const char *aEnd, // указатель на символ за концом char aComma, // символ-разделитель bool aSkipEmpty, // true, если пустые подстроки пропускать ProcParseCommaList aCallback, // функция-нагрузка void *aData) // этот параметр нужен, чтобы передавать какие хочешь данные в функцию-нагрузку, удаляй его смело! < str::trim(aStart, aEnd); // моя функция; пододвигает aStart вперёд и aEnd назад, убирая пробелы. // Если удаление пробелов не нужно — удаляй! Если нужно — пиши сам. if (aStart == aEnd) return; const char *sstart = aStart; for (const char *p = aStart; p != aEnd; ++p) < if (*p != aComma) continue; const char *send = p; str::trim(sstart, send); // то же самое, можно убрать if (p != sstart || !aSkipEmpty) aCallback(sstart, send, aData); // замени на боевую нагрузку sstart = p + 1; >str::trim(sstart, aEnd); // то же самое, можно убрать if (sstart != aEnd || !aSkipEmpty) aCallback(sstart, aEnd, aData); // замени на боевую нагрузку >И, соответственно, версия для std::string.
inline void parseCommaList( const std::string &aIn, char aComma, bool aSkipEmpty, ProcParseCommaList aCallback, void *aData)
Коллекции
Хотя в языке C# есть массивы, которые хранят в себе наборы однотипных объектов, но работать с ними не всегда удобно. Например, массив хранит фиксированное количество объектов, однако что если мы заранее не знаем, сколько нам потребуется объектов. И в этом случае намного удобнее применять коллекции. Еще один плюс коллекций состоит в том, что некоторые из них реализует стандартные структуры данных, например, стек, очередь, словарь, которые могут пригодиться для решения различных специальных задач. Большая часть классов коллекций содержится в пространстве имен System.Collections.Generic .
Класс List из пространства имен System.Collections.Generic представляет простейший список однотипных объектов. Класс List типизируется типом, объекты которого будут хранится в списке.
Мы можем создать пустой список:
List people = new List();
В данном случае объект List типизируется типом string . А это значит, что хранить в этом списке мы можем только строки.
Можно сразу при создании списка инициализировать его начальными значениями. В этом случае элементы списка помещаются после вызова конструктора в фигурных скобках
List people = new List() < "Tom", "Bob", "Sam" >;
В данном случае в список помещаются три строки
Также можно при создании списка инициализировать его элементами из другой коллекции, например, другого списка:
var people = new List() < "Tom", "Bob", "Sam" >; var employees = new List(people);
Можно совместить оба способа:
var people = new List() < "Tom", "Bob", "Sam" >; var employees = new List(people);
В данном случае в списке employees будет четыре элемента ( < "Tom", "Bob", "Sam", "Mike" >) — три добавляются из списка people и один элемент задается при инициализации.
Начиная с версии C# 12 для определения списков можно использовать выражения коллекций, которые предполагают заключение элементов коллекции в квадратные скобки:
List people = ["Tom", "Bob", "Sam"]; List employees = [];// пустой список
Подобным образом можно работать со списками других типов, например:
List people = new List() < new Person("Tom"), new Person("Bob"), new Person("Sam") >; class Person < public string Name < get;>public Person(string name) => Name = name; >
Установка начальной емкости списка
Еще один конструктор класса List принимает в качестве параметра начальную емкость списка:
List people = new List(16);
Указание начальной емкости списка позволяет в будущем увеличить производительность и уменьшить издержки на выделение памяти при добавлении элементов. Поскольку динамическое добавление в список может приводить на низком уровне к дополнительному выделению памяти, что снижает производительность. Если же мы знаем, что список не будет превышать некоторый размер, то мы можем передать этот размер в качестве емкости списка и избежать дополнительных выделений памяти.
Также начальную емкость можно установить с помощью свойства Capacity , которое имеется у класса List.
Обращение к элементам списка
Как и массивы, списки поддерживают индексы, с помощью которых можно обратиться к определенным элементам:
var people = new List() < "Tom", "Bob", "Sam" >; string firstPerson = people[0]; // получаем первый элемент Console.WriteLine(firstPerson); // Tom people[0] = "Mike"; // изменяем первый элемент Console.WriteLine(people[0]); // Mike
Длина списка
С помощью свойства Count можно получить длину списка:
var people = new List() < "Tom", "Bob", "Sam" >; Console.WriteLine(people.Count); // 3
Перебор списка
C# позволяет осуществить перебор списка с помощью стандартного цикла foreach :/p>
var people = new List() < "Tom", "Bob", "Sam" >; foreach (var person in people) < Console.WriteLine(person); >// Вывод программы: // Tom // Bob // Sam
Также можно использовать другие типы циклов и в комбинации с индексами перебирать списки:
var people = new List() < "Tom", "Bob", "Sam" >; for (int i = 0; i
Методы списка
Среди его методов можно выделить следующие:
- void Add(T item) : добавление нового элемента в список
- void AddRange(IEnumerable collection) : добавление в список коллекции или массива
- int BinarySearch(T item) : бинарный поиск элемента в списке. Если элемент найден, то метод возвращает индекс этого элемента в коллекции. При этом список должен быть отсортирован.
- void CopyTo(T[] array) : копирует список в массив array
- void CopyTo(int index, T[] array, int arrayIndex, int count) : копирует из списка начиная с индекса index элементы, количество которых равно count, и вставляет их в массив array начиная с индекса arrayIndex
- bool Contains(T item) : возвращает true , если элемент item есть в списке
- void Clear() : удаляет из списка все элементы
- bool Exists(Predicate match) : возвращает true , если в списке есть элемент, который соответствует делегату match
- T? Find(Predicate match) : возвращает первый элемент, который соответствует делегату match. Если элемент не найден, возвращается null
- T? FindLast(Predicate match) : возвращает последний элемент, который соответствует делегату match. Если элемент не найден, возвращается null
- List FindAll(Predicate match) : возвращает список элементов, которые соответствуют делегату match
- int IndexOf(T item) : возвращает индекс первого вхождения элемента в списке
- int LastIndexOf(T item) : возвращает индекс последнего вхождения элемента в списке
- List GetRange(int index, int count) : возвращает список элементов, количество которых равно count, начиная с индекса index.
- void Insert(int index, T item) : вставляет элемент item в список по индексу index. Если такого индекса в списке нет, то генерируется исключение
- void InsertRange(int index, collection) : вставляет коллекцию элементов collection в текущий список начиная с индекса index. Если такого индекса в списке нет, то генерируется исключение
- bool Remove(T item) : удаляет элемент item из списка, и если удаление прошло успешно, то возвращает true. Если в списке несколько одинаковых элементов, то удаляется только первый из них
- void RemoveAt(int index) : удаление элемента по указанному индексу index. Если такого индекса в списке нет, то генерируется исключение
- void RemoveRange(int index, int count) : параметр index задает индекс, с которого надо удалить элементы, а параметр count задает количество удаляемых элементов.
- int RemoveAll((Predicate match)) : удаляет все элементы, которые соответствуют делегату match. Возвращает количество удаленных элементов
- void Reverse() : изменяет порядок элементов
- void Reverse(int index, int count) : изменяет порядок на обратный для элементов, количество которых равно count, начиная с индекса index
- void Sort() : сортировка списка
- void Sort(IComparer? comparer) : сортировка списка с помощью объекта comparer, который передается в качестве параметра
Добавление в список
List people = new List () < "Tom" >; people.Add("Bob"); // добавление элемента // people = < "Tom", "Bob" >; people.AddRange(new[] < "Sam", "Alice" >); // добавляем массив // people = < "Tom", "Bob", "Sam", "Alice" >; // также можно было бы добавить другой список // people.AddRange(new List()< "Sam", "Alice" >); people.Insert(0, "Eugene"); // вставляем на первое место // people = < "Eugene", "Tom", "Bob", "Sam", "Alice" >; people.InsertRange(1, new string[] ); // вставляем массив с индекса 1 // people = < "Eugene", "Mike", "Kate", "Tom", "Bob", "Sam", "Alice" >; // также можно было бы добавить другой список // people.InsertRange(1, new List()< "Mike", "Kate" >);
Удаление из списка
var people = new List () < "Eugene", "Mike", "Kate", "Tom", "Bob", "Sam", "Tom", "Alice" >; people.RemoveAt(1); // удаляем второй элемент // people = < "Eugene", "Kate", "Tom", "Bob", "Sam", "Tom", "Alice" >; people.Remove("Tom"); // удаляем элемент "Tom" // people = < "Eugene", "Kate", "Bob", "Sam", "Tom", "Alice" >; // удаляем из списка все элементы, длина строки которых равна 3 people.RemoveAll(person => person.Length == 3); // people = < "Eugene", "Kate", "Alice" >; // удаляем из списка 2 элемента начиная с индекса 1 people.RemoveRange(1, 2); // people = < "Eugene">; // полностью очищаем список people.Clear(); // people = < >;
Поиск и проверка элемента
var people = new List () < "Eugene", "Mike", "Kate", "Tom", "Bob", "Sam" >; var containsBob = people.Contains(«Bob»); // true var containsBill = people.Contains(«Bill»); // false // проверяем, есть ли в списке строки с длиной 3 символа var existsLength3 = people.Exists(p => p.Length == 3); // true // проверяем, есть ли в списке строки с длиной 7 символов var existsLength7 = people.Exists(p => p.Length == 7); // false // получаем первый элемент с длиной в 3 символа var firstWithLength3 = people.Find(p => p.Length == 3); // Tom // получаем последний элемент с длиной в 3 символа var lastWithLength3 = people.FindLast(p => p.Length == 3); // Sam // получаем все элементы с длиной в 3 символа в виде списка List peopleWithLength3 = people.FindAll(p => p.Length == 3); // peopleWithLength3
Получение диапазона и копирование в массив
List people = new List() ; // получаем диапазон со второго по четвертый элемент var range = people.GetRange(1, 3); // range = < "Tom", "Mike", "Sam">; // копируем в массив первые три элемента string[] partOfPeople = new string[3]; people.CopyTo(0, partOfPeople, 0, 3); // partOfPeople = < "Eugene", "Tom", "Mike">;
Расположение элементов в обратном порядке
var people = new List () < "Eugene", "Tom", "Mike", "Sam", "Bob" >; // переворачиваем весь список people.Reverse(); // people = < "Bob","Sam", "Mike", "Tom", "Eugene">; var people2 = new List() < "Eugene", "Tom", "Mike", "Sam", "Bob" >; // переворачиваем часть только 3 элемента с индекса 1 people2.Reverse(1, 3); // people2 = < "Eugene","Sam", "Mike", "Tom", "Bob" >;
Массивы
Большинство программ работает не с отдельными переменными, а с набором переменных. Например, программа может обрабатывать информацию об учащихся класса, считывая список учащихся с клавиатуры или из файла, при этом изменение количества учащихся в классе не должно требовать модификации исходного кода программы.
Раньше мы сталкивались с задачей обработки элементов последовательности, например, вычисляя наибольший элемент последовательности. Но при этом мы не сохраняли всю последовательность в памяти компьютера, однако, во многих задачах нужно именно сохранять всю последовательность, например, если бы нам требовалось вывести все элементы последовательности в возрастающем порядке (“отсортировать последовательность”).
Для хранения таких данных можно использовать структуру данных, называемую в Питоне список (в большинстве же языков программирования используется другой термин “массив”). Список представляет собой последовательность элементов, пронумерованных от 0, как символы в строке. Список можно задать перечислением элементов списка в квадратных скобках, например, список можно задать так:
Primes = [2, 3, 5, 7, 11, 13]
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']
В списке Primes — 6 элементов, а именно, Primes[0] == 2, Primes[1] == 3, Primes[2] == 5, Primes[3] == 7, Primes[4] == 11, Primes[5] == 13. Список Rainbow состоит из 7 элементов, каждый из которых является строкой.
Также как и символы строки, элементы списка можно индексировать отрицательными числами с конца, например, Primes[-1] == 13, Primes[-6] == 2.
Длину списка, то есть количество элементов в нем, можно узнать при помощи функции len, например, len(A) == 6.
Рассмотрим несколько способов создания и считывания списков. Прежде всего можно создать пустой список (не содержащий элементов, длины 0), в конец списка можно добавлять элементы при помощи метода append. Например, если программа получает на вход количество элементов в списке n, а потом n элементов списка по одному в отдельной строке, то организовать считывание списка можно так:
A = []
for i in range(int(input()):
A.append(int(input())
В этом примере создается пустой список, далее считывается количество элементов в списке, затем по одному считываются элементы списка и добавляются в его конец.
Для списков целиком определены следующие операции: конкатенация списков (добавление одного списка в конец другого) и повторение списков (умножение списка на число). Например:
A = [1, 2, 3]
B = [4, 5]
C = A + B
D = B * 3
В результате список C будет равен [1, 2, 3, 4, 5], а список D будет равен [4, 5, 4, 5, 4, 5]. Это позволяет по-другому организовать процесс считывания списков: сначала считать размер списка и создать список из нужного числа элементов, затем организовать цикл по переменной i начиная с числа 0 и внутри цикла считывается i-й элемент списка:
A = [0] * int(input())
for i in range(len(A)):
A[i] = int(input())
Вывести элементы списка A можно одной инструкцией print(A), при этом будут выведены квадратные скобки вокруг элементов списка и запятые между элементами списка. Такой вывод неудобен, чаще требуется просто вывести все элементы списка в одну строку или по одному элементу в строке. Приведем два примера, также отличающиеся организацией цикла:
for i in range(len(A)):
print(A[i])
Здесь в цикле меняется индекс элемента i, затем выводится элемент списка с индексом i.
for elem in A:
print(elem, end = ' ')
В этом примере элементы списка выводятся в одну строку, разделенные пробелом, при этом в цикле меняется не индекс элемента списка, а само значение переменной (например, в цикле for elem in [‘red’, ‘green’, ‘blue’] переменная elem будет последовательно принимать значения ‘red’, ‘green’, ‘blue’.
Java list to array: преобразуем список элементов в массив
Привет! В данной статье мы рассмотрим, как в Java преобразовать список элементов в массив элементов. Собственно, способов сделать это не так уж и много, и все они простые, так что статья будет несложной. Сразу же определимся, с чем мы работаем. Будем конвертировать списки в массивы, а конкретнее — список строк: I, love, learning, on, JavaRush будем преобразовывать в массив таких же строк. Но для начала маленький бонус. Расскажем о том, как по быстрому запилить списочек.
Как по быстрому запилить списочек list to array
Запомни: в этой жизни есть два сценария. Первый — полнейшая тоска и скука, когда мы инициализируем новый список:
List wordsList = new ArrayList();
А потом добавляем в него значения. По одному…
wordsList.add("I"); wordsList.add("love"); wordsList.add("learning"); wordsList.add("on"); wordsList.add("JavaRush");
Никуда не годится. Уже забыл, зачем нужен был список, пока его создавал! Второй путь — отсечение всего лишнего и принятие. классов утилит. Например, класса Arrays , в котором есть невероятно удобный метод asList . В него можно передавать все, что ты хочешь сделать списком, и метод сделает это списком. Вот примерно так:
List wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush");
Данный метод принимает в себя varargs — в некотором смысле массив. Прошу прощения за то, что в лекции под названием list to array я научил тебя сначала array to list, но того требовали обстоятельства. Ну а теперь к нашим методам перевода списков в массивы.
Способ №1. Перебор
Способ отлично подойдет тем, кто любит не особо вдумчиво набирать код на клавиатуре. Своего рода медитация. Шаг 1. Создаем массив такой же длины, как и список:
List wordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); String[] wordsArray = new String[wordsList.size()];
Шаг 2. Создаем цикл со счетчиком, чтобы пробежаться по всем элементам списка и иметь возможность обращаться к ячейкам массива по индексу:
for (int i = 0; i
Шаг 3. Внутри цикла значение каждого элемента списка с индексом i присваиваем ячейке массива с индексом i:
for (int i = 0; i
public static void main(String[] args) < ListwordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); String[] wordsArray = new String[wordsList.size()]; for (int i = 0; i < wordsList.size(); i++) < wordsArray[i] = wordsList.get(i); >>
Способ №2. Метод toArray
Наверное, самая оптимальная в использовании штуковина. В интерфейсе List есть два метода toArray , которые из текущего списка создают массив:
Object[] toArray(); T[] toArray(T[] a);
Первый метод возвращает массив объектов, в котором расположены все элементы текущего списка (от первого до последнего):
public class Main < public static void main(String[] args) < ListwordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); String[] wordsArray = (String[]) wordsList.toArray(); for (String word : wordsArray) < System.out.println(word); >> >
Запустим метод main и увидим следующее:
I love learning on JavaRush
Однако у данного метода есть особенность: он всегда возвращает массив объектов (Object[]) . Поэтому возвращаемый результат необходимо привести к нужному типу данных. В примере выше мы привели его к массиву строк (String[]) . Зато данный метод не принимает аргументов, что в некоторых ситуациях может быть удобно. Второй метод также возвращает массив, в котором расположены все элементы текущего списка (от первого до последнего). Однако в отличие от первого, второй метод принимает в качестве аргумента массив определенного типа. Но и результатом работы второго метода будет не массив объектов, а массив определенного типа данных — такого же, как и тип данных в переданном в аргументы методе массива.
public class Main < public static void main(String[] args) < ListwordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); String[] wordsArray = wordsList.toArray(new String[0]); for (String word : wordsArray) < System.out.println(word); >> >
Если запустить метод main , в выводе мы увидим все те же слова:
I love learning on JavaRush
Поговорим немного о массиве, который передается в качестве аргумента методу toArray . Логика работы метода зависит от длины передаваемого массива. Есть три возможные сценария:
1. Длина передаваемого массива меньше, чем длина списка
В этом случае метод создает новый массив и помещает в него элементы списка. Мы продемонстрировали это в примере выше.
2. Длина передаваемого элемента равна длине списка
Метод поместит элементы списка в переданный массив. Продемонстрируем это:
public class Main < public static void main(String[] args) < ListwordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); // Создаем пустой массив нужной длины String[] array = new String[wordsList.size()]; // Отправляем пустой массив в метод toArray wordsList.toArray(array); // Проверяем, заполнился ли наш массив. Спойлер: да for (String word : array) < System.out.println(word); >> >
При выводе мы увидим все те же строки, и станет ясно, что метод заполнил созданный нами массив.
3. Длина передаваемого массива больше, чем длина списка
Метод запишет все элементы списка в массив, а в следующую за последним добавленным элементом ячейку запишет значение null . Продемонстрируем это:
public class Main < public static void main(String[] args) < ListwordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); // Создаем пустой массив, длина которого в 2 раза больше длины списка String[] array = new String[wordsList.size() * 2]; for (int i = 0; i < array.length; i++) < // В каждую ячейку запишем строковое представление текущего индекса array[i] = String.valueOf(i); >// Отправляем массив в метод toArray wordsList.toArray(array); // Проверяем, что лежит в нашем массиве for (String word : array) < System.out.println(word); >> >
После запуска метода main в консоли увидим следующее:
I love learning on JavaRush null 6 7 8 9
Какой же метод из трех выбрать? В ранних версиях Java было оптимально передавать массив с длиной равной длине списка или больше нее. Однако в современных JVM есть оптимизации, и в некоторых случаях они обеспечивают более быструю работу метода, в который передается массив меньшей длины, чем длина списка. Так что если вы работаете на современной версии Java, передавайте в метод пустой массив, как мы делали в первом примере:
wordsList.toArray(new String[0]);
Способ №3. Stream API
Данный способ подойдет тем, кто хочет не просто перевести список в массив, но и попутно решить пару тройку других задач. А еще — людям, знакомым с Java Stream API. На JavaRush есть неплохая статья на эту тему. В данном разделе мы разберем несколько примеров с использованием стримов. Как с помощью стримов привести список к массиву:
public class Main < public static void main(String[] args) < ListwordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); String[] strings = wordsList.stream() .toArray(String[]::new); for (String s : strings) < System.out.println(s); >/* Output: I love learning on JavaRush */ > >
Но если вам просто нужно привести список к массиву, то лучше сделать это с помощью метода toArray , описанном в разделе Способ №2. А вот если вы хотите не просто привести список к массиву, а еще и произвести некоторое действие над каждым элементом, тогда вам по адресу. Попробуем привести список к массиву так, чтобы в итоговом массиве все строки были записаны в верхнем регистре:
public class Main < public static void main(String[] args) < ListwordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); String[] strings = wordsList.stream() .map(str -> str.toUpperCase()) .toArray(String[]::new); for (String s : strings) < System.out.println(s); >/* Output: I LOVE LEARNING ON JAVARUSH */ > >
Здесь, в .map(str -> str.toUpperCase()) мы определили, что нужно сделать с каждой строкой в списке. В данном случае мы решили преобразовывать каждую строку в верхний регистр, а затем собирать ее в массив. Использование Stream API позволяет не только преобразовывать каждое значение, но и фильтровать их. Предположим, мы хотим из списка строк собрать массив, но таким образом, чтобы в массив попали только строки длиной более двух символов:
public class Main < public static void main(String[] args) < ListwordsList = Arrays.asList("I", "love", "learning", "on", "JavaRush"); String[] strings = wordsList.stream() .filter(str -> str.length() > 2) .map(str -> str.toUpperCase()) .toArray(String[]::new); for (String s : strings) < System.out.println(s); >/* Output: LOVE LEARNING JAVARUSH */ > >
Здесь в строке .filter(str -> str.length() > 2) мы создали так называемый фильтр, который будет применяться к каждому элементу списка, прежде чем он попадет в массив. В данном случае у каждой строки вызывается метод length() , и если результат выражения str.length() > 2 истинный, такая строка попадет в результирующую выборку, а в итоге в массив. Иначе — не попадет. Здесь, пожалуй, стоит сказать, что того же можно добиться, просто перебирая элементы и накладывая различные ограничения. Можно делать и так. Stream API предоставляет более функциональный подход для решения подобных задач.
Итоги
- простой перебор;
- метод toArray;
- Stream API.
- Object[] toArray();
- T[] toArray(T[] a);
Домашка
Попробуйте повторить все примеры из данной статьи самостоятельно, только вместо исходного списка строк используйте список целых чисел от 0 до 10. Естественно, некоторые условия из примеров, применимые только для строк, вам придется адаптировать под новые условия.