Классы и интерфейсы коллекции - пакет `java.util`:
1. Класс `Vector` - устаревший
2. Класс `Stack` - устаревший
3. Класс `Hashtable` - устаревший
4. Интерфейс `Collection`
5. Интерфейс `List`
6. Интерфейс `Set`
7. Интерфейс `Map`
## Класс `Vector`
Конструкторы:
```java
Vector()
Vector(int capacity)
Vector(int capacity, int increment)
Vector(Collection c)
```
Методы:
```java
boolean add(Object element)
void add(int index, Object element)
Object set(int index, Object element)
Object get(int index)
int size()
int capacity()
boolean isEmpty()
Object remove(int index)
```
## Класс `Stack`
Конструктор:
```java
Stack()
```
Методы:
```java
Object push(Object item)
Object pop()
Object peek()
boolean empty()
int search(Object item)
```
## Класс `Hashtable`
Конструкторы:
```java
Hashtable()
Hashtable(int capacity)
Hashtable(int capacity, float loadFactor)
Hashtable(Map f)
```
Методы:
```java
Object put(Object key, Object value)
Object get(Object key)
boolean containsKey(object key)
boolean containsValue(Object value)
Collection values()
Set keyset()
Object remove(Object key)
```
## Интерфейс `Collection`
Общие свойства коллекций `List` и `Set`:
```java
boolean add(Object obj)
boolean addAll(Collection coll)
void clear()
boolean contains(Object obj)
boolean containsAll(Collection coll)
boolean isEmpty()
Iterator iterator()
boolean remove(object obj)
boolean removeAll(Collection coll)
boolean rerainAll(Collection coll)
int size()
Object[] toArray()
```
## Итераторы
![Iterator и ListIterator](../Pictures/04_01.%20Iterator%20и%20ListIterator.png)  
```java
public static void main(String[] args) {
	ArrayList<String> states = new ArrayList<String>();
	states.add("Germany");
	states.add("France");
	states.add("Italy");
	states.add("Spain");
	
	Iterator<String> iter = states.iterator();
	while(iter.hasNext()) {
		System.out.println(iter.next());
		for(String str:states)
			System.out.println(str);
	}
}
```
## Интерфейс `List`
Методы:
```java
void add(int index, Object obj)
Object get(int index)
int indexOf(Object obj)
Integer remove(int index)
ListIterator listiterator()
Object set(int index, object obj)
```
Классы-списки:
```java
// ArrayList
ArrayList()
ArrayList(Collection coll)
ArrayList(int intCapacity)

// LinkedList
LinkedList()
LinkedList(Collection coll)
```
#### `ArrayList`
![ArrayList](../Pictures/04_02.%20ArrayList.png)
#### `LinkedList`
![LinkedList](../Pictures/04_03.%20LinkedList.png)
#### `ArrayDeque<E>`
Этот класс представляет собой обобщенную двунаправленную очередь, наследуя функционал от класса `AbstractCollection` и применяя интерфейс `Deque`.
#### `PriorityQueue<E>`
Этот класс представляет собой приоритетную очередь.
## Интерфейсы `Set`, `SortedSet`
Методы `SortedSet`:
```java
Comparator comparator()
Object first()
Object last()
SortedSet headset(Object toElement)
SortedSet subset(Object fromElement, Object toElement)
SortedSet tailSet(Object fromElement)
```
Классы-множества:
```java
// HashSet
HashSet()
HashSet(int capacity)
HashSet(int capacity, float loadFactor)
HashSet(Collection coll)

// TreeSet
TreeSet()
TreeSet(Comparator c)
TreeSet(Collection coll)
TreeSet(SortedMap m)
```
  
```java
public class Main {
	public static void main(String[] args) {
		Set<Integer> set = new HashSet<>();
		set.add(1111);
		set.add(12);
		set.add(23);
		System.out.println(set);
		set.add(123);
		System.out.println(set);
	}
}
```
  
```java
public class Main {
	public static void main(String[] args) {
		Set<Integer> set = new TreeSet<>();
		set.add(1111);
		set.add(12);
		set.add(23);
		System.out.println(set);
		set.add(123);
		System.out.println(set);
	}
}
```
## Интерфейсы `Map`, `SortedMap`
Методы:
```java
Object put(Object key, Object value)
void putAll(Map m)
Object get(object key)
boolean containsKey(Object key)
boolean containsValue(Object value)
Set entryset()
Set keyset()
Collection values()

Comparator comparator()
Object firstKey()
Object lastKey()
SortedMap subMap(object fromKey, Object toKey)
```
Классы-отображения:
```java
// HashMap
HashMap()
HashMap(int capacity)
HashMap(int capacity, float LoadFactor)
HashMap(Map f)

// TreeMap
TreeMap()
TreeMap(Comparator c)
TreeMap(Map f)
TreeMap(SortedMap sf)
```
#### `HashMap`
![HashMap](../Pictures/04_04.%20HashMap.png)
## Задание порядка
#### Интерфейс `Comparable`
```java
public class A implements Comparable {
	String name;
	
	public int compareTo(Object obj) {
		return name.compareTo(((A)obj).name);
	}
	...
}
```
  
```java
public class Anna implements Comparable {
	String name;
	
	public Anna(String valueName) {
		this.name = valueName;
	}
	
	public int compareTo(Object obj) {
		return name.compareTo(((Anna)obj).name);
	}
	
	@Override
	public String toString() {
		return "Anna{" + "name='" + name + '\'' + '}'
	}
}

public class Main {
	public static void main(String[] args) {
		Set<Integer> set = new TreeSet<>();
		set.add(new Anna("Bbbb"));
		set.add(new Anna("Aaaa"));
		set.add(new Anna("Abab"));
		System.out.println(set);
		set.add(new Anna("Baba"));
		System.out.println(set);
	}
}
```
#### Интерфейс `Comparator`
```java
public int compare(Object o1, Object o2)
public boolean equals(Object obj)
```
## Класс `Collections`
Методы:
```java
static void sort(List coll)
static void sort(List coll, Comparator c)
static int binarySearch(List coll, Object element)
static int binarySearch(List coll, Object element, Comparator c)
static Object max(Collection coll)
static Object max(Collection coll, Comparator c)
static Object min(Collection coll)
static Object min(Collection coll, Comparator c)
static void shuffle(List coll)
static void shuffle(List coll, Random r)
static void reverse(List coll)
static void copy(List from, List to)
static void fill(List coll, Object element)
```
## Класс `Arrays`
Методы:
```java
static void sort(type[] a)
static void sort(type[] a, int from, int to)
static void sort(Object[] a, Comparator c)
static void sort(Object[] a, int from, int to, Comparator c)
static int binarySearch(type[] a, type element)
static int binarySearch(Object[] a, Object element, Comparator c)
static void fill(type[], type value)
static void fill(type[], int from, int to, type value)
static boolean equals(type[] a1, type[] a2)
```
## Пример своей коллекции
```java
static List<Integer> rangeList(int fromInclusive, int toExclusive) {
	return new AbstractList<Integer>() {
		public Integer get(int index) {
			if (index < 0 || index >= size())
				throw new IndexOutOfBoundsException();
			return fromInclusive + index;
		}
		
		public int size() {
			return toExclusive - fromInclusive;
		}
	}
}

List<Integer> rl = rangeList(0, 10);
System.out.println(rl);
System.out.println(rl.contains(5));
```