JAVA学习笔记（7）Java中的数据结构实现：集合

集合

Java中的集合将数结构做成了类和API直接拿来使用。集合类中存储的不是真正的数据，而是对象的指针或者引用地址。

实际开发中，经常用到 java 的集合框架，比如 ArrayList 、 LinkedList 、 HashMap 、 LinkedHashMap等等。

Java 集合就像一种容器，可以把多个对象（实际上是对象的引用，但习惯上都称对象）“丢进”该容器中。从 Java 5 增加了泛型以后，Java 集合可以记住容器中对象的数据类型，使得编码更加简洁、健壮。

Java 集合大致可以分为两大体系，一个是 Collection，另一个是 Map；

Collection ：主要由List、Set、Queue接口组成，List代表有序、重复的集合；其中Set代表无序、不可重复的集合；Java 5 又增加了Queue体系集合，代表一种队列集合实现。

Map：则代表具有映射关系的键值对集合。

java.util.Collection 及其集合

Collection中的集合基本都是线性结构，存储结构是顺序表和链表，但是TreeSet和HashSet也借助了Map集合实现。

java.util.Collection：集合父类

这个是所有集合都要用到的公共接口，里面有一些常用方法，一些不常用的方法可以查询API使用，下面的实现类：ArrayList 、 LinkedList ，都是要实现这些方法的：

boolean	add(E e)
确保此集合包含指定的元素（可选操作）。

void	clear()
从此集合中删除所有元素（可选操作）。

boolean	contains(Object o)
如果此集合包含指定的元素，则返回 true 。

boolean	equals(Object o)
将指定的对象与此集合进行比较以获得相等性。

int	hashCode()
返回此集合的哈希码值。

boolean	isEmpty()
如果此集合不包含元素，则返回 true 。

Iterator<E>	iterator()
返回此集合中的元素的迭代器。

boolean	remove(Object o)
从该集合中删除指定元素的单个实例（如果存在）（可选操作）。

boolean	retainAll(Collection<?> c)
仅保留此集合中包含在指定集合中的元素（可选操作）。

int	size()
返回此集合中的元素数。

Object[]	toArray()
返回一个包含此集合中所有元素的数组。

java.util.Iterable接口：迭代器

Iterable是所有集合接口和类的祖先类，证明每一个被实现的集合类型中的内容都是可迭代，每一个实现类都要实现制造迭代器这个函数。Iterator是一个接口，所以每个实现类也需要实现这个的Iterator这个接口。

Iterator<T>	iterator()
返回类型为 T元素的迭代器。

以Arraylist为例子,下面是ArrayList的部分源代码，实现Iterator iterator()这个方法：

如何实现Iterator这个函数？采用了内部类的方式。Iterator主要是针对某一种数据结构特别设定的类，生成的对象其作用就是索引，或者是指针，初始状态下索引或者指向第一个元素的前一个位置，通过调用hasNext来判断是否有值，通过next获取下一个元素值，这些方法对所有的Collection类型都适用：

boolean	hasNext()
如果迭代具有更多元素，则返回 true 。

E next()
返回迭代中的下一个元素。并且指针向下移动一次。

default void remove()
从底层集合中删除此迭代器返回的最后一个元素（可选操作）

java.util.List ：表集合(顺序表和链表的通用方法)

像顺序表和链表这种数据结构肯定新增一些方法，这些方法组成的List接口，这个接口中的方法会被顺序表和链表实现。

比如E get(int index),在Queue和Stack中尽量就不要使用，因为这两种数据结构是对头和尾都有限制的操作。

以下是顺序表和链表特有的，常用的一些方法：

void add(int index, E element)
将指定的元素插入此列表中的指定位置（可选操作）。

E get(int index)
返回此列表中指定位置的元素。

int	indexOf(Object o)
返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

ListIterator<E>	listIterator()
返回列表中的列表迭代器（按适当的顺序）。
ListIterator<E>	listIterator(int index)
从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。

E remove(int index)
删除该列表中指定位置的元素（可选操作）。
boolean	remove(Object o)
从列表中删除指定元素的第一个出现（如果存在）（可选操作）。

E set(int index, E element)
用指定的元素（可选操作）替换此列表中指定位置的元素。

java.util.ArrayList

ArrayList实现了java.util.List这些方法。

ArrayList实现的是顺序表。

ArrayList是一个泛型类，但是类中的属性是非泛型的。是Obejct类型，但是其中的方法很多都是带泛型的。

要注意擦拭法，ArrayList满足类型自动推断和自动转换，get，set，iterator方法都可以进行自动转换。

其中的基本操作函数和数据结构的思想类似，增加后移，删除前移等等。

案例

public class Main{
    public static void main(String[] args){
        ArrayList<String> arrayList = new ArrayList<>();
        String s = "1111";
        arrayList.add(s);
        arrayList.add("bbb");
        arrayList.add("ccc");
        arrayList.add("ddd");
        arrayList.add(0,"zzz");

        String ss = arrayList.get(0);       // get方法擦拭之后，本来返回的是Object类型，但是泛型有自动转换的机制。
        System.out.println(ss);
        for (String sss : arrayList){
            System.out.println(sss);
        }
    }
}

java.util.LinkedList

LinkedList实现了java.util.List这些方法。

LinkedList实现的是双向链表，带有头尾指针，不是双向循环链表，是双向链表。

LinkedList是一个泛型类，类中的属性有头指针和尾指针组成，实现方式和双向链表一样

要注意擦拭法，LinkedList满足类型自动推断和自动转换，get，set，iterator方法都可以进行自动转换。

其中的基本操作函数和数据结构的思想类似，插入是先右后左等等。

public class Main{
    public static void main(String[] args){
       LinkedList<String> b = new LinkedList<>();
        b.add("Bob");
        b.add("Doug");
        b.add("Frances");
        b.add("Gloria");

        System.out.println(b.getLast());		// 自动类型转换
        for (String ss : b){
            System.out.println(ss);
        }
    }
}

java.util.Set:Set集合的接口

Set集合的特点：元素不重复，存取无顺序、序，无下标，存取都是没有特定顺序的，并且指针指向的元素不能重复

其中Set集合存取无顺序就是说，存进去的顺序和取出来的顺序大多数不一致。

接口常用方法：

boolean	add(E e)
如果指定的元素不存在，则将其指定的元素添加（可选操作）。

void	clear()
从此集合中删除所有元素（可选操作）。

boolean	contains(Object o)
如果此集合包含指定的元素，则返回 true 。

boolean	equals(Object o)
将指定的对象与此集合进行比较以实现相等。

int	hashCode()
返回此集合的哈希码值。

boolean	isEmpty()
如果此集合不包含元素，则返回 true 。

Iterator<E>	iterator()
返回此集合中元素的迭代器。

boolean	remove(Object o)
如果存在，则从该集合中删除指定的元素（可选操作）。

int	size()
返回此集合中的元素数（其基数）。

default Spliterator<E>	spliterator()
在此集合中的元素上创建一个 Spliterator 。

Object[]	toArray()
返回一个包含此集合中所有元素的数组。

<T> T[]	toArray(T[] a)
返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

其中只有基本的一些方法，并没有下标，因为这是Set集合的特征。

java.util.HashSet

HashSet泛型原理和List集合基本一致，实现了Set集合的方法，但是呢，底层用的是HashMap集合。

HashSet不能有方法带有下标的方法get,indexOf等等方法，所以这个类比较容易。

HashSet底层是基于 HashMap 的k实现的，元素不可重复，特性同 HashMap。

public class Main{
    public static void main(String[] args){
       HashSet<String> hs = new HashSet<>();
        hs.add("Doug");
        hs.add("Frances");
        hs.add("Bob");
        hs.add("Doug");
        hs.add("Frances");
        hs.add("Gloria");
        for (String s : hs){
            System.out.println(s.hashCode());
        }
    }
}

案例：

public class Main{
    public static void main(String[] args){
       TreeSet<String> hs = new TreeSet<>();
        hs.add("1111");
        hs.add("Doug");
        hs.add("Frances");
        hs.add("Bob");
        hs.add("Doug");
        hs.add("Frances");
        hs.add("Gloria");
        for (String s : hs){
            System.out.println(s + ":" +s.hashCode());		// 和hashcode无关
        }
    }
}

java.util.TreeSet

TreeSet泛型原理和List集合基本一致，实现了Set集合的方法，但是呢，底层用的是TreeSet集合。

TreeSet不能有方法带有下标的方法get,indexOf等等方法，所以这个类比较容易。

TreeSet底层是基于TreeMap 的k实现的，元素不可重复，特性同TreeMap。

TreeSet中的数据元素是自动排序的，有大小关系的，是有序的,但是是无顺序的，不可重复的

public class Main{
    public static void main(String[] args){
       TreeSet<String> hs = new TreeSet<>();
        hs.add("Doug");
        hs.add("Frances");
        hs.add("Bob");
        hs.add("Doug");
        hs.add("Frances");
        hs.add("Gloria");
        for (String s : hs){
            System.out.println(s + ":" +s.hashCode());		// 和hashcode无关
        }
    }
}

Set 集合的实现，基本都是基于 Map 中的键做文章，使用 Map 中键不能重复、无顺序的特性；所以，只需要重点关注 Map 的实现即可！

java.util.Map及其映射集合

Map集合，是基于哈希表的数据结构，基本采用的是链地址法这种形式。

基于K-V形式，存储的是K-V所指对象的地址

java.util.Map：接口常用方法

void	clear()
从该地图中删除所有的映射（可选操作）。

boolean	containsKey(Object key)
如果此映射包含指定键的映射，则返回 true 。

boolean	containsValue(Object value)
如果此地图将一个或多个键映射到指定的值，则返回 true 。

Set<Map.Entry<K,V>>	entrySet()
返回此地图中包含的映射的Set视图。

boolean	equals(Object o)
将指定的对象与此映射进行比较以获得相等性。

V	get(Object key)
返回到指定键所映射的值，或 null如果此映射包含该键的映射。

int	hashCode()
返回此地图的哈希码值。

boolean	isEmpty()
如果此地图不包含键值映射，则返回 true 。

Set<K>	keySet()
返回此地图中包含的键的Set视图。

V	put(K key, V value)
将指定的值与该映射中的指定键相关联（可选操作）。

V	remove(Object key)
如果存在（从可选的操作），从该地图中删除一个键的映射。

default boolean	remove(Object key, Object value)
仅当指定的密钥当前映射到指定的值时删除该条目。

default V	replace(K key, V value)
只有当目标映射到某个值时，才能替换指定键的条目。

default boolean	replace(K key, V oldValue, V newValue)
仅当当前映射到指定的值时，才能替换指定键的条目。

int	size()
返回此地图中键值映射的数量。

Collection<V>	values()
返回此地图中包含的值的Collection视图。

案例

public class Main {
	public static void main(String[] args) {
		HashMap<Integer, String> hs = new HashMap<Integer, String>();
		hs.put(1, "222");
		hs.put(2, "111");
		hs.put(100, "333");
		hs.put(4, "4444");
		Collection<String> cl = hs.values();		// 返回此地图中包含的值的Collection视图，包含Value
		for(String ss : cl) {
			System.out.println(ss);
		}
		Set<Integer> set = hs.keySet();		// 返回此地图中包含的键的Set视图，包含Key
		for(Integer i : set) {
			System.out.println(i);
		}
		Set<Map.Entry<Integer, String>> sset = hs.entrySet();		// 返回此地图中包含的映射的Set视图,内容是返回整个key和valuse，即Node对象
		for(Map.Entry<Integer, String> me : sset) {
			System.out.println(me);
		}
	}
}

java.util.HashMap

HashMap是内部原理是基于链地址法来解决冲突

通过hashcode的值进入hash算法确定下标

key的位置不确定，所以HashSet是没有排序的

Key的类需要重写hashcode和equals方法来保持Key的唯一性，不重写hashcode就会导致每个对象都不一样，出现对象属性一样，但是对象不一样。
不重写equals，就无法判断出Key部分是否相等，equls即能判断出是否是属于同一个类，又能判断属性是否相等。
在使用get和put方法中，类的属性相等，hashcode必须相等

public class Main {
	
	public static void main(String[] args) {
		HashMap<A, String> hs = new HashMap<>();
		hs.put(new A(), "222");
		hs.put(new A(), "111");
		hs.put(new A(), "333");
		hs.put(new A(), "4444");
		Collection<String> cl = hs.values();
		for(String ss : cl) {
			System.out.println(ss);
		}
		Set<A> set = hs.keySet();
		for(A i : set) {
			System.out.println(i);
		}
		Set<Map.Entry<A, String>> sset = hs.entrySet();
		for(Map.Entry<A, String> me : sset) {
			System.out.println(me.toString());
		}			
	}
}

class A{
	private int i;
	@Override
	public String toString() {
		return this.i + "";
	}
}

java.util.TreeMap

使用方法和原理如下，基于红黑树：

https://www.cnblogs.com/liahon/p/11221634.html

Key类型自己定义也需要实现CompareTo方法，用来进行排序，因为红黑树和AVL树都是基于二叉排序树的改进，所以排序的时候，如果重复就不会添加到树结构中。