🗊Презентация Java.SE.06. Generic and collections

Generic & Collections

Содержание Определение коллекций Интерфейс Collection Множества Set Интерфейс Iterator Сравнение коллекций. Comparator, Comparable Списки List Очереди Queue Карты отображений Map Класс Collections Унаследованные коллекции Коллекции для перечислений

определение коллекций

Определение коллекций Коллекции – это хранилища, поддерживающие различные способы накопления и упорядочения объектов с целью обеспечения возможностей эффективного доступа к ним. Применение коллекций обуславливается возросшими объемами обрабатываемой информации. Коллекции в языке Java объединены в библиотеке классов java.util и представляют собой контейнеры, т.е объекты, которые группируют несколько элементов в отдельный модуль. Коллекции используются для хранения, поиска, манипулирования и передачи данных. Коллекции – это динамические массивы, связные списки, деревья, множества, хэш-таблицы, стеки, очереди.

Определение коллекций Collections framework - это унифицированная архитектура для представления и манипулирования коллекциями. Collections framework содержит: Интерфейсы Реализации (Implementations) Алгоритмы

Определение коллекций Интерфейсы коллекций: Collection<E> – вершина иерархии остальных коллекций; List<E> – специализирует коллекции для обработки списков; Set<E> – специализирует коллекции для обработки множеств, содержащих уникальные элементы; Map<K,V> – карта отображения вида “ключ-значение”. Интерфейсы позволяют манипулировать коллекциями независимо от деталей конкретной реализации, реализуя тем самым принцип полиморфизма

Определение коллекций

Определение коллекций

Определение коллекций Все конкретные классы Java Collections Framework реализуют Cloneable и Serializable интерфейсы, следовательно, их экземпляры могут быть клонированы и сериализованы.

Определение коллекций Реализации (Implementations) Конкретные реализации интерфейсов могут быть следующих типов: General-purpose implementations Special-purpose implementations Concurrent implementations Wrapper implementations Convenience implementations Abstract implementations

Определение коллекций General-Purpose Implementations - реализации общего назначения, наиболее часто используемые реализации, HashSet, TreeSet, LinkedHashSet. ArrayList , LinkedList. HashMap, TreeMap, LinkedHashMap. PriorityQueue

Определение коллекций Special-Purpose Implementations - реализации специального назначения, разработаны для использования в специальных ситуациях и предоставляют нестандартные характеристики производительности, ограничения на использование или на поведение EnumSet , CopyOnWriteArraySet. CopyOnWriteArrayList EnumMap, WeakHashMap, IdentityHashMap

Определение коллекций Concurrent implementations – потоковые реализации ConcurrentHashMap LinkedBlockingQueue ArrayBlockingQueue PriorityBlockingQueue DelayQueue SynchronousQueue LinkedTransferQueue

Определение коллекций Wrapper implementations – реализация обертки, применяется для реализации нескольких типов в одном, чтобы обеспечить добавленную или ограниченную функциональность, все они находятся в классе Collections. public static <T> Collection<T> synchronizedCollection(Collection<T> c); public static <T> Set<T> synchronizedSet(Set<T> s); public static <T> List<T> synchronizedList(List<T> list); public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m); public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s); и др. public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c); public static <T> Set<T> unmodifiableSet(Set<? extends T> s); public static <T> List<T> unmodifiableList(List<? extends T> list); public static <K,V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m); public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<? extends T> s); public static <K,V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, ? extends V> m);

Определение коллекций Convenience implementations – удобные реализации, выполнены обычно с использованием реализаций общего назначения и применением static factory methods для предоставления альтернативных путей создания (например, единичной коллекции) Получить такие коллекции можно при помощи следующих методов Arrays.asList Collections.nCopies Collections.singleton emptySet, emptyList, emptyMap. (из Collections)

Определение коллекций Abstract implementations – основа всех реализаций коллекций, которая облегчает создание собственных коллекций. AbstractCollection AbstractSet AbstractList AbstractSequentialList AbstractQueue AbstractMap

Определение коллекций Алгоритмы (Algorithms) Это методы, которые выполняют некоторые вычисления, такие как поиск, сортировка объектов, реализующих интерфейс Сollection. Они также реализуют принцип полиморфизма, таким образом один и тот же метод может быть использован в различных реализациях Сollection интерфейса. По существу, алгоритмы представляют универсальную функциональность.

Интерфейс collection

Интерфейс Collection Интерфейс Collection - вершина иерархии коллекций Интерфейс Collection - наименьший набор характеристик, реализуемых всеми коллекциями JDK не предоставляет прямых реализаций этого интерфейса, но существует множество реализаций более специфичных подинтерфейсов таких как Set и List.

Интерфейс Collection public interface Collection<E> extends Iterable<E> { boolean equals(Object o); int size(); //возвращает количество элементов в коллекции; boolean isEmpty(); // возвращает true, если коллекция пуста; boolean contains(Object element); //возвращает true, если коллекция содержит элемент element; boolean add(E element); //добавляет element к вызывающей коллекции и возвращает true, если объект добавлен, и false, если element уже элемент коллекции; boolean remove(Object element); //удаляет element из коллекции; Iterator<E> iterator(); //возвращает итератор

Интерфейс Collection boolean containsAll(Collection<?> c); //возвращает true, если коллекция содержит все элементы из c; boolean addAll(Collection<? extends E> c); //добавляет все элементы коллекции к вызывающей коллекции; boolean removeAll(Collection<?> c); //удаление всех элементов данной коллекции, которые содержаться в c; boolean retainAll(Collection<?> c); //удаление элементов данной коллекции, которые не содержаться в коллекции c; void clear(); //удаление всех элементов. Object[] toArray(); //копирует элементы коллекции в массив объектов <T> T[] toArray(T[] a); //возвращает массив, содержащий все элементы коллекции }

Интерфейс Collection interface Iterable<T>{ Iterator<T> iterator(); // возвращает итератор по множеству элементов T }

Интерфейс Collection Класс AbstractCollection - convenience class, предоставляет частичную реализацию интерфейса Collection, реализует все методы, за исключением size() и iterator().

Интерфейс Collection Некоторые методы интерфейса Collection могут быть не реализованы в подклассах (нет необходимости их реализовывать). В этом случае метод генерирует java.lang.UnsupportedOperationException (подкласс RuntimeException) Это хорошее решение, которое следует использовать.

Множества SET

Множества Set Множество ─ коллекция без повторяющихся элементов Интерфейс Set<E> содержит методы, унаследованные Collection<E> и добавляет запрет на дублирующиеся элементы.

Множества Set

Множества Set Интерфейс Set заботится об уникальности хранимых объектов, уникальность определятся реализацией метода equals().

Множества Set public interface Set<E> extends Collection<E> { int size(); //возвращает количество элементов в множестве boolean isEmpty(); //возвращает true, если множество пусто; boolean contains(Object element); //возвращает true, если множество содержит элемент element boolean add(E element); //добавляет element к вызывающему множеству и возвращает true, если объект добавлен, и false, если element уже элемент множества boolean remove(Object element); // удаляет element из множества Iterator<E> iterator(); // возвращает итератор по множеству

Множества Set boolean containsAll(Collection<?> c); // возвращает true, если множество содержит все элементы коллекции с boolean addAll(Collection<? extends E> c); //добавление всех элементов из коллекции c во множество, если их еще нет boolean removeAll(Collection<?> c); //удаляет из множества все элементы, входящие в коллекцию c boolean retainAll(Collection<?> c); //сохраняет элементы во множестве, которые также содержаться и в коллекции с void clear(); //удаление всех элементов Object[] toArray(); //копирует элементы множества в массив объектов <T> T[] toArray(T[] a); //возвращает массив, содержащий все элементы множества }

Множества Set Set также добавляет соглашение на поведение методов equals и hashCode, позволяющих сравнивать множества даже если их реализации различны Два множества считаются равными, если они содержат одинаковые элементы

Множества Set Правила сравнения на равенство Метод boolean equals(Object o) Рефлексивность o1.equals(o1) Симметричность o1.equals(o2) == e2.equals(o1) Транзитивность o1.equals(o2) && o2.equals(o3) => o1.equals(o3) Устойчивость o1.equals(o2) не изменяется, если o1 и o2 не изменяются Обработка null o1.equals(null) == false

Множества Set Интерфейс SortedSet из пакета java.util, расширяющий интерфейс Set, описывает упорядоченное множество, отсортированное по естественному порядку возрастания его элементов или по порядку, заданному реализацией интерфейса Comparator.

Множества Set public interface SortedSet<E> extends Set<E>{ Comparator<? super E> comparator(); // возвращает способ упорядочения коллекции; E first(); // минимальный элемент SortedSet<E> headSet(E toElement); //подмножество элементов, меньших toElement E last(); // максимальный элемент SortedSet<E> subSet(E fromElement, E toElement); // подмножество элементов, меньших toElement и больше либо равных fromElement SortedSet<E> tailSet(E fromElement); // подмножество элементов, больших либо равных fromElement }

Множества Set Интерфейс NavigableSet добавляет возможность перемещения, "навигации" по отсортированному множеству.

Множества Set public interface NavigableSet<E> extends SortedSet<E>{ E lower(E e); E floor(E e); E higher(E e); E ceiling(E e); E pollFirst(); E pollLast(); Iterator<E> iterator(); Iterator<E> descendingIterator(); NavigableSet<E> descendingSet();

Множества Set // методы, позволяющие получить подмножество элементов. Параметры fromElement и toElement ограничивают подмножество снизу и сверху, а флаги fromInclusive и toInclusive показывают, нужно ли в результирующий набор включать граничные элементы. headSet возвращает элементы с начала набора до указанного элемента, а tailSet - от указанного элемента до конца набора. Перегруженные методы без логических параметров включают в выходной набор первый элемент интервала, но исключают последний. SortedSet<E> headSet(E toElement) NavigableSet<E> headSet(E toElement, boolean inclusive) NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) SortedSet<E> subSet(E fromElement, E toElement) SortedSet<E> tailSet(E fromElement) NavigableSet<E> tailSet(E fromElement, boolean inclusive) }

Множества Set Класс AbstractSet - convenience class , который наследуется от AbstractCollection и реализует интерфейс Set. Класс AbstractSet предоставляет реализацию методов equals и hashCode; hash-код множества – это сумма всех hash-кодов его элементов; методы size и iterator не реализованы.

Множества Set HashSet – неотсортированная и неупорядоченная коллекция, для вставки элемента используются методы hashCode() и equals(…). Чем эффективней реализован метод hashCode(), тем эффективней работает коллекция. HashSet используется в случае, когда порядок элементов не важен, но важно чтобы в коллекции все элементы были уникальны.

Множества Set Конструкторы HashSet HashSet() ─ создает пустое множество; HashSet(Collection<? extends E> c) ─ создает новое множество с элементами коллекции c; HashSet(int initialCapacity) ─ создает новое пустое множество размера initialCapacity; HashSet(int initialCapacity, float loadFactor) ─ создает новое пустое множество размера initialCapacity со степенью заполнения loadFactor. Выбор слишком большой первоначальной вместимости (capacity) может обернуться потерей памяти и производительности. Выбор слишком маленькой первоначальной вместимости (capacity) уменьшает производительность из-за копирования данных каждый раз, когда вместимость увеличивается.

Множества Set Для эффективности объекты, добавляемые в множество должны реализовывать hashСode. Метод int hashCode() - возвращает значение хэш-кода множества Правила: Устойчивость hashCode() не изменяется, если объект не изменяется Согласованность с equals() o1.equals(o2) => o1.hashCode() == o2.hashCode()

Множества Set. Example 01 Результат:

Множества Set LinkedHashSet<E> ─ множество на основе хэша c сохранением порядка обхода.

Множества Set. Example 02 Результат:

Множества Set TreeSet<E> – реализует интерфейс NavigableSet<E>, который поддерживает элементы в отсортированном по возрастанию порядке. Для хранения объектов использует бинарное дерево. При добавлении объекта в дерево он сразу же размещается в необходимую позицию с учетом сортировки. Сортировка происходит благодаря тому, что все добавляемые элементы реализуют интерфейсы Comparator и Comparable. Обработка операций удаления и вставки объектов происходит медленнее, чем в хэш-множествах, но быстрее, чем в списках.

Множества Set Используется в том случае, если необходимо использовать операции, определенные в интерфейсе SortedSet, NavigableSet или итерацию в определенном порядке.

Множества Set Конструкторы TreeSet: TreeSet(); TreeSet(Collection <? extends E> c); TreeSet(Comparator <? super E> c); TreeSet(SortedSet <E> s);

Множества Set Класс TreeSet<E> содержит методы по извлечению первого и последнего (наименьшего и наибольшего) элементов E first() и E last(). Методы SortedSet<E> subSet(E from, E to), SortedSet<E> tailSet(E from) и SortedSet<E> headSet(E to) предназначены для извлечения определенной части множества. Метод Comparator <? super E> comparator() возвращает объект Comparator, используемый для сортировки объектов множества или null, если выполняется обычная сортировка.

Множества Set. Example 03

Множества Set. Example 03 Результат:

Интерфейс Iterator

Интерфейс Iterator Для обхода коллекции можно использовать: for-each Конструкция for-each является краткой формой записи обхода коллекции с использованием цикла for. Iterator Итератор это объект, который позволяет осуществлять обход коллекции и при желании удалять избранные элементы.

Интерфейс Iterator Интерфейс Iterator<E> используется для доступа к элементам коллекции Iterator<E> iterator() – возвращает итератор

Интерфейс Iterator public interface Iterator { boolean hasNext(); // возвращает true при наличии следующего элемента, а в случае его отсутствия возвращает false. Итератор при этом остается неизменным; Object next(); // возвращает объект, на который указывает итератор, и передвигает текущий указатель на следующий итератор, предоставляя доступ к следующему элементу. Если следующий элемент коллекции отсутствует, то метод next() генерирует исключение ; void remove(); // удаляет объект, возвращенный последним вызовом метода next() }

Интерфейс Iterator Исключения: NoSuchElementException ─ генерируется при достижении конца коллекции ConcurrentModificationException ─ генерируется при изменении коллекции

Интерфейс Iterator. Example 04

Интерфейс Iterator. Example 04 Результат:

Интерфейс Iterator Используйте Iterator вместо for-each если вам необходимо удалить текущий элемент. Конструкция for-each скрывает итератор, поэтому нельзя вызвать remove Также конструкция for-each не применима для фильтрации.

Интерфейс Iterator Чтобы удалить все экземпляры определенного элемента е из коллекции с воспользуйтесь следующим кодом: Удалить все элементы null из коллекции Collections.singleton(), статический метод, который возвращает постоянное множество, содержащее только определенный элемент.

Сравнение объектов. Compatator, comparable

Сравнение коллекций. Comparator, Comparable Естественный порядок сортировки (natural sort order) — естественный и реализованный по умолчанию (реализацией метода compareTo интерфейса java.lang.Comparable) способ сравнения двух экземпляров одного класса. int compareTo(E other) — сравнивает this объект с other и возвращает отрицательное значение если this<other, 0 — если они равны и положительное значение если this>other.

Сравнение коллекций. Comparator, Comparable Реализация Comparable позволяет: Вызвать Collections.sort иCollections.binarySearch Вызывать Arrays.sort и Arrays.binarySearch Использовать такие объекты, как keys в TreeMap Использовать такие объекты, как elements вTreeSet

Сравнение коллекций. Comparator, Comparable Метод compareTo должен выполнять следующие условия. sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) если x.compareTo(y) выбрасывает исключение, то и y.compareTo(x) должен выбрасывать то же исключение если x.compareTo(y)>0 и y.compareTo(z)>0, тогда x.compareTo(z)>0 если x.compareTo(y)==0, и x.compareTo(z)==0, то и y.compareTo(z)==0 x.compareTo(y)==0, тогда и только тогда, когда x.equals(y) ; (правило рекомендуемо но не обязательно)

Сравнение коллекций. Comparator, Comparable. Example 05

Сравнение коллекций. Comparator, Comparable. Example 05

Сравнение коллекций. Comparator, Comparable. Example 05

Сравнение коллекций. Comparator, Comparable. Example 05

Сравнение коллекций. Comparator, Comparable. Example 05 Результат:

Сравнение коллекций. Comparator, Comparable При реализации интерфейса Comparator<T> существует возможность сортировки списка объектов конкретного типа по правилам, определенным для этого типа. Для этого необходимо реализовать метод int compare(T ob1, T ob2), принимающий в качестве параметров два объекта для которых должно быть определено возвращаемое целое значение, знак которого и определяет правило сортировки. Этот метод автоматически вызывается методом public static <T> void sort(List<T> list, Comparator<? super T> c) класса Collections, в качестве первого параметра принимающий коллекцию, в качестве второго – объект-comparator, из которого извлекается правило сортировки.

Сравнение коллекций. Comparator, Comparable java.util.Comparator — содержит два метода: int compare(T o1, T o2) — сравнение, аналогичное compareTo boolean equals(Object obj) — true если оbj это Comparator и у него такой же принцип сравнения.

Сравнение коллекций. Comparator, Comparable. Example 06

Сравнение коллекций. Comparator, Comparable. Example 06

Сравнение коллекций. Comparator, Comparable. Example 06

Сравнение коллекций. Comparator, Comparable. Example 06

Сравнение коллекций. Comparator, Comparable. Example 06 Результат:

Списки List

Списки List Список - упорядоченная коллекция (иногда называется sequence) Список может содержать повторяющиеся элементы. Интерфейс List сохраняет последовательность добавления элементов и позволяет осуществлять доступ к элементу по индексу.

Списки List

Списки List public interface List<E> extends Collection<E> { E get(int index); //возвращает объект, находящийся в позиции index; E set(int index, E element); //заменяет элемент, находящийся в позиции index объектом element; boolean add(E element); //добавляет элемент в список void add(int index, E element); //вставляет элемент element в позицию index, при этом список раздвигается E remove(int index); //удаляет элемент, находящийся на позиции index boolean addAll(int index, Collection<? extends E> c); //добавляет все элементы коллекции с в список, начиная с позиции index

Списки List int indexOf(Object o); //возвращает индекс первого появления элемента o в списке; int lastIndexOf(Object o); //возвращает индекс последнего появления элемента o в списке; ListIterator<E> listIterator(); //возвращает итератор на список ListIterator<E> listIterator(int index); //возвращает итератор на список, установленный на элемент с индексом index List<E> subList(int from, int to); //возвращает новый список, представляющий собой часть данного (начиная с позиции from до позиции to-1 включительно). }

Списки List Класс AbstractList предоставляет частичную реализацию для интерфейса List. Класс AbstractSequentialList расширяет AbstractList, чтобы предоставить поддержку для связанных списков.

Списки List ListIterator<E> - это итератор для списка

Списки List interface ListIterator<E> extends Iterator{ boolean hasNext() / boolean hasPrevious() // проверка E next() / E previous () // взятие элемента int nextIndex() / int previousIndex() // определение индекса void remove() // удаление элемента void set(E o) // изменение элемента void add(E o) // добавление элемента }

Списки List ArrayList<E> ─ список на базе массива (реализация List) Достоинства Быстрый доступ по индексу Быстрая вставка и удаление элементов с конца Недостатки Медленная вставка и удаление элементов Аналогичен Vector за исключением потокобезопасности Применения: “Бесконечный” массив Стек

Списки List Конструкторы ArrayList ArrayList() ─ пустой список ArrayList(Collection<? extends E> c) ─ копия коллекции ArrayList(int initialCapacity) ─ пустой список заданной вместимости Вместимость ─ реальное количество элементов Дополнительные методы void ensureCapacity(int minCapacity) ─ определение вместимости void trimToSize() ─ “подгонка” вместимости

Списки List LinkedList<E> ─ двусвязный список (реализация List) Достоинства Быстрое добавление и удаление элементов Недостатки Медленный доступ по индексу Рекомендуется использовать, если необходимо часто добавлять элементы в начало списка или удалять внутренний элемент списка Применения: Стек Очередь Дек

Списки List Конструкторы LinkedList LinkedList<E> () //пустой список LinkedList(Collection<? extends E> c) //копия коллекции Дополнительные методы void addFirst(E o) //добавить в начало списка void addLast(E o) // добавить в конец списка E removeFirst() // удалить первый элемент E removeLast() //удалить последний элемент E getFirst() E getLast()

Списки List. Example 07

Списки List. Example 07

Списки List. Example 07 Результат:

Очереди Queue

Очереди Queue Очередь, предназначенная для размещения элемента перед его обработкой. Расширяет коллекцию методами для вставки, выборки и просмотра элементов Очередь – хранилище элементов, предназначенных для обработки.

Очереди Queue Кроме базовых методов Collection очередь(Queue) предоставляет дополнительные методы по добавлению, извлечению и проверке элементов. Чаще всего порядок выдачи элементов соответствует FIFO (first-in, first-out), но в общем случае определяется конкретной реализацией. Очереди не могут хранить null. У очереди может быть ограничен размер.

Очереди Queue

Очереди Queue public interface Queue<E> extends Collection<E> { E element(); // возвращает, но не удаляет головной элемент очереди boolean offer(E o); //добавляет в конец очереди новый элемент и возвращает true, если вставка удалась. E peek(); // возвращает первый элемент очереди, не удаляя его. E poll(); // возвращает первый элемент и удаляет его из очереди E remove(); // возвращает и удаляет головной элемент очереди }

Очереди Queue Класс AbstractQueue – реализует методы интерфейса Queue: size() offer(Object o) peek() poll() iterator()

Очереди Queue. Example 08 Результат:

Очереди Queue Интерфейс Deque позволяет реализовать двунаправленная очередь, разрешающую вставку и удаление элементов в два конца очереди. Интерфейс Deque определяет «двунаправленную» очередь и, соответственно, методы доступа к первому и последнему элементам двусторонней очереди. Методы обеспечивают удаление, вставку и обработку элементов. Каждый из этих методов существует в двух формах. Одни методы создают исключительную ситуацию в случае неудачного завершения, другие возвращают какое-либо из значений (null или false в зависимости от типа операции).

Очереди Queue Вторая форма добавления элементов в очередь сделана специально для реализаций Deque, имеющих ограничение по размеру. Методы addFirst(e), addLast(e) вставляют элементы в начало и в конец очереди соответственно. Метод add(e) унаследован от интерфейса Queue и абсолютно аналогичен методу addLast(e) интерфейса Deque.

Очереди Queue ArrayDeque - эффективная реализация интерфейса Deque переменного размера Конструкторы: ArrayDeque(); // создает пустую двунаправленную очередь с вместимостью 16 элементов ArrayDeque(Collection<? extends E> c); // создает двунаправленную очередь из элементов коллекции c в том порядке, в котором они возвращаются итератором коллекции c. ArrayDeque(int numElements); // создает пустую двунаправленную очередь с вместимостью numElements.

Очереди Queue. Example 09 Результат:

Очереди Queue. Example 10

Очереди Queue. Example 10 Результат:

Очереди Queue PriorityQueue – это класс очереди с приоритетами. По умолчанию очередь с приоритетами размещает элементы согласно естественному порядку сортировки используя Comparable. Элементу с наименьшим значением присваивается наибольший приоритет. Если несколько элементов имеют одинаковый наивысший элемент – связь определяется произвольно. Также можно указать специальный порядок размещения, используя Comparator

Очереди Queue Конструкторы PriorityQueue: PriorityQueue(); // создает очередь с приоритетами начальной емкостью 11, размещающую элементы согласно естественному порядку сортировки (Comparable). PriorityQueue(Collection<? extends E> c); PriorityQueue(int initialCapacity); PriorityQueue(int initialCapacity, Comparator<? super E> comparator); PriorityQueue(PriorityQueue<? extends E> c); PriorityQueue(SortedSet<? extends E> c);

Очереди Queue. Example 11

Очереди Queue. Example 11

Очереди Queue. Example 11 Результат:

Карты отображений map

Карты отображений Map Интерфейс Map работает с наборами пар объектов «ключ-значение» Все ключи в картах уникальны. Уникальность ключей определяет реализация метода equals(…). Для корректной работы с картами необходимо переопределить методы equals(…) и hashCode(), допускается добавление объектов без переопределения этих методов, но найти эти объекты в Map вы не сможете.

Карты отображений Map

Карты отображений Map public interface Map<K,V> { V put(K key, V value); // запись V get(Object key); // получение значение V remove(Object key); // удаление boolean containsKey(Object key); // наличие ключа boolean containsValue(Object value); // наличие значения int size(); // размер отображения boolean isEmpty(); // проверка на пустоту void putAll(Map<? extends K, ? extends V> m); // добавление всех пар void clear(); // полная очистка public Set<K> keySet(); // множество ключей public Collection<V> values(); // коллекция значений public Set<Map.Entry<K,V>> entrySet(); // множество пар }

Карты отображений Map public static interface Map.Entry<K,V> { boolean equals(Object o); // сравнивает объект о с сущностью this на равенство K getKey(); // возвращает ключ карты отображения V getValue(); // возвращает значение карты отображения int hashCode(); // возвращает hash-код для карты отображения V setValue(V value); // устанавливает значение для карты отображения }

Карты отображений Map public interface SortedMap<K,V> extends Map<K,V>{ Comparator<? super K> comparator(); // возвращает компаратор, используемый для упорядочивания ключей иди null, если используется естественный порядок сортировки Set<Map.Entry<K,V>> entrySet(); // возвращает множество пар K firstKey(); // минимальный ключ SortedMap<K,V> headMap(K toKey); // отображение ключей меньших toKey Set<K> keySet(); // возвращает множество ключей K lastKey(); // максимальный ключ SortedMap<K,V> subMap(K fromKey, K toKey); // отображение ключей меньших toKey и больше либо равных fromKey SortedMap<K,V> tailMap(K fromKey); // отображение ключей больших либо равных fromKey Collection<V> values(); // возвращает коллекцию всех значений }

Карты отображений Map

Карты отображений Map

Карты отображений Map

Карты отображений Map

Карты отображений Map HashMap – неотсортированная и неупорядоченная карта, эффективность работы HashMap зависит от того, насколько эффективно реализован метод hashCode(). HashMap может принимать в качестве ключа null, но такой ключ может быть только один, значений null может быть сколько угодно.

Карты отображений Map LinkedHashMap –хранит элементы в порядке вставки. LinkedHashMap добавляет и удаляет объекты медленнее чем HashMap, но перебор элементов происходит быстрее.

Карты отображений Map TreeMap –хранит элементы в порядке сортировки. По умолчанию TreeMap сортирует элементы по возрастанию от первого к последнему, также порядок сортировки может задаваться реализацией интерфейсов Comparator и Comparable. Реализация Comparator передается в конструктор TreeMap, Comparable используется при добавлении элемента в карту.

Карты отображений Map. Example 12

Карты отображений Map. Example 12

Карты отображений Map. Example 12 Результат:

Карты отображений Map. Example 13

Карты отображений Map. Example 13 Результат:

Класс collections

Класс Collections Collections — класс, состоящий из статических методов, осуществляющих различные служебные операции над коллекциями.

Класс Collections

Класс Collections

Класс Collections .

Класс Collections. Example 14 Результат:

Класс Collections. Example 15

Класс Collections. Example 16

Класс Collections. Example 17

Класс Collections. Example 18

Класс Collections. Example 19

Класс Collections. Example 20

Класс Collections. Example 21

Класс Collections. Example 22

Класс Collections. Example 23

Унаследованные коллекции

Унаследованные коллекции Унаследованные коллекции (Legacy Collections) – это коллекции языка Java 1.0/1.1 В ряде распределенных приложений, например с использованием сервлетов, до сих пор применяются унаследованные коллекции, более медленные в обработке, но при этом потокобезопасные, существовавшие в языке Java с момента его создания.

Унаследованные коллекции

Унаследованные коллекции Vector –устаревшая версия ArrayList, его функциональность схожа с ArrayList за исключением того, что ключевые методы Vector синхронизированы для безопасной работы с многопоточностью. Из-за того что методы Vector синхронизированы, Vector работает медленее чем ArrayList. Конструкторы класса Vector Vector() Vector(Collection<? extends E> c). Vector(int initialCapacity)           Vector(int initialCapacity, int capacityIncrement)           

Унаследованные коллекции. Example 24

Унаследованные коллекции. Example 24

Унаследованные коллекции. Example 24

Enumeration – объекты классов, реализующих данный интерфейс, используются для предоставления однопроходного последовательного доступа к серии объектов: public interface Enumeration<E>{ boolean hasMoreElements(); E nextElement() ; }

Унаследованные коллекции Класс Stack позволяет создавать очередь типа last-in-first-out (LIFO) public class Stack<E> extends Vector<E> { public boolean empty(); public synchronized E peek(); public synchronized E pop(); public E push(E object); public synchronized int search(Object o); }

Унаследованные коллекции. Example 25

Унаследованные коллекции Hashtable – после модификации в JDK 1.2 реализует интерфейс Map. Порядок следования пар ключ/значение не определен. Конструкторы Hashtable Hashtable() ; Hashtable(int initialCapacity) ; Hashtable(int initialCapacity, float loadFactor) ; Hashtable(Map<? extends K,? extends V> t);           

Унаследованные коллекции. Example 26

Унаследованные коллекции. Example 26

Унаследованные коллекции Класс Properties предназначен для хранения набора свойств (параметров). Методы String getProperty(String key) String getProperty(String key,String defaultValue) позволяют получить свойство из набора. С помощью метода setProperty(String key, String value) это свойство можно установить.

Унаследованные коллекции Метод load(InputStream inStream) позволяет загрузить набор свойств из входного потока. Параметры представляют собой строки представляющие сбой пары ключ/значение. Предполагается, что по умолчанию используется кодировка ISO 8859-1.

Унаследованные коллекции. Example 27

Унаследованные коллекции. Example 27

Унаследованные коллекции. Example 27

Унаследованные коллекции Класс BitSet предназначен для работы с последовательностями битов. Каждый компонент. этой коллекции может принимать булево значение, которое обозначает установлен бит или нет. Содержимое BitSet может быть модифицировано содержимым другого BitSet с использованием операций AND, OR или XOR (исключающее или). BitSet имеет текущий размер (количество установленных битов) может динамически изменятся.

Унаследованные коллекции По умолчанию все биты в наборе устанавливаются в 0 (false). Установка и очистка битов в BitSet осуществляется методами set(int index) и clear(int index). Метод int length() возвращает "логический" размер набора битов, int size() возвращает количество памяти занимаемой битовой последовательностью BitSet.

Унаследованные коллекции. Example 28

Коллекции для перечислений

Коллекции для перечислений Абстрактный класс EnumSet<E extends Enum<E>> (наследуется от абстрактного класса AbstractSet) - специально реализован для работы с типами enum. Все элементы такой коллекции должны принадлежать единственному типу enum, определенному явно или неявно. Внутренне множество представимо в виде вектора битов, обычно единственного long. Множества нумераторов поддерживают перебор по диапазону из нумераторов. Скорость выполнения операций над таким множеством очень высока, даже если в ней участвует большое количество элементов.

Коллекции для перечислений Создание EnumSet EnumSet<T> EnumSet.noneOf(T.class); // cоздает пустое множество нумерованных констант с указанным типом элемента EnumSet<T> EnumSet.allOf(T.class); // создает множество нумерованных констант, содержащее все элементы указанного типа EnumSet<T> EnumSet.of(e1, e2, …); // создает множество, первоначально содержащее указанные элементы EnumSet<T> EnumSet.copyOf(EnumSet<T> s); EnumSet<T> EnumSet.copyOf(Collection<T> t);

Коллекции для перечислений EnumSet<T> EnumSet.complementOf(EnumSet<T> s); // создается множество, содержащее все элементы, которые отсутствуют в указанном множестве EnumSet<T> range(T from, T to); // создает множество из элементов, содержащихся в диапазоне, определенном двумя элементами При передаче вышеуказанным методам в качестве параметра null будет сгенерирована исключительная ситуация NullPointerException

Коллекции для перечислений. Example 29

Коллекции для перечислений EnumMap - высоко производительное отображение (map). В качестве ключей используются элементы перечисления, что позволяет реализовывать EnumMap на базе массива. Null ключи запрещены. Null значения допускаются. Не синхронизировано. Все основные операции с EnumMap совершаются за постоянное время. Как правило EnumMap работает быстрее, чем HashMap. Создание EnumMap EnumMap<K, V>(K.class); EnumMap<K, V>(EnumMap<K, V>); EnumMap<K, V>(Map<K, V>);

Коллекции для перечислений Создать объект EnumMap: Создать синхронизированный объект EnumMap:

Коллекции для перечислений. Example 30

Коллекции для перечислений

Ihar Blinou, PhD Java.SE.06 Generic&Collections