---

Обработка заняла 9s

Да. Я изучил именно эту лекцию и ниже сделаю все задания практической работы №5, максимально простым способом и только на тех коллекциях и приёмах, которые есть в лекции. В лекции всего 5 заданий, пятое — дополнительное *. 


---

Сначала сама лекция — что тебе надо понять

1. Зачем нужны коллекции

Массив:

int[] a = new int[5];

имеет фиксированный размер.

Если там уже 5 элементов, шестой просто так добавить нельзя.

Коллекции — это готовые структуры, которые могут:

увеличиваться;

удалять элементы;

искать элементы;

перебирать элементы.


Проще:

> Массив — размер заранее фиксирован. Коллекция — размер может меняться. 




---

2. Три главных вида коллекций

List

Список.

элементы идут по порядку;

есть индексы;

повторы разрешены.


Например:

[5, 10, 5, 20]

Для него обычно используют ArrayList.


---

Set

Множество.

повторов нет;

индексов нет.


Если написать:

a.add(5);
a.add(5);

второй 5 не добавится.

Главный вариант — HashSet.


---

Map

Хранит:

ключ → значение

Например:

Анна → 123456
Борис → 789012

Главный вариант — HashMap.

Ключи должны быть уникальными. Если добавить существующий ключ ещё раз, старое значение заменится. 


---

3. ArrayList

Это массив, который может увеличиваться.

ArrayList<Integer> a = new ArrayList<>();

Основные команды:

add()       добавить
get()       получить
remove()    удалить
size()      количество
contains()  проверить наличие
clear()     удалить всё
set()       заменить
isEmpty()   проверить, пустой ли




---

Практическая работа №5


---

№1. Работа со списком оценок

Что требуется

Создать ArrayList<Integer> с 10 оценками.

Потом:

1. вывести оценки;


2. найти среднее;


3. удалить все оценки меньше 3;


4. добавить 5;


5. вывести итоговый список.



И очень важный момент: при удалении идём с конца списка, потому что после удаления остальные элементы сдвигаются. Это прямо указано в задании. 

Максимально простой код

import java.util.ArrayList;

class Main {
    public static void main(String[] args) {

        ArrayList<Integer> a = new ArrayList<>();

        a.add(4);
        a.add(2);
        a.add(5);
        a.add(3);
        a.add(1);
        a.add(4);
        a.add(5);
        a.add(2);
        a.add(3);
        a.add(4);

        for (int i = 0; i < a.size(); i++) {
            System.out.print(a.get(i) + " ");
        }

        System.out.println();

        int s = 0;

        for (int i = 0; i < a.size(); i++) {
            s = s + a.get(i);
        }

        double d = (double) s / a.size();

        System.out.println("Среднее: " + d);

        for (int i = a.size() - 1; i >= 0; i--) {
            if (a.get(i) < 3) {
                a.remove(i);
            }
        }

        a.add(5);

        System.out.println(a);
    }
}

Как это работает

Создаём пустой список:

ArrayList<Integer> a = new ArrayList<>();

Потом добавляем оценки:

a.add(4);
a.add(2);
a.add(5);

Получается:

[4, 2, 5]


---

Выводим

for (int i = 0; i < a.size(); i++) {
    System.out.print(a.get(i) + " ");
}

a.size() — количество элементов.

a.get(i) — получить элемент по индексу.


---

Считаем сумму

int s = 0;

Сначала сумма равна 0.

Потом:

s = s + a.get(i);

Каждый элемент добавляется к s.


---

Среднее

double d = (double) s / a.size();

Например сумма = 33, элементов = 10.

33 / 10 = 3.3


---

Удаляем оценки меньше 3

for (int i = a.size() - 1; i >= 0; i--)

Здесь главное — идём справа налево.

Например:

[4, 2, 5, 3, 1]

Удалили 1:

[4, 2, 5, 3]

Индексы изменились.

Если идти с начала, можно случайно пропустить элемент.

Поэтому:

последний → предпоследний → ... → первый

Если:

a.get(i) < 3

то:

a.remove(i);

удаляем эту оценку.


---

Добавляем пятёрку

a.add(5);

Добавляет 5 в конец.


---

№2. Уникальные слова — HashSet

Что требуется

Есть текст.

Нужно:

1. разбить его на слова;


2. сделать всё маленькими буквами;


3. положить слова в HashSet;


4. повторяющиеся слова автоматически исчезнут;


5. вывести количество;


6. проверить, есть ли слово java.



Это прямо соответствует заданию из лекции. 

Чтобы не усложнять с точками и запятыми, возьмём текст без знаков препинания:

import java.util.HashSet;

class Main {
    public static void main(String[] args) {

        String a = "Java is great Java is fun I hate Java";

        a = a.toLowerCase();

        String[] b = a.split("\\s+");

        HashSet<String> c = new HashSet<>();

        for (int i = 0; i < b.length; i++) {
            c.add(b[i]);
        }

        System.out.println(c);
        System.out.println("Количество: " + c.size());

        if (c.contains("java")) {
            System.out.println("Содержит java: Да");
        } else {
            System.out.println("Содержит java: Нет");
        }
    }
}

Как работает

Текст:

Java is great Java is fun I hate Java


---

Переводим в нижний регистр

a = a.toLowerCase();

Получаем:

java is great java is fun i hate java


---

Разбиваем на слова

String[] b = a.split("\\s+");

Получаем примерно:

[java, is, great, java, is, fun, i, hate, java]

split("\\s+") разделяет строку на отдельные слова по пробелам/пробельным символам. Именно такой вариант приведён в задании лекции. 


---

Создаём множество

HashSet<String> c = new HashSet<>();


---

Кладём слова

for (int i = 0; i < b.length; i++) {
    c.add(b[i]);
}

Если слово уже есть:

c.add("java");

второй раз его HashSet не добавит.

Получится что-то вроде:

[java, is, great, fun, i, hate]

Порядок может быть другим — для HashSet порядок не гарантируется. 


---

Количество

c.size()

Получаем:

6


---

Проверяем слово

c.contains("java")

Если java есть → true.


---

№3. Частота слов — HashMap

Здесь уже нужно считать:

слово → сколько раз встретилось

Например:

apple → 3
banana → 2
orange → 1

Это именно то, что требуется в третьем задании. 

Код

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        String a = "apple banana apple orange banana apple";

        a = a.toLowerCase();

        String[] b = a.split("\\s+");

        HashMap<String, Integer> c = new HashMap<>();

        for (int i = 0; i < b.length; i++) {

            if (c.containsKey(b[i])) {
                c.put(b[i], c.get(b[i]) + 1);
            } else {
                c.put(b[i], 1);
            }
        }

        for (String d : c.keySet()) {
            System.out.println(d + " = " + c.get(d));
        }

        String d = "";
        int e = 0;

        for (String f : c.keySet()) {

            if (c.get(f) > e) {
                e = c.get(f);
                d = f;
            }
        }

        System.out.println("Самое частое слово: " + d);
        System.out.println("Количество: " + e);
    }
}

Самая главная часть

if (c.containsKey(b[i])) {

Проверяем:

есть ли такое слово уже в HashMap?

Если есть:

c.put(b[i], c.get(b[i]) + 1);

Например уже было:

apple → 2

c.get("apple") даст 2.

Добавляем 1:

2 + 1 = 3

Получаем:

apple → 3


---

Если слова ещё нет:

c.put(b[i], 1);

Например встретили orange первый раз:

orange → 1


---

Как ищем самое частое

Сначала:

String d = "";
int e = 0;

d — слово.

e — максимальное количество.

Потом перебираем все ключи:

for (String f : c.keySet())

Если нашли число больше текущего максимума:

if (c.get(f) > e)

запоминаем:

e = c.get(f);
d = f;

В итоге:

Самое частое слово: apple
Количество: 3


---

№4. Объединение двух списков без повторов

Есть:

A = [1, 2, 3, 4]
B = [3, 4, 5, 6]

Нужно получить:

[1, 2, 3, 4, 5, 6]

В задании прямо предлагается использовать HashSet, а потом получить ArrayList. 

Максимально простой вариант

import java.util.ArrayList;
import java.util.HashSet;

class Main {
    public static void main(String[] args) {

        ArrayList<Integer> a = new ArrayList<>();
        a.add(1);
        a.add(2);
        a.add(3);
        a.add(4);

        ArrayList<Integer> b = new ArrayList<>();
        b.add(3);
        b.add(4);
        b.add(5);
        b.add(6);

        HashSet<Integer> c = new HashSet<>();

        for (int i = 0; i < a.size(); i++) {
            c.add(a.get(i));
        }

        for (int i = 0; i < b.size(); i++) {
            c.add(b.get(i));
        }

        ArrayList<Integer> d = new ArrayList<>();

        for (Integer x : c) {
            d.add(x);
        }

        System.out.println(d);
    }
}

Как работает

Есть два списка:

a = [1, 2, 3, 4]

b = [3, 4, 5, 6]

Создаём:

HashSet<Integer> c = new HashSet<>();

Кладём туда первый список:

1
2
3
4

Потом второй:

3
4
5
6

Но HashSet не допускает дубликаты.

Поэтому получится:

1 2 3 4 5 6

Потом создаём новый ArrayList:

ArrayList<Integer> d = new ArrayList<>();

И переносим туда элементы HashSet.

В итоге:

d = [1, 2, 3, 4, 5, 6]

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


---

№5* — телефонный справочник

Это дополнительное задание.

Здесь используется:

HashMap<String, ArrayList<String>>

То есть:

имя → список телефонов

Например:

Анна → [123-45-67, 765-43-21]
Борис → [111-22-33]

Именно такую структуру требует лекция. 

Здесь уже по условию можно сделать методы, потому что сама лекция предлагает операции addContact(), removeNumber(), findContact().

Код максимально просто

import java.util.ArrayList;
import java.util.HashMap;

class Main {

    static HashMap<String, ArrayList<String>> a = new HashMap<>();

    static void addContact(String b, String c) {

        if (a.containsKey(b)) {
            a.get(b).add(c);
        } else {
            ArrayList<String> d = new ArrayList<>();
            d.add(c);
            a.put(b, d);
        }
    }

    static void removeNumber(String b, String c) {

        if (a.containsKey(b)) {

            a.get(b).remove(c);

            if (a.get(b).isEmpty()) {
                a.remove(b);
            }
        }
    }

    static void findContact(String b) {

        if (a.containsKey(b)) {
            System.out.println(a.get(b));
        } else {
            System.out.println("Контакта нет");
        }
    }

    static void printAll() {

        for (String b : a.keySet()) {
            System.out.println(b + " -> " + a.get(b));
        }
    }

    public static void main(String[] args) {

        addContact("Анна", "123-45-67");
        addContact("Анна", "765-43-21");
        addContact("Борис", "111-22-33");

        printAll();

        removeNumber("Анна", "123-45-67");

        findContact("Анна");

        printAll();
    }
}


---

Как понять эту программу

Самая важная строка:

HashMap<String, ArrayList<String>> a = new HashMap<>();

Она означает:

> У нас есть HashMap, где ключ — String, то есть имя человека, а значение — ArrayList строк, то есть список его телефонов.



Поэтому:

Анна → [123-45-67, 765-43-21]


---

Добавление контакта

addContact("Анна", "123-45-67");

Проверяем:

a.containsKey("Анна")

Если Анны ещё нет → создаём список:

[]

добавляем номер:

[123-45-67]

и кладём в Map:

Анна → [123-45-67]


---

Если Анна уже есть:

a.get("Анна").add("765-43-21");

Получается:

Анна → [123-45-67, 765-43-21]


---

Удаление номера

a.get(b).remove(c);

Например:

Анна → [123-45-67, 765-43-21]

удаляем:

123-45-67

остаётся:

Анна → [765-43-21]

Если список стал пустым:

if (a.get(b).isEmpty()) {
    a.remove(b);
}

то удаляем уже самого человека из справочника.


---

Поиск

findContact("Анна");

Если Анна есть:

a.get("Анна")

вернёт её список:

[765-43-21]

Если нет:

Контакта нет


---

Вывод всего справочника

for (String b : a.keySet()) {
    System.out.println(b + " -> " + a.get(b));
}

keySet() даёт нам все имена, то есть все ключи.

Например:

Анна -> [765-43-21]
Борис -> [111-22-33]


---

Что тебе реально выучить перед преподом

Если он спросит про эту лекцию, вот самый полезный набор:

ArrayList

> ArrayList — это список, похожий на массив, но его размер может изменяться. В нём есть индексы и могут быть повторяющиеся элементы.



HashSet

> HashSet — это множество, которое не хранит дубликаты. Индексов у него нет.



HashMap

> HashMap хранит пары ключ-значение. Ключи уникальны. По ключу можно получить значение.



Главное отличие:

ArrayList → элементы по порядку + индексы + повторы

HashSet → только уникальные элементы

HashMap → ключ → значение

Главные команды

ArrayList:
add()
get()
remove()
size()
contains()
set()
clear()
isEmpty()

HashSet:
add()
remove()
contains()
size()
clear()
isEmpty()

HashMap:
put()
get()
remove()
containsKey()
containsValue()
size()
clear()
isEmpty()
keySet()

И ещё обязательно запомни:

> Коллекции не хранят примитивы напрямую, поэтому используется Integer, а не int: ArrayList<Integer>. Но Java автоматически упаковывает int в Integer, поэтому можно спокойно писать list.add(5). 



Это уже покрывает основную часть лекции + все 5 заданий практической №5. Иерархию из десятков редких коллекций учить не надо — сама лекция прямо говорит, что она показана в основном для общего понимания и реально понадобится несколько основных коллекций.