先介绍下Java中的集合的概念
1.集合是JavaAPI所提供的一系列类，用来动态存放多个对象----集合只能存放对象
2.集合与数组的区别是，集合长度可变，且存放元素不受限定，主要是引用类型。
3.集合全部支持泛型，是一种数据安全的用法
集合框架图
集合分两大家族：
Collection(接口)家族：存放单一对象
Map(接口)家族：存放键值对(key,value)
先说Collection(接口)家族
Collection接口定义了存取对象的方法，它有两个很常用的子接口
List接口：存放的元素有序且重复
Set接口：存放的元素无序且唯一
List接口的两个重要实现类：ArrayList和LinkedList
这个不是我们要说的重点，就不多BB了，反正想用集合但不知道用什么集合，那就用ArrayList。
Set接口的两个重要实现类：HashSet和TreeSet
下面看看他们的具体存储原理：
图中简单模拟了下hash算法，即数字转为二进制后与一串特定的二进制序列相与，得到hashcode。
对！你也许已经发现了：
不同数字的hashcode可能是相同的，在图中也可以看到hashcode相同时，元素是以链表的形式存放在该位置的。
相同数字的hashcode必然相同，比较相同元素的过程被大大简化。
下面我们来检测下HashSet存放元素的唯一性
public class Test {
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
set.add(11);
set.add(22);
set.add(44);
set.add(11);
System.out.println(set);
//=======遍历1：基本for-无下标不能使用
//-----------增强for（实现原理就是迭代器）
System.out.println();
for(Integer a:set)
System.out.print(a+"-");
System.out.println();
//迭代器
Iterator<Integer> it = set.iterator();
while (it.hasNext()) {
System.out.print(it.next()+"-");
}
}
}
HashSet确实去掉了重复元素11
这里存放的是Integer类型对象，那么如果存放我们自己定义的对象呢？
定义一个Teacher类：
public class Teacher {
private String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Teacher [name=" + name + age+"]";
}
public Teacher() {
super();
// TODO Auto-generated constructor stub
}
public Teacher(String name, int age) {
super();
this.name = name;
this.age = age;
}
}
我们再来测试下：
public class Test2 {
public static void main(String[] args) {
Set<Teacher> set = new HashSet<>();
set.add(new Teacher("苍老师",18));
set.add(new Teacher("陈老师",18));
set.add(new Teacher("苍老师",18));
System.out.println(set);
}
}
输出结果：
这次输出了两个苍老师，HashSet居然没有去重。
这是为什么呢？
我们注释掉Teacher类中的toString方法，再看下输出
我们看下输出，可以发现输出的对象地址都是不同的（尽管存放的都是苍老师）
因为我们存放的元素是对象，而不同的对象其地址肯定是不同的，而hashcode也是用地址去计算的，不同地址计算出来的hashcode当然也不同。
那么问题来了，我们上面存放的Integer对象，为什么就没出现这样的问题呢？
我们看下Integer类的源码
public Integer(int value) {
this.value = value;
}
@Override
public int hashCode() {
return Integer.hashCode(value);
}
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
原来Integer类内部悄悄重写了hashcode和equals方法，改为用value值去获取hashcode和比较。
那么给我们的Teacher类也实现hashcode和equals方法吧。
但怎么实现呢，大佬可以参照源码实现的方式自己写。
懒人方法：eclipse已经给我们提供自动实现了，就和getter和setter方法一样，按下alt+shift+s,即可看到Generate hashCode() and equals()选项，一键点击即可在我们自己写的类里实现hashSet的去重功能。
再来测试下：
可以看到，我们终于去掉了重复的苍老师。
下面重点来了：
先了解下TreeSet的存储方式
由于TreeSet的存储特性，可知TreeSet存储特点是唯一且有序。
和前面一样，我们先来测试Java自定义的Integer类对象及TreeSet的遍历
public class Test {
public static void main(String[] args) {
Set<Integer> set = new TreeSet<>();
set.add(1);
set.add(3);
set.add(2);
set.add(1);//唯一
System.out.println(set);
//遍历也是不能用基本for
//可以进行增强for和迭代器遍历
System.out.println("===============");
for(Integer i:set){
System.out.println(i);
}
System.out.println("===============");
Iterator<Integer> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
输出：
可以看到TreeSet不仅实现了去重，还进行了升序排序。
那么将Integer类对象换为我们定义的Teacher对象呢
public class Test2 {
public static void main(String[] args) {
Set<Student> set = new TreeSet<>();
//ClassCastException: Student cannot be cast to Comparable
set.add(new Student("zs",20));
set.add(new Student("ls",30));
set.add(new Student("ww",20));
set.add(new Student("zs",80));
System.out.println(set);
}
}
这次不仅仅是无法去重排序了，直接报了个Bug。
那该如何解决呢？
和之前一样，看下Integer类源码
public final class Integer extends Number implements Comparable<Integer> {
public int compareTo(Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}
}
原来Integer类实现了Comparable接口里的compareTo方法，
compareTo是Comparable接口定义的方法，那么里面调用的compare方法又是什么呢？
由于Integer类连compare方法都重写了，那该如何查看compare方法源码呢
这里补充个知识点，HashSet和TreeSet都是调用Map家族下的HashMap和TreeMap中的方法来实现的，所以我们得去TreeMap中找compare源码
final int compare(Object k1, Object k2) {
return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
: comparator.compare((K)k1, (K)k2);
}
这是个三目运算，当comparator为空时，执行第一个表达式，否则执行第二个表达式。
即实现了comparator接口的话，就调用其compare方法实现比较大小；而未实现comparator接口就调用comparable接口的compareTo方法。
也就是说源码给我们提供了两种比较方法，一种是实现comparator接口，另一种是实现comparable接口，这也就是我们所说的比较器法和自然排序法。
自然排序法
方式1：自然排序法------》自定义类实现Comparable接口
public class Student implements Comparable{
private String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int compareTo(Student o) {
if(o.age==this.age)
return o.name.compareTo(this.name);//升序
//return o.name.compareTo(this.name);//降序
return o.age - this.age; //按年龄降序，相同则按名字首字母升序排列
}
}
方式2：比较器法------》自定义实现比较器comparator类
这里用匿名内部类实现：
//匿名内部类
Map<Student, Integer> map3 = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
if(o1.getName().equals(o2.getName()))
return o1.getAge()-o2.getAge();
return o1.getName().compareTo(o2.getName());
}
});
虽是TreeMap集合，但TreeSet与其除相差无几
Map集合中的HashMap、TreeMap与上面说的HashSet、TreeSet实现方式大致相同。
值得一提的就是Map集合的遍历了
//遍历
Set<String> set1 = map.keySet();
for(String a:set1){
System.out.println(a+" "+map.get(a));
}
System.out.println("============");
//键值对遍历
Set<Entry<String, Integer>> set = map.entrySet();
Iterator<Entry<String, Integer>> it = set.iterator();
while (it.hasNext()) {
Entry<String, Integer> entry = (Entry<String, Integer>) it.next();
System.out.println(entry.getKey()+"-->"+entry.getValue());
}
