Массивы и списки (ArrayLists) в Java

JavaBeginner
Практиковаться сейчас

Введение

В этом практическом занятии (lab) мы углубимся в два фундаментальных структуры данных в Java: массивы (Arrays) и списки (ArrayLists). Эти структуры позволяют нам хранить и манипулировать наборами данных, что является важной частью многих программистских задач. Мы начнем с базового массива, а затем перейдем к более гибкому списку (ArrayList). К концу этого практического занятия вы сможете создавать, манипулировать и работать как с массивами, так и со списками (ArrayLists) в Java.

Мы рассмотрим:

  1. Создание и использование массивов
  2. Доступ и изменение элементов массива
  3. Введение в списки (ArrayLists)
  4. Добавление, удаление и доступ к элементам в списках (ArrayLists)
  5. Преобразование между массивами и списками (ArrayLists)

Давайте начнем организовывать наши данные!

Это Guided Lab, который предоставляет пошаговые инструкции, чтобы помочь вам учиться и практиковаться. Внимательно следуйте инструкциям, чтобы выполнить каждый шаг и получить практический опыт. Исторические данные показывают, что это лабораторная работа уровня начальный с процентом завершения 88%. Он получил 99% положительных отзывов от учащихся.

Создание и использование массивов

Массивы (Arrays) - это фундаментальная структура данных в Java, которая позволяет вам хранить несколько элементов одного и того же типа. Представьте массив как ряд ящиков, где каждый ящик может хранить один элемент определенного типа.

  1. Откройте файл ArrayDemo.java в директории вашего проекта.

    public class ArrayDemo {
        public static void main(String[] args) {
            // We'll add our code here
        }
    }

    Это базовая структура нашего Java - программы. Метод main - это точка входа в нашу программу.

  2. Теперь объявим и инициализируем массив целых чисел. Добавьте следующую строку внутри метода main:

    int[] numbers = {1, 2, 3, 4, 5};

    Эта строка создает массив целых чисел с именем numbers и инициализирует его значениями 1, 2, 3, 4 и 5. Квадратные скобки [] сообщают Java, что numbers - это массив.

  3. Выведем на экран элементы нашего массива. Добавьте эти строки после объявления массива:

    System.out.println("The elements of the array are:");
    for (int i = 0; i < numbers.length; i++) {
        System.out.println("Element at index " + i + ": " + numbers[i]);
    }

    Этот код использует цикл for для перебора элементов массива. numbers.length возвращает размер массива, а numbers[i] позволяет получить доступ к элементу с индексом i.

Java array elements output
  1. Сохраните файл, затем скомпилируйте и запустите программу:

    javac ~/project/ArrayDemo.java
    java -cp ~/project ArrayDemo

    Вы должны увидеть вывод, похожий на следующий:

    The elements of the array are:
    Element at index 0: 1
    Element at index 1: 2
    Element at index 2: 3
    Element at index 3: 4
    Element at index 4: 5
  2. Теперь вычислим сумму всех элементов в массиве. Добавьте этот код после предыдущего цикла:

    int sum = 0;
    for (int number : numbers) {
        sum += number;
    }
    System.out.println("The sum of the elements is: " + sum);

    Этот код использует расширенный цикл for (также известный как цикл for - each) для перебора элементов массива. Это более простой способ пройти по всем элементам, когда вам не нужен индекс.

  3. Наконец, найдем максимальное значение в массиве. Добавьте этот код:

    int max = numbers[0];
    for (int i = 1; i < numbers.length; i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
    }
    System.out.println("The maximum value in the array is: " + max);

    Этот код предполагает, что первый элемент является максимальным, а затем сравнивает каждый последующий элемент с текущим максимальным значением, обновляя max, если найдено большее значение.

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

    The sum of the elements is: 15
    The maximum value in the array is: 5
Java array output example
  1. Массивы в Java имеют фиксированный размер, но мы можем изменять их элементы. Изменим один элемент и выведем модифицированный массив. Добавьте этот код в конце метода main:

    numbers[2] = 10;
    System.out.println("\nAfter modifying the third element:");
    for (int number : numbers) {
        System.out.print(number + " ");
    }
    System.out.println();

    Это изменяет значение третьего элемента (с индексом 2) на 10, а затем выводит модифицированный массив.

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

    After modifying the third element:
    1 2 10 4 5

Поздравляем! Теперь вы создали массив, получили доступ к его элементам, выполнили вычисления с его значениями и изменили один элемент. Помните, что массивы в Java имеют фиксированный размер, то есть после создания массива вы не можете изменить его длину. Однако вы можете изменить значения его элементов.

Введение в списки (ArrayLists)

Теперь, когда мы работали с массивами, давайте познакомимся со списками (ArrayLists). Списки (ArrayLists) являются частью Фреймворка коллекций Java (Java Collections Framework) и предоставляют более гибкий способ работы со списками объектов. В отличие от массивов, списки (ArrayLists) могут динамически увеличивать или уменьшать свой размер.

  1. Откройте файл ArrayListDemo.java в директории вашего проекта.

    import java.util.ArrayList;
    
    public class ArrayListDemo {
        public static void main(String[] args) {
            // We'll add our code here
        }
    }

    Обратите внимание на оператор import вверху. Он сообщает Java, что мы хотим использовать класс ArrayList в нашей программе.

  2. Теперь создадим список (ArrayList) строк. Добавьте следующую строку внутри метода main:

    ArrayList<String> fruits = new ArrayList<>();

    Это создаёт пустой список (ArrayList), который может хранить объекты типа String. Часть <String> называется "обобщением" (generic) и указывает тип элементов, которые будет содержать список (ArrayList).

  3. Добавим несколько элементов в наш список (ArrayList). Добавьте следующие строки:

    fruits.add("Apple");
    fruits.add("Banana");
    fruits.add("Cherry");

    Метод add() добавляет элементы в конец списка.

  4. Теперь выведем наш список (ArrayList) на экран. Добавьте следующий код:

    System.out.println("Fruits in the list:");
    for (String fruit : fruits) {
        System.out.println(fruit);
    }

    Здесь используется расширенный цикл for для перебора элементов списка (ArrayList), аналогично тому, как мы делали с массивами.

    Совет: Вы можете скомпилировать и запустить свою программу в любое время, чтобы увидеть вывод. Или вы можете продолжить добавлять больше кода и запустить его все в конце.

  5. Списки (ArrayLists) имеют много полезных методов. Попробуем несколько из них. Добавьте следующий код:

    System.out.println("\nNumber of fruits: " + fruits.size());
    System.out.println("The second fruit is: " + fruits.get(1));

    Метод size() возвращает количество элементов в списке (ArrayList), а метод get(index) извлекает элемент по указанному индексу.

  6. Мы также можем заменить элементы в списке (ArrayList) с помощью метода set(). Добавьте следующий код:

    // Before: [Apple, Banana, Cherry]
    fruits.set(1, "Blueberry");    // Replaces "Banana" with "Blueberry"
    System.out.println("\nAfter replacing the second fruit:");
    System.out.println(fruits);     // [Apple, Blueberry, Cherry]

    Метод set(index, element) заменяет элемент по указанному индексу новым элементом. Размер списка (ArrayList) остаётся прежним.

  7. В отличие от массивов, списки (ArrayLists) позволяют вставлять элементы в любую позицию с помощью метода add(index, element). Это отличается от метода set(), который мы рассмотрели ранее. Давайте посмотрим, как работает метод add():

    // Before: [Apple, Blueberry, Cherry]
    fruits.add(1, "Blackberry");
    System.out.println("\nAfter inserting Blackberry at index 1:");
    System.out.println(fruits);
    // After: [Apple, Blackberry, Blueberry, Cherry]

    Давайте разберем, что произошло:

    • add(1, "Blackberry") вставляет "Blackberry" по индексу 1
    • Существующие элементы с индексом 1 и далее (Blueberry, Cherry) автоматически сдвигаются на одну позицию вправо
    • Размер списка (ArrayList) увеличивается на 1
    • Это отличается от метода set(), который заменяет существующий элемент без сдвига и изменения размера

    Чтобы лучше понять разницу:

    // Using add(index, element) - inserts and shifts
    fruits.add(1, "Blackberry");    // [Apple, Blackberry, Blueberry, Cherry]
    
    // Using set(index, element) - replaces without shifting
    fruits.set(1, "Blackberry");    // [Apple, Blackberry, Cherry]
  8. Мы также можем удалять элементы из списка (ArrayList). Добавьте следующий код:

    fruits.remove("Cherry");
    System.out.println("\nAfter removing Cherry:");
    System.out.println(fruits);

    Это удаляет первое вхождение "Cherry" из списка (ArrayList). Когда элемент удаляется, все последующие элементы сдвигаются влево, чтобы заполнить образовавшуюся дыру.

  9. Наконец, проверим, содержатся ли определенные элементы в нашем списке (ArrayList):

    System.out.println("\nDoes the list contain Apple? " + fruits.contains("Apple"));
    System.out.println("Does the list contain Cherry? " + fruits.contains("Cherry"));

    Метод contains() проверяет, содержит ли список (ArrayList) определенный элемент, и возвращает логическое значение.

  10. Сохраните файл, затем скомпилируйте и запустите программу:

    javac ~/project/ArrayListDemo.java
    java -cp ~/project ArrayListDemo

    Вы должны увидеть вывод, похожий на следующий:

    Fruits in the list:
    Apple
    Banana
    Cherry
    
    Number of fruits: 3
    The second fruit is: Banana
    
    After replacing the second fruit:
    [Apple, Blueberry, Cherry]
    
    After inserting Blackberry at index 1:
    [Apple, Blackberry, Blueberry, Cherry]
    
    After removing Cherry:
    [Apple, Blackberry, Blueberry]
    
    Does the list contain Apple? true
    Does the list contain Cherry? false

Поздравляем! Теперь вы создали список (ArrayList), добавили и удалили элементы, получили доступ к элементам по индексу и использовали различные методы списка (ArrayList). Вы узнали важные различия между операциями, такими как add(), который вставляет и сдвигает элементы, и set(), который заменяет элементы. Списки (ArrayLists) предоставляют больше гибкости, чем массивы, так как они могут увеличиваться и уменьшаться по мере необходимости. Это делает их очень полезными, когда вы заранее не знаете, с каким количеством элементов будете работать.

Преобразование между массивами и списками (ArrayLists)

Иногда вам может понадобиться преобразовывать массивы в списки (ArrayLists) и наоборот. Java предоставляет удобные методы для этого. Давайте рассмотрим, как преобразовать массив в список (ArrayList) и наоборот.

  1. Откройте файл ConversionDemo.java в директории вашего проекта.

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class ConversionDemo {
        public static void main(String[] args) {
            // We'll add our code here
        }
    }

    Обратите внимание на операторы import вверху. Мы импортируем классы, которые нам понадобятся для преобразований.

  2. Начнем с преобразования массива в список (ArrayList). Добавьте следующий код внутри метода main:

    String[] colorArray = {"Red", "Green", "Blue"};
    List<String> colorList = Arrays.asList(colorArray);
    
    System.out.println("Array converted to ArrayList:");
    System.out.println(colorList);

    Метод Arrays.asList() преобразует массив в объект типа List. Обратите внимание, что таким образом создается список фиксированного размера, который связан с исходным массивом.

  3. Изменим список (ArrayList) и посмотрим, что произойдет с исходным массивом. Добавьте следующий код:

    colorList.set(1, "Yellow");
    
    System.out.println("\nAfter modifying the ArrayList:");
    System.out.println(colorList);
    System.out.println("Original array after ArrayList modification:");
    System.out.println(Arrays.toString(colorArray));

    Метод Arrays.toString() - это удобный способ вывести массив на экран.

  4. Теперь преобразуем список (ArrayList) в массив. Добавьте следующий код:

    ArrayList<Integer> numberList = new ArrayList<>();
    numberList.add(1);
    numberList.add(2);
    numberList.add(3);
    
    Integer[] numberArray = numberList.toArray(new Integer[0]);
    
    System.out.println("\nArrayList converted to array:");
    System.out.println(Arrays.toString(numberArray));

    Мы используем метод toArray() списка (ArrayList) для преобразования его в массив. Мы передаем new Integer[0] в качестве аргумента, которое служит подсказкой о типе и размере создаваемого массива.

  5. Наконец, изменим массив и посмотрим, повлияет ли это на список (ArrayList). Добавьте следующий код:

    numberArray[0] = 100;
    System.out.println("\nAfter modifying the array:");
    System.out.println("Array: " + Arrays.toString(numberArray));
    System.out.println("ArrayList: " + numberList);
  6. Сохраните файл, затем скомпилируйте и запустите программу:

    javac ~/project/ConversionDemo.java
    java -cp ~/project ConversionDemo

    Вы должны увидеть вывод, похожий на следующий:

    Array converted to ArrayList:
    [Red, Green, Blue]
    
    After modifying the ArrayList:
    [Red, Yellow, Blue]
    Original array after ArrayList modification:
    [Red, Yellow, Blue]
    
    ArrayList converted to array:
    [1, 2, 3]
    
    After modifying the array:
    Array: [100, 2, 3]
    ArrayList: [1, 2, 3]

Это демонстрация показывает, как массивы и списки (ArrayLists) могут быть преобразованы друг в друга. Важно отметить различия в поведении:

  • Когда вы преобразуете массив в список (List) с помощью Arrays.asList(), полученный список связан с исходным массивом. Это означает, что изменения в списке будут отражены в массиве и наоборот.
  • Когда вы преобразуете список (ArrayList) в массив с помощью toArray(), вы создаете новый массив, который не зависит от списка (ArrayList). Изменения в этом новом массиве не повлияют на исходный список (ArrayList).

Понимание этих преобразований и их поведения является важным при работе с различными типами коллекций в Java, особенно при взаимодействии с API или библиотеками, которые могут предпочитать один тип коллекции над другим.

Резюме

В этом практическом занятии (lab) мы изучили две фундаментальные структуры данных в Java: массивы (Arrays) и списки (ArrayLists). Давайте повторим, что мы узнали:

  1. Массивы (Arrays):

    • Мы создали и инициализировали массивы с использованием синтаксиса int[] numbers = {1, 2, 3, 4, 5};
    • Мы научились получать доступ к элементам массива с использованием индексной нотации, например numbers[0]
    • Мы перебирали элементы массивов как с использованием традиционных циклов for, так и расширенных циклов for
    • Мы выполняли вычисления с элементами массива, например находили сумму и максимальное значение
    • Мы увидели, что массивы имеют фиксированный размер, но мы можем изменять их элементы
  2. Списки (ArrayLists):

    • Мы создали списки (ArrayLists) с использованием ArrayList<String> fruits = new ArrayList<>();
    • Мы научились добавлять элементы с помощью метода add(), удалять элементы с помощью метода remove() и получать доступ к элементам с помощью метода get()
    • Мы использовали методы, такие как size(), set() и contains(), для работы со списками (ArrayLists)
    • Мы увидели, что списки (ArrayLists) могут динамически увеличиваться и уменьшаться в размере, предоставляя больше гибкости, чем массивы
  3. Преобразование между массивами и списками (ArrayLists):

    • Мы преобразовывали массивы в списки (ArrayLists) с использованием Arrays.asList()
    • Мы преобразовывали списки (ArrayLists) в массивы с использованием метода toArray()
    • Мы наблюдали разное поведение при модификации преобразованных коллекций

Массивы (Arrays) и списки (ArrayLists) являются важными инструментами в программировании на Java. Массивы отлично подходят для работы с фиксированным количеством элементов и могут быть более эффективными с точки зрения использования памяти. Списки (ArrayLists), с другой стороны, предоставляют больше гибкости и богатый набор методов для манипуляции коллекцией.

По мере того, как вы продолжите изучать Java, вы будете часто использовать как массивы, так и списки (ArrayLists). Выбор между ними часто зависит от ваших конкретных потребностей - если вы знаете точное количество элементов, с которыми будете работать, массив может быть предпочтительнее. Если вам нужна динамическая коллекция, которая может увеличиваться или уменьшаться в размере, или если вам нужны дополнительные методы, предоставляемые списками (ArrayLists), то список (ArrayList) будет лучшим выбором.