Java学习--Java集合框架（list、map、set）

泛型

在介绍集合框架之前必须先介绍泛型，泛型的提出就是为了建立具有类型安全的集合框架。比如我们一但用List声明了一个集合，在我们向这个集合中添加数据时，不需要采取任何的多于措施来保证这个集合中存入的是同一个类型的数据。这个在声明该集合时就确定了该集合是用来存储什么样的数据的。

泛型类的声明

可以使用 ”class 类名<泛型类表>“来声明一个泛型类。
泛型列表中的泛型可以用任何合法的标识符，如果有多个泛型则用“,”隔开。与普通的类一样，泛型类的类体也包括属性和方法两个部分，不同的是允许使用泛型作为成员变量的类型、方法的类型以及局部变量的类型。

class Test<E>{
E e;
public E get(){
return e;
}
}

泛型类的使用

再用泛型类声明以及创建一个对象时，一定要把“<>”中的泛型替换成具体的数据类型（可以是接口、类，但不能是基本数据类型）。

class People{
}

Test<People> test = new Test<People>();

可以看得出，使用了泛型允许我们在程序设计时向类中引入一些可变的数据类型,当我们在使用该泛型类时，将泛型替换成了什么类型的数据，那么在创建对象时它就有了具体的数据类型。

集合框架

我们知道，我们在使用数组作为存储结构存储数据时非常的不方便。这是因为我们在创建数组时必须提前确定分配给该数组的内存大小，一旦数组的大小分配完成，就不能动态的改变。大部分情况下，我们是不能确定我们需要的数组大小的。这就使得如果我们分配的数组过大，就会浪费了宝贵的内存资源，分配过小呢又会不足以满足数据的存储需求。所以我们就用到了链表这个数据结构，使用链表时我们不需要提前分配内存大小，而是在使用时自动的分配。

链表的使用

使用链表我们就必须用到LinkedList泛型类。该类位于java.util包中，它实现了List泛型接口，而List又是Collection接口的子接口。所以在使用LinkedList类时我们一般使用接口回调，即把LinkedList对象的引用放到List或者Collection创建的对象中。在创建List对象时一定不要忘记将"<>"中的泛型换成具体的数据类型。

List<Integer> list = new LinkedList<Integer>();

常用方法

1、public boolean add(E element)
向创建的链表对象中添加一个数据元素，成功返回true，失败返回false。

2、public void add(int index, E element)
向创建的链表的指定位置添加一个元素。

3、public void clear()
删除链表中的全部数据

4、public E remove(int index)
删除并返回链表指定位置上的数据

5、public boolean remove(E element)
删除指定的数据，删除成功则返回true，删除失败或者数据不存在则返回false

6、public E set(int index, E element)
将链表指定位置上的元素替换成指定的新元素，然后返回被替换的元素

7、public E get(int index)
取得链表指定位置上的元素

8、public int indexOf(E element)
查找链表中是否含有此数据元素，有则返回第一次出现该元素的位置，没有返回-1

9、public int lastIndexOf(E element)
返回最后一次出现指定数据元素的位置，没有饭后-1

10、public boolean contains(E element)
查找链表中是否包含指定元素，返回true或者false

11、public int size()
返回链表的长度，即节点的个数

12、public Object clone()
克隆一个链表

链表的遍历

总体来说有四种方法：
1、for循环遍历

	List<Integer> list = new LinkedList<Integer>();
		//向链表中添加数据
		for(int i = 0; i < 10000; i++) {
			list.add(i);
		}
		//for循环遍历
		for(int i = 0;i < list.size(); i++) {
			System.out.println(list.get(i));
		}

2、增强for循环遍历

	List<Integer> list = new LinkedList<Integer>();
		//向链表中添加数据
		for(int i = 0; i < 10000; i++) {
			list.add(i);
		}
		//增强for循环遍历
		for(int i = 0;i < list.size(); i++) {
			System.out.println(list.get(i));
		}

3、迭代器遍历（Iterator）

List<Integer> list = new LinkedList<Integer>();
		//向链表中添加数据
		for(int i = 0; i < 10000; i++) {
			list.add(i);
		}
		//迭代器遍历
		Iterator<Integer> iterator = list.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}

4、列表迭代器遍历(ListIterator)

List<Integer> list = new LinkedList<Integer>();
		//向链表中添加数据
		for(int i = 0; i < 10000; i++) {
			list.add(i);
		}
		//列表迭代器遍历
		//正向
		ListIterator<Integer> iterator =  list.listIterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		//反向
		while(iterator.hasPrevious()) {
			System.out.println(iterator.previous());
		}

ListIterator是Iterator的子类，与其父类相比只是多了反向遍历这个，但是要想反向遍历必须先正向遍历一遍。

处LinkedList外，类似的还有ArrayList。两者用法相同，不同的是ArrayList用的是顺序的数组存储结构，所以它在查找指定位置的数据时更加快，但LinkedList在添加、修改、删除数据时要更方便。

散列映射（HashMap<K,V>）

HashMap<K,V>实现了Map<K,V>泛型接口。它采用散列表的存储结构，可以存储“键/值”对，只是不允许存储的数据的键相同，如果向散列表中存入一个有相同键的数据，那么先前的数据值将会被覆盖。采用散列映射存储数据可以建立键值的一一对映，在查找不知道具体存储位置的值时不必再遍历查找，节省大量计算机资源。

散列映射的使用
同样接口回调

Map<Integer, String> map = new HashMap<Integer, String>();

常用方法

1、public V put(K key, V value)
向散列表中添加数据，返回添加的值

2、public void clear()
清空散列表

3、public V remove(K key)
删除键为key的数据并返回其值

4、public V get(K key)
取出键为key的数据的值

5、public boolean containsKey(K key)
查询是否存在键为key的数据

6、public boolean containsValue(V value)
查询是否存在值为value的数据

7、public Object clone()
克隆该散列表

8、public int size()
查询散列表的长度

9、public Set entrySet()
返回一个该散列表的set视图

散列映射的遍历

三种：

1、利用values()方法（只能遍历获取他的值）

	Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "hello1");
		map.put(2, "hello2");
		map.put(3, "hello3");
		map.put(4, "hello4");
		map.put(5, "hello5");
		
		Collection<String> collection = map.values();
		
		for(String str : collection) {
			System.out.println(str);
		}

2、利用keySet()方法获取其键的set视图

Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "hello1");
		map.put(2, "hello2");
		map.put(3, "hello3");
		map.put(4, "hello4");
		map.put(5, "hello5");
		
		Set<Integer> set = map.keySet();
		for(Integer key : set) {
			System.out.println(map.get(key));
		}

3、利用entrySet()方法，将map中的每一个键值对都转化成Map.entry对象，将所有的对象再放入一个Set集合建立一个map的set映射，再依次取得其键、值

Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "hello1");
		map.put(2, "hello2");
		map.put(3, "hello3");
		map.put(4, "hello4");
		map.put(5, "hello5");
		
		Set<Entry<Integer,String>> set = map.entrySet();
		for(Entry<Integer,String> entry : set) {
			System.out.println("key:"+entry.getKey()+" value:"+entry.getValue());
		}

TreeMap<K,V>与HashMap用法类似，不同的是TreeMap对数据的存储是有序的，按照键值升序排序，如果键值必须是实现了Comparable接口的可比较的对象。

树集（TreeSet）

树集采用树状存储结构，同一层按照从左到右升序排序，不同层按照从下到上升序排序。实现了Set接口

书籍的使用

Set<String> set = new TreeSet<String>();

常用方法

1、public boolean add(E element)
添加一个元素

2、public void clear()
删除全部元素

3、public boolean remove(E element)
移除指定元素

4、public boolean contains(E element)
查询是否包含指定元素

5、public E first()
返回第一节点中的元素（最小）

6、public E last()
返回最后一个节点的元素（最大）

树集的遍历

1、

Set<Integer> set = new TreeSet<Integer>();
		for(int i = 0; i < 10000; i++)
			set.add(i);
	
		for(Integer n : set)
			System.out.println(n);

2、

Set<Integer> set = new TreeSet<Integer>();
		for(int i = 0; i < 10000; i++)
			set.add(i);
	
		Iterator<Integer> iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}