回顾问题:

上一期我们讲了list集合，它的一个显著特点就是读取速度快，元素可重复，可以自动扩容！！！有一个问题，在上一期中，我们使用foreach去删除元素是会发现在两个相邻的同一样的元素中会发生执行错误，如果我们没有重复相邻的两个元素，再去删除，还是会有问题，但我们如果刚好删除的是倒数第二个元素，就可以正常删除，这是为什么呢，我们一起来看看。

下面的图都为源码：

大家首先看到这里的这个方法，在使用list进行foreach进行删除的时候我们就会进入到这里来，然后进行删除，那具体是怎么样的呢，其实在使用foreach进行删除的时候是调用的一个iterator来进行的，这个迭代器就是我们的array list的内部类中的iterator，它进入到这里之后会调用hasnext方法进行cursor进行一个和集合元素的长度进行比较，如果不相等就还有元素，然后接着往下走，调用next方法先去进行一个检查维护，那这个modCount是什么呢，它其实是我们的集合的大小，当我们集合元素大小发生变化是就会更着改变，例如，如果集合原本大小为5，此时插入一个元素，就变成了6.modCount也变成了6，减少一个变成4，modCount也变成了4。所以我们就会发现，在我们用foreach进行list的删除时这个检查约束过不不了就直接抛出异常了，而为什么倒数第二可以呢，以为删除它就变成倒数第一了，来不及检查约束就已经删除了，其实这也时一个特性，但它本质是一个bug。

检查方法

Set集合

特点：

1. 特点：无序，不重复

2. 遍历：foreach，迭代器

3.  扩容： 初始容量16，负载因子0.75，扩容增量1倍

 实现类

HashSet

特点：

1.它存储唯一元素并允许空值，依据对象的hashcode来确定该元素是否存在

2. 由HashMap支持

3. 不保持插入顺序

4. 非线程安全

5. 性能参数：初始容量，负载因子，默认值： 初始容量16，负载因子0.75，示例：new HashSet<>(20, 0.5f);

实例

 
	List<Integer> list = new ArrayList<Integer>();
	private Set<Integer> set = new HashSet<Integer>();
 
	@Before
	public void setup() {
		list.add(1);
		list.add(4);
		list.add(4);
		list.add(8);
		list.add(8);
		list.add(12);
		list.add(16);
 
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(3);
		set.add(4);
		set.add(4);
		set.add(5);
 
	}
 
	@Test
	public void setdome01() {
		List<Integer> temp = new ArrayList<Integer>(new HashSet<Integer>(list));
		System.out.println(temp);
		// 结果:[16，1，4，8，12],hashset直接帮我们去重复了，因为set集合不可以出现重复的
		// 除了这种方法还有list的迭代器的去重复，还有最为死的for遍历，一个一个做判断删除
 
	}
 
//	HashSet其实就是一个皮包公司，都是委托
	@Test
	public void setdome02() {
		for (Integer ui : set) {
			System.out.println(ui);
		}
//		结果：12345；
//		可以看到，去重复和排序了
	}
 
	@Test
	public void setdome03() {
		Iterator<Integer> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
//			结果：12345
	}
//	可以看到，我们插入的到顺序是无序的，但我们输出的却是有序的，而set是无序的，
//	那为什么输出的有序呢，那是因为set的无序指的是插入的顺序是无序 ，而这的有序
//	是因为hashset的有序，我们常说的有序是指插入的顺序是有序的

TreeSet

1. 是一个包含有序的且没有重复元素的集合

2. 作用是提供有序的Set集合，自然排序或者根据提供的Comparator进行排序

3. TreeSet是基于TreeMap实现的

比较器

1.默认自然排序

1. 默认自然排序
   数据准备
 
 ts = new TreeSet<>();
		ts.add(1);
		ts.add(8);
		ts.add(7);
		ts.add(2);
		ts.add(4);
		ts.add(6);
		ts.add(3);
 
 
@Test
	public void setdome04() {
		Set<Student> set = new HashSet<Student>();
		set.add(new Student(1, "张三", 18));
		set.add(new Student(2, "李四", 19));
		set.add(new Student(3, "李凝", 20));
		set.add(new Student(4, "王三", 21));
		set.add(new Student(4, "王三", 21));
		set.add(new Student(5,"二虎",26));
 
		for (Student student : set) {
			System.out.println(student);
		}
 
	}

2.自定义排序

--1. 较器通过构造函数传入比

1. 较器通过构造函数传入比
TreeSet<Integer> tset = new TreeSet<Integer>(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o2 - o1;
			}
		});

2. 2. 实现排序接口

public class Student implements Comparable<Student>{
	
	private Integer sid;
	
	private String name;
	
	private int age;
 
	
	@Override
	public int compareTo(Student o) {
		// TODO Auto-generated method stub
		return o.getAge() - this.getAge();
	}
 
}
 
 
 
Student实体类
 
package com.zking.test;
 
public class Student implements Comparable<Student> {
 
	private Integer sid;
 
	private String sname;
 
	private int age;
 
	public Student(Integer sid, String sname, int age) {
		super();
		this.sid = sid;
		this.sname = sname;
		this.age = age;
	}
 
	public Integer getSid() {
		return sid;
	}
 
	public void setSid(Integer sid) {
		this.sid = sid;
	}
 
	public String getSname() {
		return sname;
	}
 
	public void setSname(String sname) {
		this.sname = sname;
	}
 
	public int getAge() {
		return age;
	}
 
	public void setAge(int age) {
		this.age = age;
	}
 
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((sid == null) ? 0 : sid.hashCode());
		result = prime * result + ((sname == null) ? 0 : sname.hashCode());
		return result;
	}
 
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (sid == null) {
			if (other.sid != null)
				return false;
		} else if (!sid.equals(other.sid))
			return false;
		if (sname == null) {
			if (other.sname != null)
				return false;
		} else if (!sname.equals(other.sname))
			return false;
		return true;
	}
 
	@Override
	public String toString() {
		return "Student [sid=" + sid + ", sname=" + sname + ", age=" + age + "]";
	}
 
	@Override
	public int compareTo(Student o) {
		if (this.getAge() - o.getAge() == 0) {
			return this.getSid() - o.getSid();
		}
		return this.getAge() - o.getAge();
	}
 
}

总结:

set集合元素无放入顺序，且不可重复（注意：元素虽然无放入顺序，但是元素在Set中的位置是由该元素的HashCode决定的，其位置是固定的）。List支持for循环，也就是通过下标来遍历，也可以用迭代器，但是Set只能用迭代器，因为他无序，无法使用下标取值；Set：检索元素效率低，删除和插入效率高，插入和删除不会引起元素位置改变。