JAVA之Collection集合总结

继承与实现体系

共性方法

由于底层都是实现了Collection接口那么，下面的所有类便会继承。
其中包含：增、删、查、改

返回值	方法	解释
boolean	add(E e)	往集合中添加数据
void	clear()	删除集合所有数据
boolean	remove(Object o)	删除集合中某个存在的数据
boolean	contains(Object o)	查找集合中是否存在这个数据
boolean	isEmpty()	判断集合是否为空
int	size()	查看该集合的长度
Object[]	toArray()	将集合中的数据转化为数组

共性遍历方法—迭代器

  由于每一个的集合遍历方式都或多或少有一些变化，因此这里必须把通用的一种遍历方式进行书写。

步骤

1. 声明一个迭代器的对象。Iterator<E> b =
   注意事项：
   1. 数据格式也就是泛型的改变一定要和需要遍历的集合数据类型相对应！！！
2. 使用集合的 iterator() 方法，返回一个迭代器对象。Iterator<E> 迭代器名 = 集合名.iterator();
3. 利用迭代器的方法：hasNext()与next()进行遍历

迭代器具体使用方式

import java.util.ArrayList;
import java.util.Iterator;


public class Main {

	public static void main(String[] args) {
		// 1. 准备一个集合
		ArrayList<Integer> a = new ArrayList<Integer>();
		a.add(2);a.add(8);a.add(6);a.add(1);
		
		// 2. 声明迭代器对象（注意：上下的数据类型一定要保持一致）
		// 3. 使用集合的iterator()方法返回一个迭代器对象
		Iterator<Integer> b = a.iterator();
		
		
		// 4.利用hashnext()和next()方法进行遍历
		
		/*
		 	其中hashnext()判断集合指针是否指向了空
		 	
		 	next()获取当前数据，并将指针指向下一个数据
		*/
		
		while(b.hasNext()) {
			System.out.println(b.next());
		}

	}

}

运行结果：
2
8
6
1

ArrayList与Vector详解

  其实这两个就是一个数组。但和数组不同的是，我可以随时根据自己的需要动态修改数组长度，对其增删改查。而数组一旦开辟了空间，就再也不能修改。

特点：

1. 查询快，增删慢

LinkedList详解

  由于他底层是继承了链表结构。因此该集合方法，包含了大量的方法都是对首尾进行操作。

特点：

1. 查询慢，增删快

LinkedList常用首尾方法

返回值	方法	解释
void	addFirst(E e)	在该列表开头插入指定的元素
void	addLast(E e)	将指定的元素追加到此列表的末尾
E	getFirst()	返回此列表中的第一个元素
E	getLast()	返回此列表中的最后一个元素
E	peekFirst()	检索但不删除此列表的第一个元素，如果此列表为空，则返回 null
E	peekLast()	检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null
E	pollFirst()	检索并删除此列表的第一个元素，如果此列表为空，则返回 null
E	pollLast()	检索并删除此列表的最后一个元素，如果此列表为空，则返回 null

HashSet详解

  底层是由哈希表+链表/红黑树构成。因此为了对其进行存放那就要使用相应的规则去靠近这两种。该集合由于存放数据是根据哈希表存放的，因此存储的数据和我存放时的数据会产生位置差异。

1. 哈希表： 通过hashcode()方法计算出一个哈希值。
2. 链表结构： 当哈希值一样通过equals()方法计算出内容是否相同，如果不同，将哈希值的元素连接到一起。
3. 红黑树结构： 特殊情况，如果某一个哈希值下面已经连接了8个以上的数据，自动将链表结构转化为红黑树结构。

  具体过程如下图所示：

代码模拟HashSet

import java.util.HashSet;



public class Main {

	public static void main(String[] args) {
		
		String x = "重地";	// 1179395
		String y = "通话";	// 1179395
		String z = "abc";	// 96354
		System.out.println(x.hashCode());
		System.out.println(y.hashCode());
		System.out.println(z.hashCode());
		
		// 模拟过程
		HashSet<String> hash = new HashSet<String>();		// 创建一个HashSet对象
		hash.add("abc");hash.add("重地");hash.add("通话");	// 将这里面存放数据
		System.out.println(hash);
		

	}

}

运行结果：
1179395
1179395
96354
[重地, 通话, abc]

LinkedHashSet详解

  底层是由（ 哈希表 + 链表/红黑树 ）+ 链表 构成该集合由于是继承了HashSet因此HashSet拥有的它都有。唯一与HashSet集合不同的就是。该集合存储的数据和我存放时的数据不会产生位置差异。因为在它的基础之上后面添加了一个链表将他们串了起来。

代码模拟LinkedHashSet

import java.util.HashSet;
import java.util.LinkedHashSet;
public class Main {

	public static void main(String[] args) {
		
		String x = "重地";	// 1179395
		String y = "通话";	// 1179395
		String z = "abc";	// 96354
		System.out.println(x.hashCode());
		System.out.println(y.hashCode());
		System.out.println(z.hashCode());
		
		// HashSet模拟过程
		HashSet<String> hash = new HashSet<String>();		// 创建一个HashSet对象
		hash.add("abc");hash.add("重地");hash.add("通话");	// 将这里面存放数据
		System.out.println(hash);
		
		// HashSet模拟过程
		LinkedHashSet<String> linkedhash = new LinkedHashSet<String>();		// 创建一个HashSet对象
		linkedhash.add("abc");linkedhash.add("重地");linkedhash.add("通话");	// 将这里面存放数据
		System.out.println(linkedhash);

	}

}

运行结果：
1179395
1179395
96354
[重地, 通话, abc]
[abc, 重地, 通话]

总结Set集合

set集合最重要的两个点：

1. 使用hashcode()方法，判断两个数据哈希值是否相同，不同则存放，相同则往下执行
2. 使用equals()方法，判断两个数据内容是否相同，不同则通过链表连接，相同则覆盖
3. 如果某一个哈希值下面，数据超过了8个以上，自动转化为红黑树结构

因此，对于我们进行扩展，如果想要自定义对某个类型(利用泛型)进行存放，我们只需要重写这两个方法，也可以自己实现Set集合这些内容。

乱入Collections集合类

  此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。
  其中，最重要的一个方法也是最常用的，那就是排序方法。

返回值	方法	解释
void	sort(List list)	根据其元素的natural ordering对指定的列表进行排序，默认升序
void	sort(List list, Comparator<? super T> c)	根据指定的比较器引起的顺序对指定的列表进行排序
void	shuffle(List<?> list)	使用默认的随机源随机排列指定的列表

建议：

1. 由于大部分的时候都是需要自定义比较器进行排序。这个时候使用第二的一个sort()方法，并且sort()方法也不是一直使用，所以就使用匿名内部类即可。
2. 使用了第二个sort()方法，也就是使用到了匿名内部类就需要重写里面的compare()方法
   1. 升序排序：第一个参数(某个特征) — 第二个参数(某个特征)
   2. 降序排序：第二个参数(某个特征) — 第一个参数(某个特征)

例子：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;


public class Main {

	public static void main(String[] args) {
		
		ArrayList<Teacher> list = new ArrayList<Teacher>();
		
		list.add(new Teacher("王五", 23));
		list.add(new Teacher("李四", 23));
		list.add(new Teacher("张三", 22));
		
		// 先打印最开始，然后再开始排序
		System.out.println(list);

		// 使用匿名内部类进行排序
		/*
		 * 排序规则：
		 * 	1. 年龄小 --> 大
		 *  2. 如果不满第一步：比较String哈希值 
		 */
		Collections.sort(list, new Comparator<Teacher>() {
			@Override
			public int compare(Teacher o1, Teacher o2) {
				// TODO Auto-generated method stub

				if(o1.getAge() > o2.getAge())
					return o1.getAge() - o2.getAge();
				
				return o1.getName().hashCode() - o2.getName().hashCode();
				
				
			}
		});
		System.out.println(list);
	}

}

class Teacher {

	private String name;
	private int age;

	public Teacher() {
		super();
	}

	public Teacher(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Teacher [name=" + name + ", age=" + age + "]";
	}
	

}

运行结果：
[Teacher [name=王五, age=23], Teacher [name=李四, age=23], Teacher [name=张三, age=22]]
[Teacher [name=张三, age=22], Teacher [name=李四, age=23], Teacher [name=王五, age=23]]