LabEx
ВходРегистрация

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

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

Введение

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

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

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

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

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

Массивы (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) будет лучшим выбором.

Связанные Java Курсы
Java для начинающих

Java для начинающих

java
Упражнения по программированию на Java

Упражнения по программированию на Java

java
Массовая вставка данных в расписание курсов

Массовая вставка данных в расписание курсов

java