Понимание различий между методами List.of() и Arrays.asList
Источник:
Medium
В этой публикации рассмотрены различия между List.of() и Arrays.asList() в Java, варианты их применения в коде, а также результаты использования.
![Кофе-брейк #232. Понимание различий между методами List.of() и Arrays.asList. Рекурсивные функции в Java: руководство по решению задач - 1]()
Java имеет несколько удобных методов для создания списков (lists), включая
List.of() и
Arrays.asList(). Хотя оба этих метода позволяют легко создавать списки, они имеют некоторые ключевые отличия. Давайте взглянем на них глубже.
List.of()
List.of() — это фабричный метод, впервые представленный в Java 9, который создает неизменяемый список, содержащий указанные элементы. Вот несколько ключевых моментов, на которые вам следует обратить внимание, изучая
List.of():
- Неизменяемость: полученный список неизменен, то есть его размер и элементы не могут быть изменены после создания.
- Фиксированный размер: список, созданный List.of(), имеет фиксированный размер и не поддерживает добавление или удаление элементов.
- Нулевые значени: List.of() не допускает нулевых элементов. Если вы попытаетесь добавить null, появится исключение NullPointerException.
Пример использования:
List<String> immutable_list = List.of("apple", "banana", "orange");
Arrays.asList()
Arrays.asList() — это метод, доступный еще в ранних версиях Java, и он предоставляет удобный способ создания изменяемого списка, поддерживаемого массивом. Рассмотрим его характеристики:
- Модифицируемость: полученный из Arrays.asList() список можно модифицировать, что позволяет добавлять, удалять или изменять элементы.
- Поддерживается массивом: список поддерживается исходным массивом, поэтому любые изменения в списке влияют на базовый массив и наоборот.
- Ограничение фиксированного размера: несмотря на возможность изменения, размер списка, возвращаемого Arrays.asList(), является фиксированным, что предотвращает структурные модификации, такие как добавление или удаление элементов.
- Нулевые значения: в отличие от List.of(), Arrays.asList() допускает нулевые элементы.
Пример использования:
List<String> mutable_list = Arrays.asList("red", "green", "blue");
Варианты применения
Теперь, когда мы понимаем разницу между
List.of() и
Arrays.asList(), давайте рассмотрим соответствующие варианты их использования:
List.of():
Этот метод идеален, когда вам нужен неизменяемый список с фиксированным набором элементов. Это обеспечивает целостность данных и предотвращает случайные изменения.
import java.util.List;
public class ListOfExample {
public static void main(String[] args) {
List<String> fruits = List.of("apple", "banana", "orange");
// Попытка изменить список вызовет исключение UnsupportedOperationException
fruits.add("grape"); // Выдает исключение
// Попытка добавить нулевой элемент вызовет исключение NullPointerException
fruits.add(null); // Выдает исключение
// Доступ к элементам
System.out.println(fruits.get(0)); // Output: apple
System.out.println(fruits.get(1)); // Output: banana
System.out.println(fruits.get(2)); // Output: orange
}
}
В приведенном выше примере
List.of() используется для создания неизменного списка фруктов (fruits). Любая попытка изменить список путем добавления или удаления элементов приведет к возникновению исключений. В примере также демонстрируется доступ к элементам из списка.
Arrays.asList():
Используйте этот метод, если вам нужен редактируемый список, поддерживаемый массивом, и если вам необходимо выполнять структурные модификации или использовать определенные методы, доступные только в интерфейсе
List.
import java.util.Arrays;
import java.util.List;
public class ArraysAsListExample {
public static void main(String[] args) {
String[] colorsArray = {"red", "green", "blue"};
List<String> colors = Arrays.asList(colorsArray);
// Изменение списка (и массива) путем добавления нового элемента
colors.add("yellow");
// Изменение списка (и массива) путем удаления элемента
colors.remove(0);
// Доступ к элементам
System.out.println(colors.get(0)); // Output: green
System.out.println(colors.get(1)); // Output: blue
System.out.println(colors.get(2)); // Output: yellow
// Доступ к элементам исходного массива
System.out.println(colorsArray[0]); // Output: green
System.out.println(colorsArray[1]); // Output: blue
System.out.println(colorsArray[2]); // Output: yellow
}
}
Заключение
Понимание различий между
List.of() и
Arrays.asList() важно для любого Java-разработчика. В то время как
List.of() создает неизменяемый список фиксированного размера,
Arrays.asList() создает изменяемый список, поддерживаемый массивом. Понимая характеристики, способы и результаты использования каждого метода, вы можете принимать обоснованные решения при выборе для ваших конкретных потребностей в программировании.
Рекурсивные функции в Java: руководство по решению задач
Источник:
Medium
Данное руководство объясняет значение рекурсивных функций в Java и продемонстрирует их применение на ряде примеров.
Рекурсия — это мощная концепция программирования, которая позволяет решать сложные проблемы, разбивая их на более мелкие и более управляемые подзадачи. Давайте рассмотрим несколько конкретных примеров:
- найдем произведение всех чисел в списке;
- напишем слова в массиве с заглавной буквы;
- найдем самый большой элемент в массиве;
- добавим налог в размере 10% к каждой зарплате.
Произведение всех чисел в списке
Первая задача, которую мы решим, — найти произведение всех чисел в списке. В этом нам поможет рекурсивная функция
getProductRecursive, которая умножает каждый элемент на произведение остальных элементов, пока не будет достигнут конец списка. Для наглядности ознакомьтесь с примером кода, демонстрирующим реализацию этой функции:
public class Main {
public static int getProductRecursive(int[] arr, int index) {
if (index < 0 || index >= arr.length) {
return 1;
} else {
return arr[index] * getProductRecursive(arr, index + 1);
}
}
public static void main(String[] args) {
int[] numbers = {2, 3, 4, 5};
int product = getProductRecursive(numbers, 0);
System.out.println("Product: " + product);
}
}
Заглавные слова в массиве:
Далее мы рассмотрим рекурсивную функцию для написания всех слов в массиве с заглавной буквы. Мы определим функцию
capitalizeWordsRecursive, которая преобразует каждое слово в верхний регистр с помощью метода
toUpperCase и рекурсивно вызывает себя для обработки оставшихся слов в массиве. Логика и использование этой функции показаны на фрагменте кода:
import java.util.Arrays;
public class Main {
public static String[] capitalizeWordsRecursive(String[] words, int index) {
if (index < 0 || index >= words.length) {
return new String[0];
} else {
String word = words[index];
String capitalizedWord = word.toUpperCase();
String[] remainingWords = capitalizeWordsRecursive(words, index + 1);
String[] result = new String[remainingWords.length + 1];
result[0] = capitalizedWord;
System.arraycopy(remainingWords, 0, result, 1, remainingWords.length);
return result;
}
}
public static void main(String[] args) {
String[] words = {"foo", "bar", "world"};
String[] capitalizedWords = capitalizeWordsRecursive(words, 0);
System.out.println("Capitalized words: " + Arrays.toString(capitalizedWords));
}
}
Поиск самого большого элемента в массиве
В этом разделе перед нами стоит проблема поиска самого большого элемента в массиве с помощью рекурсии. Мы определим рекурсивную функцию
findHighestElementRecursive, которая сравнивает каждый элемент с текущим наибольшим значением и обновляет его, если найден элемент, который его превышает. Вот пример кода, иллюстрирующий ее использование:
public class Main {
public static int findHighestElementRecursive(int[] arr, int index, int highest) {
if (index < 0 || index >= arr.length) {
return highest;
} else {
int currentElement = arr[index];
if (currentElement > highest) {
highest = currentElement;
}
return findHighestElementRecursive(arr, index + 1, highest);
}
}
public static void main(String[] args) {
int[] numbers = {5, 8, 2, 10, 3};
int highestElement = findHighestElementRecursive(numbers, 0, Integer.MIN_VALUE);
System.out.println("Highest element: " + highestElement);
}
}
Добавление налога к зарплате
И наконец, давайте решим задачу добавления 10% налога к каждой зарплате в массиве. Для этого определим рекурсивную функцию
addTaxRecursive, которая вычисляет новую зарплату, добавляя налог, и рекурсивно вызывает себя для обработки оставшихся зарплат. Перед вами полный пример кода для демонстрации ее функциональности:
import java.util.Arrays;
public class Main {
public static double[] addTaxRecursive(double[] salaries, int index) {
if (index < 0 || index >= salaries.length) {
return new double[0];
} else {
double salary = salaries[index];
double newSalary = salary + (0.1 * salary);
double[] remainingSalaries = addTaxRecursive(salaries, index + 1);
double[] result = new double[remainingSalaries.length + 1];
result[0] = newSalary;
System.arraycopy(remainingSalaries, 0, result, 1, remainingSalaries.length);
return result;
}
}
public static void main(String[] args) {
double[] salaries = {1000.0, 2000.0, 3000.0};
double[] newSalaries = addTaxRecursive(salaries, 0);
System.out.println("New salaries: " + Arrays.toString(newSalaries));
}
}
Заключение
Рекурсия — это мощная техника, которая позволяет нам решать сложные проблемы, разбивая их на более мелкие и более управляемые подзадачи. В этой статье мы рассмотрели рекурсивные функции в Java на нескольких примерах. Помните, что используя рекурсию, вы можете писать элегантный и эффективный код для решения широкого круга задач.
Java имеет несколько удобных методов для создания списков (lists), включая List.of() и Arrays.asList(). Хотя оба этих метода позволяют легко создавать списки, они имеют некоторые ключевые отличия. Давайте взглянем на них глубже.
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ