Дополнительные лекции к уровню

к тому же устаревшая недосказанная инфа про switch expr который уместно было бы к ветвлениям переместить отсюда

Неплох

Позже я обнаружил в одном собеседований на позицию Junior похожую задачу, где через мапу надо было фильтровать носки разного цвета и указать, у носков какого цвета нет пары. Так что даже улыбнуло, что мы, ребята, на шаг ближе к тому, чтобы стать Junior

Вот так заколхозил, но чатгпт сказал, что можно и проще, хотя и так сойдет)

public class Task1 {

    public static void main(String[] args) {

        List<String> words = List.of("apple", "cat", "banana", "dog", "kiwi");
        Map<Integer, List<String>> result = groupByLength(words);

        for (Integer i : result.keySet()) {
            System.out.println(i + " -> " +result.get(i));
        }
    }

    public static Map<Integer, List<String>> groupByLength (List<String> words) {
        Map<Integer, List<String>> map = new HashMap<>();

        Set<Integer> lengths = new HashSet<>();
        for(String s : words) {
            lengths.add(s.length());
        }
        List<Integer>list = new ArrayList<>(lengths);
        Collections.sort(list);

        for (int x : list) {
            List<String> list2 = new ArrayList<>();
            for (String y : words) {
                if (y.length() == x) {
                    list2.add(y);
                }
            }
            map.put(x, list2);
        }
        return map;
    }
}

Какого же будет твое удивление, когда ты узнаешь, что эта задача решается в 3-6 строк с getOrDefault =) Но решение твое тоже хорошо, я решал ее через if(words.containsKey(key)) и если true то добавлял в список элемент, если нет, то для этого создавал новый список, вот еще раз решил -

public static void main(String[] args)  {
        List<String> words = List.of("apple", "cat", "banana", "dog", "kiwi");
        Map<Integer,List<String>> result = new HashMap<>();


        for (String str : words) {
            if(result.containsKey(str.length())) { //Если есть ключ ввиде длины строки, например apple - 5, то переходим в тело
                result.get(str.length()).add(str); //Берем уже существующий список и туда добавляем нашу строку
            } else { // если ключ 5 (apple) для нас новый, то делам тело else
                List<String> list = new ArrayList<>(List.of(str)); // создаем списпок
                result.put(str.length(),list); // Ну и ложим в мапу Integer ввиде длины строки и сам список
            }
        }
        for (var str : result.entrySet()) {
            System.out.println(str.getKey() + " -> " + str.getValue());
        }
    }

Но я нейронке сказал, что не хочу грузить голову и решать через getOrDefault, это уже продвинутое понимание Map, а оно приходится в квесте Java Collection, а не сейчас

уже много времени прошло, но я все равно хочу скинуть своё решение задачи

public static void main(String[] args) {
        List<String> words = List.of("apple", "cat", "banana", "dog", "kiwi");
        Map<Integer, List<String>> sortedWords = sortWords(words);
        for (Integer key : sortedWords.keySet()){
            System.out.println(key+" -> "+sortedWords.get(key));
        }
    }
    public static Map<Integer,List<String>> sortWords(List<String> words){
        Map<Integer,List<String>> map = new HashMap<>();

        for(String word : words){
            if(!map.containsKey(word.length())){
                List<String> list = new ArrayList<>();
                list.add(word);
                map.put(word.length(),list);
            }
            else{
                List<String> list = map.get(word.length());
                list.add(word);
                map.put(word.length(),list);
            }
        }

        return map;
    }

Сойдет, братишка, все качественно, продолжай путь и ты сможешь решать такие задачи 3-4 строчками с помощью метода groupingBy, вот так будет выглядеть на нашем примере -

public static void main(String[] args) {
        List<String> words = List.of("apple", "cat", "banana", "dog", "kiwi");
        Map<Integer,List<String>> sortedWords = new HashMap<>(); //наша карта
        sortedWords = words.stream().collect(Collectors.groupingBy(String::length));//Я говорю, создай поток из того списка, далее сгруппируй мне, а как сгруппировать, а я говорю бери длину
        System.out.println(sortedWords); // ну и вывожу
    }

Так, ну мне тоже захотелось попробовать. Признаться, было нелегко. Темы дались тяжковато + после этого месячный перерыв, но шерстя предыдущие лекции Java Rush и несколько тонких вопрос ГПТ - имеют такой результат. Хотел бы услышать от гуру замечания) Интересный факт, сначала задачу делал без упорядочивания(сорт не использовал), а результат всё-равно был отсортирован. Видимо мало входных значений и оно по кеш коду их упорядочило)

import java.util.*;


public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "cat", "banana", "dog", "kiwi");
        Map<Integer, List<String>> result = new HashMap<>();

        ArrayList<Integer> sortedKeys = new ArrayList<>();
        
        for(String word: words) 
            if(!sortedKeys.contains(word.length()))
                sortedKeys.add(word.length());
        
        Collections.sort(sortedKeys);
        
        for(Integer key: sortedKeys)
            result.put(key, new ArrayList<String>());
        
        for(String word: words) 
            result.get(word.length()).add(word);
        
        for(Map.Entry entry: result.entrySet())
            System.out.println(entry.getKey() + "  -->  " + entry.getValue());
    }

}

не надо думать о том, насколько это быстро, надо вот как раз думать о том, чтобы было понятно, а не быстро, поэтому не смотрим на скорость, смотрим на то как устроен Linked List

Если сразу не понят - то уже никогда не поймёшь! Шутка.

Зато быстро )

Друг, как говориться, дорогу осилит идущий) Главное не забрасывай и иди дальше. Ну... и иногда лучше 1 час каждый день, чем 7 часов в один.