Кофе-брейк #232. Понимание различий между методами List.of() и Arrays.asList. Рекурсивные функции в Java: руководство по решению задач

Понимание различий между методами List.of() и Arrays.asList

Источник: Medium В этой публикации рассмотрены различия между List.of() и Arrays.asList() в Java, варианты их применения в коде, а также результаты использования. 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 и продемонстрирует их применение на ряде примеров. Рекурсия — это мощная концепция программирования, которая позволяет решать сложные проблемы, разбивая их на более мелкие и более управляемые подзадачи. Давайте рассмотрим несколько конкретных примеров:

1. найдем произведение всех чисел в списке;
2. напишем слова в массиве с заглавной буквы;
3. найдем самый большой элемент в массиве;
4. добавим налог в размере 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 на нескольких примерах. Помните, что используя рекурсию, вы можете писать элегантный и эффективный код для решения широкого круга задач.