{"draftJsState":{"blocks":[{"data":{"image":{"id":"65aebe9d8ff94c646b9ec296"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"64bpt"},{"data":{},"depth":0,"entityRanges":[{"key":0,"length":22,"offset":10}],"inlineStyleRanges":[],"text":"Источник: Nuances of Programming","type":"unstyled","key":"1ujfk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Пишу эту статью, чтобы помочь Java-разработчикам понять, почему необходимо различать интерфейсы изменяемых (mutable) и неизменяемых (immutable) коллекций. Java — на редкость эффективный язык программирования с почти 30-летней историей. Java Collections Framework (JCF) — одна из наиболее активно используемых частей стандартной библиотеки Java — сыграл важную роль в успешном развитии языка. Сегодня Java продолжает совершенствоваться в соответствии с новыми требованиями, оставаясь в ряду лучших языков программирования. Однако, как и во многих других начинаниях, прошлые успехи не являются гарантией будущих достижений.","type":"unstyled","key":"14r4o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Мастика для натирки полов или начинка для десерта?","type":"header-three","key":"ca3ja"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Долгое время в языке Java отдавалось предпочтение изменяемости в интерфейсах коллекций. После выхода Java 8 язык и библиотеки Java начали медленно, но неуклонно двигаться в сторону неизменяемости коллекций и других типов.","type":"unstyled","key":"e85jk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"К сожалению, этот переход к неизменяемости происходил путем добавления новых реализаций и использования старых интерфейсов JCF, таких как Collection, List, Set и Map. Эти интерфейсы всегда были “условно” изменяемыми. Однако в Javadoc у изменяющих методов интерфейсов (таких как add и remove) нет никакой гарантии изменяемости.","type":"unstyled","key":"t6o0"},{"data":{"image":{"id":"65aebec19f0a001db5d1f6a7"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Фрагмент Javadoc из метода add в интерфейсе Collection","type":"atomic:image","key":"4jr2n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Выбрасывание UnsupportedOperationException в ответ на изменяющий метод — это неудачный способ сообщить, что Collection Java может быть как воском для пола, так и начинкой для десерта. Использование Collection в качестве то ли десертной начинки, то ли чистящего средства может оказаться небезопасным. Но вы не узнаете об этом, пока не попробуете.","type":"unstyled","key":"3lqqa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Какое же влияние оказал этот неоднозначный подход к дизайну на стандартную библиотеку Java за прошедшие годы? Рассмотрим несколько изменяемых и неизменяемых реализаций интерфейса List в стандартных библиотеках Java.","type":"unstyled","key":"dpkf9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Приведенные ниже примеры кода создают экземпляры List, используя различные варианты реализации. Я укажу, какие из них являются изменяемыми, а какие — неизменяемыми. При этом заметьте: все они имеют один тип интерфейса — List.","type":"unstyled","key":"7vflt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ArrayList","type":"header-three","key":"64pa3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ArrayList — изменяемая реализация List.","type":"unstyled","key":"7brj2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void arrayList()\n{\n // Изменяемая реализация\n List list = new ArrayList<>();\n list.add(\"✅\"); // Работает\n \n Assertions.assertEquals(List.of(\"✅\"), list);\n}","type":"blockquote","key":"493mg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"LinkedList","type":"header-three","key":"es35d"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"LinkedList — изменяемая реализация List.","type":"unstyled","key":"akuso"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void linkedList()\n{\n // Изменяемая реализация\n List list = new LinkedList<>();\n list.add(\"✅\"); // Работает\n\n Assertions.assertEquals(List.of(\"✅\"), list);\n}","type":"blockquote","key":"5301o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"CopyOnWriteArrayList","type":"header-three","key":"1jh9l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"CopyOnWriteArrayList — изменяемая и потокобезопасная реализация List.","type":"unstyled","key":"5sohq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void copyOnWriteArrayList()\n{\n // Изменяемая реализация\n List list = new CopyOnWriteArrayList<>();\n list.add(\"✅\"); // Работает\n\n Assertions.assertEquals(List.of(\"✅\"), list);\n}","type":"blockquote","key":"89esr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Arrays.asList()","type":"header-three","key":"c0012"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Arrays.asList() возвращает изменяемую, но нерасширяемую реализацию List. Это означает, что можно задавать элементам List различные значения, но нельзя применять add или remove к List. Такая реализация List похожа на массив Java.","type":"unstyled","key":"fobdh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void arraysAsList()\n{\n // Изменяемая, но нерасширяемая реализация\n List list = Arrays.asList(\"✅\");\n list.set(0, \"✔️\"); // Работает\n\n Assertions.assertThrows(\n UnsupportedOperationException.class,\n () -> list.add(0, \"⛔️\"));\n Assertions.assertEquals(List.of(\"✔️\"), list);\n}","type":"blockquote","key":"irt4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Collections.emptyList()","type":"header-three","key":"a6k7m"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Collections.emptyList() возвращает неизменяемый пустой List.","type":"unstyled","key":"ui8l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void collectionsEmptyList()\n{\n // Неизменяемый\n List list = Collections.emptyList();\n\n Assertions.assertThrows(\n UnsupportedOperationException.class,\n () -> list.add(0, \"⛔️\"));\n Assertions.assertEquals(List.of(), list);\n}","type":"blockquote","key":"e77l6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Collections.singletonList()","type":"header-three","key":"7okph"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Collections.singletonList() возвращает неизменяемый синглтон List.","type":"unstyled","key":"bili8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void collectionsSingletonList()\n{\n // Неизменяемый\n List list =\n Collections.singletonList(\"✅\");\n\n Assertions.assertThrows(\n UnsupportedOperationException.class,\n () -> list.add(\"⛔️\"));\n Assertions.assertEquals(List.of(\"✅\"), list);\n}","type":"blockquote","key":"eno86"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Collections.unmodifiableList(List)","type":"header-three","key":"75nkm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Collections.unmodifiableList() возвращает “немодифицированное представление” List, но оборачиваемый им List можно модифицировать отдельно, как показано в приведенном ниже коде. Оборачиваемый List может быть изменяемым или неизменяемым, но если он будет неизменяемым, то представление будет излишним.","type":"unstyled","key":"2osa5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void collectionsUnmodifiableList()\n{\n // Изменяемый\n List arrayList = new ArrayList<>();\n arrayList.add(\"✅\");\n\n // \"Неизменяемый\" (но arrayList все еще изменяем)\n List list = Collections.unmodifiableList(arrayList);\n\n Assertions.assertThrows(\n UnsupportedOperationException.class,\n () -> list.add(\"⛔️\"));\n Assertions.assertEquals(List.of(\"✅\"), list);\n arrayList.add(\"⛔️\");\n Assertions.assertEquals(List.of(\"✅\", \"⛔️\"), list);\n}","type":"blockquote","key":"886p1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Collections.synchronizedList(List)","type":"header-three","key":"b0012"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Collections.synchronizedList возвращает “условно потокобезопасный” экземпляр List. Под “условно потокобезопасным” подразумевается, что такие методы, как iterator, stream и parallelStream, являются небезопасными и должны быть защищены разработчиком явной блокировкой.","type":"unstyled","key":"dumvr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void collectionsSynchronizedList()\n{\n // Изменяемый\n List arrayList = new ArrayList<>();\n arrayList.add(\"✅\");\n\n // Изменяемый и \"условно потокобезопасный\" экземпляр\n List list = Collections.synchronizedList(arrayList);\n\n Assertions.assertEquals(List.of(\"✅\"), list);\n list.add(\"✅\");\n Assertions.assertEquals(List.of(\"✅\", \"✅\"), list);\n}","type":"blockquote","key":"2cilu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"List.of()","type":"header-three","key":"ictd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"List.of() возвращает неизменяемый List.","type":"unstyled","key":"6flg6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void listOf()\n{\n // Неизменяемый\n List list = List.of(\"✅\");\n\n Assertions.assertThrows(\n UnsupportedOperationException.class,\n () -> list.add(\"⛔️\"));\n Assertions.assertEquals(List.of(\"✅\"), list);\n}","type":"blockquote","key":"75usc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"List.copyOf(List)","type":"header-three","key":"9mjpb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"List.copyOf() копирует содержимое другого List и возвращает неизменяемый List.","type":"unstyled","key":"35kdr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void listCopyOf()\n{\n // Неизменяемый\n List list = List.copyOf(new ArrayList<>(List.of(\"✅\")));\n\n Assertions.assertThrows(\n UnsupportedOperationException.class,\n () -> list.add(\"⛔️\"));\n Assertions.assertEquals(List.of(\"✅\"), list);\n}","type":"blockquote","key":"bb39a"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Stream.toList()","type":"header-three","key":"82vni"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Stream.toList() возвращает неизменяемый List.","type":"unstyled","key":"b2la9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void streamToList()\n{\n // Неизменяемый\n List list = Stream.of(\"✅\").toList();\n \n Assertions.assertThrows(\n UnsupportedOperationException.class,\n () -> list.add(\"⛔️\"));\n Assertions.assertEquals(List.of(\"✅\"), list);\n}","type":"blockquote","key":"5rsre"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Stream.collect(Collectors.toList())","type":"header-three","key":"1v34v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Stream.collect(Collectors.toList()) вернет изменяемый List сегодня, но нет никакой гарантии, что он останется изменяемым в будущем.","type":"unstyled","key":"chqe1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void streamCollectCollectorsToList()\n{\n // Изменяемый\n List list = Stream.of(\"✅\")\n .collect(Collectors.toList());\n list.add(\"✅\");\n\n Assertions.assertEquals(List.of(\"✅\", \"✅\"), list);\n}","type":"blockquote","key":"bbqke"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Stream.collect(Collectors.toUnmodifiableList())","type":"header-three","key":"e40cl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Stream.collect(Collectors.toUnmodifiableList()) вернет сегодня немодифицируемый List, который фактически является неизменяемым, поскольку нельзя легко получить указатель на изменяемый List, который он оборачивает.","type":"unstyled","key":"2aiqg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void streamCollectCollectorsToUnmodifiableList()\n{\n // Изменяемый\n List list = Stream.of(\"✅\")\n .collect(Collectors.toUnmodifiableList());\n\nAssertions.assertThrows(\n UnsupportedOperationException.class,\n () -> list.add(\"⛔️\"));\n Assertions.assertEquals(List.of(\"✅\"), list);\n}","type":"blockquote","key":"55uql"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"List имеет множество потенциальных реализаций, при этом у вас нет возможности определить, какими они являются — изменяемыми или неизменяемыми.","type":"unstyled","key":"b7as7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Выбор Хобсона в дизайне","type":"header-three","key":"1p0eh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Выбор Хобсона — кажущаяся свобода выбора при отсутствии реальной альтернативы.","type":"blockquote","key":"5r549"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"На протяжении последних 25 лет Java Collections Framework предпочитал простоту и минимализм в дизайне, основанном на иерархии наследования. JCF был чрезвычайно успешен, по крайней мере, по одному из критериев успеха: за последние 25 лет миллионы разработчиков смогли изучить и использовать JCF для создания полезных приложений. Это огромное достижение в истории Java.","type":"unstyled","key":"14kdi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Простой дизайн JCF позволяет разработчикам легко освоить четыре основных типа Collection. Эти типы, названные Collection, List, Set и Map, доступны начиная с JDK 1.2. Большинство разработчиков могут быстро освоить работу с коллекциями, изучив эти базовые типы.","type":"unstyled","key":"9kbg1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В изменяемом мире эти и несколько других типов (таких как bag, sorted и ordered) удовлетворили бы большинство повседневных потребностей Java-разработчиков. Однако сейчас мы живем в гибридном мире, где изменяемость и неизменяемость должны сосуществовать. И если мы хотим, чтобы код доходил до будущих разработчиков в лучшем виде, необходимо различать изменяемые и неизменяемые типы.","type":"unstyled","key":"huh5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Пространство List: расширение API с помощью Stream","type":"header-three","key":"f97km"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"С помощью Java Collections Framework и библиотеки Java Stream я продемонстрирую, как выглядит использование List без различения типов. Посмотрите на типы результатов filter, map и collect. Можно ли только по коду определить, изменяемыми или неизменяемыми являются возвращаемые типы используемых методов?","type":"unstyled","key":"af4m6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void landOfTheList()\n{\n var mapping =\n Map.of(\"\uD83C\uDF42\", \"Leaves\", \"\uD83C\uDF41\", \"Leaf\", \"\uD83E\uDD67\", \"Pie\", \"\uD83E\uDD83\", \"Turkey\");\n \n // Изменяемый или неизменяемый? \n List november =\n Arrays.asList(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\", \"\uD83E\uDD83\");\n\n // Изменяемый или неизменяемый?\n List filter = \n november.stream()\n .filter(\"\uD83E\uDD83\"::equals)\n .toList();\n \n // Изменяемый или неизменяемый?\n List filterNot = \n november.stream()\n .filter(Predicate.not(\"\uD83E\uDD83\"::equals))\n .collect(Collectors.toList());\n \n // Изменяемый или неизменяемый?\n List map = \n november.stream()\n .map(mapping::get)\n .collect(Collectors.toUnmodifiableList());\n \n // Изменяемый или неизменяемый?\n Map> partition =\n november.stream()\n .collect(Collectors.partitioningBy(\"\uD83E\uDD83\"::equals));\n \n // Изменяемый или неизменяемый?\n Map> groupBy =\n november.stream()\n .collect(Collectors.groupingBy(mapping::get));\n \n // Изменяемый или неизменяемый?\n Map countBy =\n november.stream()\n .collect(Collectors.groupingBy(mapping::get, \n Collectors.counting()));\n\n Assertions.assertEquals(List.of(\"\uD83E\uDD83\"), filter);\n Assertions.assertEquals(List.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\"), filterNot);\n Assertions.assertEquals(List.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), map);\n Assertions.assertEquals(filter, partition.get(true));\n Assertions.assertEquals(filterNot, partition.get(false));\n var expectedGroupBy =\n Map.of(\"Leaves\", List.of(\"\uD83C\uDF42\"),\n \"Leaf\", List.of(\"\uD83C\uDF41\"),\n \"Pie\", List.of(\"\uD83E\uDD67\"),\n \"Turkey\", List.of(\"\uD83E\uDD83\"));\n Assertions.assertEquals(expectedGroupBy, groupBy);\n Assertions.assertEquals(\n Map.of(\"Leaves\", 1L, \"Leaf\", 1L, \"Pie\", 1L, \"Turkey\", 1L), countBy);\n}","type":"blockquote","key":"7nb54"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"При таком подходе к дизайну наиболее безопасным решением будет не доверять никому и создавать копии коллекций, прежде чем работать с ними. Такое решение чревато дополнительными затратами.","type":"unstyled","key":"7lv9n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Ничто в этом мире не бывает бесплатным. Сегодня у Java-разработчиков, которым нужен гибридный фреймворк коллекций с четким различением интерфейсов изменяемых и неизменяемых коллекций, есть выбор следующих вариантов:","type":"unstyled","key":"e2q5p"},{"data":{},"depth":0,"entityRanges":[{"key":1,"length":17,"offset":0}],"inlineStyleRanges":[],"text":"Scala Collections.","type":"ordered-list-item","key":"b3gcq"},{"data":{},"depth":0,"entityRanges":[{"key":2,"length":20,"offset":9}],"inlineStyleRanges":[],"text":"Kotlin + ImmutableCollections.","type":"ordered-list-item","key":"6q4oc"},{"data":{},"depth":0,"entityRanges":[{"key":3,"length":19,"offset":0}],"inlineStyleRanges":[],"text":"Eclipse Collections.","type":"ordered-list-item","key":"fo00n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Дизайн с различением типов","type":"header-three","key":"b0fp8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Представьте себе мир Java, в котором существует три вида интерфейсов коллекций, обеспечивающих четкое разграничение типов на читаемые (Readable), изменяемые (Mutable) и неизменяемые (Immutable). В Eclipse Collections используются интерфейсы именно с такими названиями.","type":"unstyled","key":"13vk4"},{"data":{},"depth":0,"entityRanges":[{"key":4,"length":8,"offset":0}],"inlineStyleRanges":[],"text":"Readable: RichIterable, ListIterable, SetIterable и MapIterable.","type":"unordered-list-item","key":"6cgud"},{"data":{},"depth":0,"entityRanges":[{"key":5,"length":8,"offset":0}],"inlineStyleRanges":[],"text":"Mutable: MutableCollection, MutableList, MutableSet и MutableMap.","type":"unordered-list-item","key":"f8agr"},{"data":{},"depth":0,"entityRanges":[{"key":6,"length":10,"offset":0}],"inlineStyleRanges":[],"text":"Immutable: ImmutableCollection, ImmutableList, ImmutableSet и ImmutableMap.","type":"unordered-list-item","key":"eovb4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Утроение общего числа типов, необходимое для обеспечения их различия, означает, что разработчику потребуется больше времени на изучение таких фреймворков, как Scala Collections, Kotlin Collections и Eclipse Collections. По временным затратам это равносильно переходу от среднего к высшему образованию.","type":"unstyled","key":"95lpn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Посмотрим на примере Eclipse Collections, как на практике выглядит подобное различение типов и как оно, наряду с функциональным и “текучим” API, приводит к широкому использованию ковариантных типов возвращаемых значений. Стоит заметить, что ковариантные типы возвращаемых значений (Covariant Return Types) — замечательная возможность, доступная с Java 5.","type":"unstyled","key":"9egqj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Различение типов в Eclipse Collections","type":"header-three","key":"d1uvt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Приведенные ниже примеры построены на основе демонстрации, использованной в разделе “Пространство List” (“Land of List”). Они позволят сосредоточиться на двух основных типах коллекций Java — List и Set. Вы увидите примеры использования как изменяемых, так и неизменяемых типов с различением их в Eclipse Collections. В примерах будут рассмотрены MutableList, MutableSet, ImmutableList и ImmutableSet и в каждом случае будут показаны различаемые ковариантные типы возвращаемых значений при применении следующих методов.","type":"unstyled","key":"1uiri"},{"data":{},"depth":0,"entityRanges":[{"key":7,"length":6,"offset":0},{"key":8,"length":12,"offset":55}],"inlineStyleRanges":[],"text":"select (также известный как filter) — возвращает тип RichIterable.","type":"unordered-list-item","key":"4948j"},{"data":{},"depth":0,"entityRanges":[{"key":9,"length":6,"offset":0},{"key":10,"length":12,"offset":58}],"inlineStyleRanges":[],"text":"reject (также известный как filterNot) — возвращает тип RichIterable.","type":"unordered-list-item","key":"4l1ns"},{"data":{},"depth":0,"entityRanges":[{"key":11,"length":7,"offset":0},{"key":12,"length":12,"offset":53}],"inlineStyleRanges":[],"text":"collect (также известный как map) — возвращает тип RichIterable.","type":"unordered-list-item","key":"blrbn"},{"data":{},"depth":0,"entityRanges":[{"key":13,"length":9,"offset":0},{"key":14,"length":17,"offset":66}],"inlineStyleRanges":[],"text":"partition (также известный как partitioningBy) — возвращает тип PartitionIterable.","type":"unordered-list-item","key":"b3116"},{"data":{},"depth":0,"entityRanges":[{"key":15,"length":7,"offset":0},{"key":16,"length":8,"offset":60}],"inlineStyleRanges":[],"text":"groupBy (также известный как groupingBy) — возвращает тип Multimap.","type":"unordered-list-item","key":"4rla6"},{"data":{},"depth":0,"entityRanges":[{"key":17,"length":7,"offset":0},{"key":18,"length":3,"offset":71}],"inlineStyleRanges":[],"text":"countBy (также известный как groupingBy + counting) — возвращает тип Bag.","type":"unordered-list-item","key":"b7d5s"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Нас будет интересовать один вопрос: изменяемыми или неизменяемыми будут типы возвращаемых значений при применении этих методов.","type":"unstyled","key":"4jjf1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"MutableList","type":"header-three","key":"2g3nd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Типы возвращаемых значений при применении методов в MutableList являются ковариантными переопределениями родительского интерфейса RichIterable. Изменяемыми или неизменяемыми будут типы возвращаемых значений при применении методов в MutableList?","type":"unstyled","key":"26qg0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void covariantReturnTypesMutableList()\n{\n var mapping =\n Maps.immutable.of(\"\uD83C\uDF42\", \"Leaves\", \"\uD83C\uDF41\", \"Leaf\", \"\uD83E\uDD67\", \"Pie\", \"\uD83E\uDD83\", \"Turkey\");\n\n // Изменяемый или неизменяемый?\n MutableList november =\n Lists.mutable.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\", \"\uD83E\uDD83\");\n\n // Изменяемый или неизменяемый?\n MutableList select = \n november.select(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый? \n MutableList reject = \n november.reject(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n MutableList collect = \n november.collect(mapping::get);\n\n // Изменяемый или неизменяемый?\n PartitionMutableList partition = \n november.partition(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n MutableListMultimap groupBy = \n november.groupBy(mapping::get);\n\n // Изменяемый или неизменяемый?\n MutableBag countBy = \n november.countBy(mapping::get);\n\n Assertions.assertEquals(List.of(\"\uD83E\uDD83\"), select);\n Assertions.assertEquals(List.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\"), reject);\n Assertions.assertEquals(\n List.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), collect);\n Assertions.assertEquals(select, partition.getSelected());\n Assertions.assertEquals(reject, partition.getRejected());\n var expectedGroupBy = \n Multimaps.mutable.list.with(\"Leaves\", \"\uD83C\uDF42\", \"Leaf\", \"\uD83C\uDF41\", \"Pie\", \"\uD83E\uDD67\")\n .withKeyMultiValues(\"Turkey\", \"\uD83E\uDD83\");\n Assertions.assertEquals(expectedGroupBy, groupBy);\n Assertions.assertEquals(\n Bags.mutable.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), countBy);\n}","type":"blockquote","key":"c6bjv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ImmutableList","type":"header-three","key":"apnna"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Типы возвращаемых значений при применении методов в ImmutableList являются ковариантными переопределениями родительского интерфейса RichIterable. Изменяемыми или неизменяемыми будут типы возвращаемых значений при применении методов в ImmutableList?","type":"unstyled","key":"bi6nr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void covariantReturnTypesImmutableList()\n{\n var mapping =\n Maps.immutable.of(\"\uD83C\uDF42\", \"Leaves\", \"\uD83C\uDF41\", \"Leaf\", \"\uD83E\uDD67\", \"Pie\", \"\uD83E\uDD83\", \"Turkey\");\n\n // Изменяемый или неизменяемый?\n ImmutableList november =\n Lists.immutable.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\", \"\uD83E\uDD83\");\n\n // Изменяемый или неизменяемый?\n ImmutableList select =\n november.select(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n ImmutableList reject =\n november.reject(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n ImmutableList collect =\n november.collect(mapping::get);\n\n // Изменяемый или неизменяемый?\n PartitionImmutableList partition =\n november.partition(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n ImmutableListMultimap groupBy =\n november.groupBy(mapping::get);\n\n // Изменяемый или неизменяемый?\n ImmutableBag countBy =\n november.countBy(mapping::get);\n\n Assertions.assertEquals(List.of(\"\uD83E\uDD83\"), select);\n Assertions.assertEquals(List.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\"), reject);\n Assertions.assertEquals(\n List.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), collect);\n Assertions.assertEquals(select, partition.getSelected());\n Assertions.assertEquals(reject, partition.getRejected());\n var expectedGroupBy =\n Multimaps.mutable.list.with(\"Leaves\", \"\uD83C\uDF42\", \"Leaf\", \"\uD83C\uDF41\", \"Pie\", \"\uD83E\uDD67\")\n .withKeyMultiValues(\"Turkey\", \"\uD83E\uDD83\").toImmutable();\n Assertions.assertEquals(expectedGroupBy, groupBy);\n Assertions.assertEquals(\n Bags.immutable.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), countBy);\n}","type":"blockquote","key":"1kn6n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"MutableSet","type":"header-three","key":"erc9f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Типы возвращаемых значений при применении методов в MutableSet являются ковариантными переопределениями родительского интерфейса RichIterable. Изменяемыми или неизменяемыми будут типы возвращаемых значений при применении методов в MutableSet?","type":"unstyled","key":"eavbq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void covariantReturnTypesMutableSet()\n{\n var mapping =\n Maps.immutable.of(\"\uD83C\uDF42\", \"Leaves\", \"\uD83C\uDF41\", \"Leaf\", \"\uD83E\uDD67\", \"Pie\", \"\uD83E\uDD83\", \"Turkey\");\n\n // Изменяемый или неизменяемый?\n MutableSet november =\n Sets.mutable.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\", \"\uD83E\uDD83\");\n\n // Изменяемый или неизменяемый?\n MutableSet select = \n november.select(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n MutableSet reject = \n november.reject(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n MutableSet collect = \n november.collect(mapping::get);\n\n // Изменяемый или неизменяемый?\n PartitionMutableSet partition = \n november.partition(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n MutableSetMultimap groupBy = \n november.groupBy(mapping::get);\n\n // Изменяемый или неизменяемый?\n MutableBag countBy = \n november.countBy(mapping::get);\n\n Assertions.assertEquals(Set.of(\"\uD83E\uDD83\"), select);\n Assertions.assertEquals(Set.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\"), reject);\n Assertions.assertEquals(\n Set.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), collect);\n Assertions.assertEquals(select, partition.getSelected());\n Assertions.assertEquals(reject, partition.getRejected());\n var expectedGroupBy = \n Multimaps.mutable.set.with(\"Leaves\", \"\uD83C\uDF42\", \"Leaf\", \"\uD83C\uDF41\", \"Pie\", \"\uD83E\uDD67\")\n .withKeyMultiValues(\"Turkey\", \"\uD83E\uDD83\");\n Assertions.assertEquals(expectedGroupBy, groupBy);\n Assertions.assertEquals(\n Bags.mutable.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), countBy);\n}","type":"blockquote","key":"a842h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ImmutableSet","type":"header-three","key":"344g0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Типы возвращаемых значений при применении методов в ImmutableSet являются ковариантными переопределениями родительского интерфейса RichIterable. Изменяемыми или неизменяемыми будут типы возвращаемых значений при применении методов в ImmutableSet?","type":"unstyled","key":"4t1pt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"@Test\npublic void covariantReturnTypesImmutableSet()\n{\n var mapping =\n Maps.immutable.of(\"\uD83C\uDF42\", \"Leaves\", \"\uD83C\uDF41\", \"Leaf\", \"\uD83E\uDD67\", \"Pie\", \"\uD83E\uDD83\", \"Turkey\");\n\n // Изменяемый или неизменяемый?\n ImmutableSet november =\n Sets.immutable.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\", \"\uD83E\uDD83\");\n\n // Изменяемый или неизменяемый?\n ImmutableSet select = \n november.select(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n ImmutableSet reject = \n november.reject(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый?\n ImmutableSet collect = \n november.collect(mapping::get);\n\n // Изменяемый или неизменяемый?\n PartitionImmutableSet partition = \n november.partition(\"\uD83E\uDD83\"::equals);\n\n // Изменяемый или неизменяемый? \n ImmutableSetMultimap groupBy = \n november.groupBy(mapping::get);\n\n // Изменяемый или неизменяемый?\n ImmutableBag countBy = \n november.countBy(mapping::get);\n\n Assertions.assertEquals(Set.of(\"\uD83E\uDD83\"), select);\n Assertions.assertEquals(Set.of(\"\uD83C\uDF42\", \"\uD83C\uDF41\", \"\uD83E\uDD67\"), reject);\n Assertions.assertEquals(Set.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), collect);\n Assertions.assertEquals(select, partition.getSelected());\n Assertions.assertEquals(reject, partition.getRejected());\n var expectedGroupBy = \n Multimaps.mutable.set.with(\"Leaves\", \"\uD83C\uDF42\", \"Leaf\", \"\uD83C\uDF41\", \"Pie\", \"\uD83E\uDD67\")\n .withKeyMultiValues(\"Turkey\", \"\uD83E\uDD83\").toImmutable();\n Assertions.assertEquals(expectedGroupBy, groupBy);\n Assertions.assertEquals(Bags.immutable.of(\"Leaves\", \"Leaf\", \"Pie\", \"Turkey\"), countBy);\n}","type":"blockquote","key":"fiv2b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Доверяй, но проверяй: внутренние и внешние пользователи API","type":"header-three","key":"1l08l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Одна из задач различения типов заключается в более четком донесении ваших намерений до разработчиков, которые будут читать и использовать код. Дело в том, что недобросовестные разработчики могут предоставить изменяемую реализацию неизменяемого интерфейса или, наоборот, неизменяемую реализацию изменяемого интерфейса. Оба варианта действительно возможны. Одно из решений, доступных сегодня в Java, — использование запечатанных типов (sealed) для ограничения альтернатив реализации в дизайне с иерархической системой наследования.","type":"unstyled","key":"5718n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если вы не доверяете разработчикам, использующим ваш API (например, неизвестным внешним пользователям), то у вас единственный выход — копировать данные для входящих параметров коллекции независимо от того, какой интерфейс вам передается. Различаемые типы возвращаемых значений должны быть безопасными и при этом более четко передавать намерения.","type":"unstyled","key":"85c3f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если же вы доверяете разработчикам, использующим ваш API (внутренним пользователям), то различение типов сделает код намного яснее.","type":"unstyled","key":"40efv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Читайте также:","type":"unstyled","key":"dl3gg"},{"data":{},"depth":0,"entityRanges":[{"key":19,"length":49,"offset":0}],"inlineStyleRanges":[],"text":"Обнаружение и предотвращение утечек памяти в Java","type":"unordered-list-item","key":"1b1rh"},{"data":{},"depth":0,"entityRanges":[{"key":20,"length":75,"offset":0}],"inlineStyleRanges":[],"text":"Сложные вопросы на собеседовании для тех, кто 7 лет работал с Java. Часть 2","type":"unordered-list-item","key":"21shh"},{"data":{},"depth":0,"entityRanges":[{"key":21,"length":49,"offset":0}],"inlineStyleRanges":[],"text":"3 способа мониторинга изменений лог-файлов в Java","type":"unordered-list-item","key":"7iub4"},{"data":{},"depth":0,"entityRanges":[{"key":22,"length":8,"offset":14},{"key":23,"length":2,"offset":24}],"inlineStyleRanges":[],"text":"Читайте нас в Telegram, VK","type":"unstyled","key":"94bjr"},{"data":{},"depth":0,"entityRanges":[{"key":24,"length":11,"offset":15},{"key":25,"length":61,"offset":28}],"inlineStyleRanges":[{"length":14,"offset":0,"style":"ITALIC"}],"text":"Перевод статьи Donald Raab: How do you know if a Java Collection is Mutable or Immutable?","type":"unstyled","key":"6vb9p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"mcJIyBhoxsFZnyIJhVxm"}],"entityMap":{"22":{"data":{"href":"https://t.me/nuancesprog","url":"https://t.me/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"23":{"data":{"href":"https://vk.com/nuancesprog","url":"https://vk.com/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"24":{"data":{"href":"https://medium.com/@donraab","url":"https://medium.com/@donraab"},"mutability":"MUTABLE","type":"LINK"},"25":{"data":{"href":"https://medium.com/javarevisited/how-do-you-know-if-a-java-collection-is-mutable-or-immutable-b397dfc5d231","url":"https://medium.com/javarevisited/how-do-you-know-if-a-java-collection-is-mutable-or-immutable-b397dfc5d231"},"mutability":"MUTABLE","type":"LINK"},"10":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html"},"mutability":"MUTABLE","type":"LINK"},"11":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#collect%28org.eclipse.collections.api.block.function.Function%29","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#collect%28org.eclipse.collections.api.block.function.Function%29"},"mutability":"MUTABLE","type":"LINK"},"12":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html"},"mutability":"MUTABLE","type":"LINK"},"13":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#partition%28org.eclipse.collections.api.block.predicate.Predicate%29","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#partition%28org.eclipse.collections.api.block.predicate.Predicate%29"},"mutability":"MUTABLE","type":"LINK"},"14":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/partition/PartitionIterable.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/partition/PartitionIterable.html"},"mutability":"MUTABLE","type":"LINK"},"15":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#groupBy%28org.eclipse.collections.api.block.function.Function%29","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#groupBy%28org.eclipse.collections.api.block.function.Function%29"},"mutability":"MUTABLE","type":"LINK"},"16":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/multimap/Multimap.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/multimap/Multimap.html"},"mutability":"MUTABLE","type":"LINK"},"17":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#countBy%28org.eclipse.collections.api.block.function.Function%29","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#countBy%28org.eclipse.collections.api.block.function.Function%29"},"mutability":"MUTABLE","type":"LINK"},"18":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/bag/Bag.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/bag/Bag.html"},"mutability":"MUTABLE","type":"LINK"},"19":{"data":{"href":"https://nuancesprog.ru/p/19628/","url":"https://nuancesprog.ru/p/19628/"},"mutability":"MUTABLE","type":"LINK"},"0":{"data":{"url":"https://nuancesprog.ru/p/19712/"},"mutability":"MUTABLE","type":"LINK"},"1":{"data":{"href":"https://docs.scala-lang.org/overviews/collections-2.13/overview.html","url":"https://docs.scala-lang.org/overviews/collections-2.13/overview.html"},"mutability":"MUTABLE","type":"LINK"},"2":{"data":{"href":"https://github.com/Kotlin/kotlinx.collections.immutable","url":"https://github.com/Kotlin/kotlinx.collections.immutable"},"mutability":"MUTABLE","type":"LINK"},"3":{"data":{"href":"https://github.com/eclipse/eclipse-collections","url":"https://github.com/eclipse/eclipse-collections"},"mutability":"MUTABLE","type":"LINK"},"4":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html"},"mutability":"MUTABLE","type":"LINK"},"5":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/collection/MutableCollection.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/collection/MutableCollection.html"},"mutability":"MUTABLE","type":"LINK"},"6":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/collection/ImmutableCollection.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/collection/ImmutableCollection.html"},"mutability":"MUTABLE","type":"LINK"},"7":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#select%28org.eclipse.collections.api.block.predicate.Predicate%29","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#select%28org.eclipse.collections.api.block.predicate.Predicate%29"},"mutability":"MUTABLE","type":"LINK"},"8":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html"},"mutability":"MUTABLE","type":"LINK"},"9":{"data":{"href":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#reject%28org.eclipse.collections.api.block.predicate.Predicate%29","url":"https://eclipse.dev/collections/javadoc/11.1.0/org/eclipse/collections/api/RichIterable.html#reject%28org.eclipse.collections.api.block.predicate.Predicate%29"},"mutability":"MUTABLE","type":"LINK"},"20":{"data":{"href":"https://nuancesprog.ru/p/19324/","url":"https://nuancesprog.ru/p/19324/"},"mutability":"MUTABLE","type":"LINK"},"21":{"data":{"href":"https://nuancesprog.ru/p/16207/","url":"https://nuancesprog.ru/p/16207/"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}