Java基础-Collection之Set的实现
Collection体系：
|–List——特点：元素有序（指的是元素的存入和取出的顺序一致），元素可重复
–||–ArrayList——特点：底层是数组结构，查询快，增删慢；线程不同步，效率高
–||–Vector——特点：底层是数组结构，查询快，增删慢；线程同步，效率低（基本上已经被ArrayList替代）
–||–LinkedList——特点：底层是链表结构，增删快，查询慢；线程不同步，效率高
|–Set——特点：元素无序（指的是元素的存入和取出的顺序有可能不一致），元素唯一
–||–HashSet——特点：底层是哈希结构，线程不同步，无序，高效
–||–TreeSet——特点：底层是二叉树结构，线程不同步，可以对Set集合中的元素进行指定顺序的排序。（自然顺序或自定义排序）
前面已经学过了Collection体系中的List的实现子类了，今天将学习到的Set的实现子类以及一些重要的知识点总结一下
学习集合体系的标准：学习顶层，使用底层
在Set体系中，有两个实现子类：HashSet和TreeSet
首先，来学习一下Set这个顶层所具备的功能
通过查询API，我发现，Set体系中定义的功能完全和Collection中定义的功能一致，因此，就不在这里赘述了，直接使用：
学习Set集合无非是学习：
1、创建一个集合
2、创建元素对象
3、往集合里添加元素
4、遍历
A：迭代器
B：增强for
创建一个Set集合的方法，由于Set是一个接口，不能通过new来新建对象，我们可以通过下面三种方式来创建一个Set集合
// 创建集合对象
Collection<String> c = new HashSet<String>();
Set<String> set = new HashSet<String>();
HashSet<String> hs = new HashSet<String>();以上三种方法，都可以创建一个Set的集合
由于，set体系中的方法和Collection中定义的方法一样，那么我们现在直接来走一遍学习集合的流程
创建集合、创建元素、添加元素、遍历
代码如下：
public class SetDemo {
public static void main(String[] args) {
// 创建集合对象
Set set = new HashSet();
// 创建并添加元素
set.add("hello");
set.add("world");
set.add("java");
set.add("world");
// 迭代器遍历
Iterator it = set.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
System.out.println("--------------");
//增强for遍历
for (String s : set) {
System.out.println(s);
}
}
} 结果：
从结果可以看出，1、我们存储元素的顺序和取出来的顺序是不同的，这就印证了Set体系中的集合的元素是无序的
2、在程序中，我们添加了两个“world”字符串，但是在遍历的时候却没有两个“world”，这印证了Set集合中的元
素是唯一的。后面学习的HashSet和TreeSet会详细分析保证元素唯一是如何实现的。
HashSet是Set体系中的一个子实现类
特点：特点：底层是哈希结构，线程不同步，无序，高效
HashSet集合保证元素唯一性：通过元素的hashCode方法，和equals方法完成的。
当元素的hashCode值相同时，才继续判断元素的equals是否为true。
如果为true，那么视为相同元素，不存。如果为false，那么存储。
如果hashCode值不同，那么不判断equals，从而提高对象比较的速度。
HashSet存储字符串并遍历
public class HashSetDemo {
public static void main(String[] args) {
// 创建集合对象
HashSet hs = new HashSet();
// 创建并添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("java");
// 遍历
for (String s : hs) {
System.out.println(s);
}
}
} 结果：
分析：
在HashSet中添加了两个“java”元素，但是输出来只有1个，是因为String类实现了hashCode（）和equals（）方法。
那么，现在问题来了，当我们要存储自定义的对象时，该如何保证HashSet中元素的唯一性呢？
我们都知道，当我们new出来多个对象时，往HashSet中添加时，每个对象的地址值都是不同的，那么就算我们有两个属性一模一样
的对象，HashSet仍然认为是两个不同的对象，但是现实生活中，我们就认为这是同一个对象，其中一个不应该添加进HashSet集合中。
图解HashSet保证元素唯一性：
上面我们说过，在HashSet里面，是通过元素（也就是我们现在的对象）hashCode（）和equals（）方法来保证元素的唯一性。那么我们该如何来实现这两个方法呢？
通过观看原码，我们发现这是一个相当复杂的过程，但是IDE给我们提供了最大的方便，可以一键生成hashCode（）和equals（）方法。在开发中，我们只需要自动生成就好了。
那么现在，我们现在来看一下，在没有实现这两个方法的时候，HashSet是不能保证元素唯一的情况
Student.java
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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;
}
}
HashSetDemo.java
public class HashSetDemo2 {
public static void main(String[] args) {
// 创建集合对象
HashSet hs = new HashSet();
// 创建元素对象
Student s1 = new Student("林青霞", 26);
Student s2 = new Student("张曼玉", 36);
Student s3 = new Student("周慧敏", 20);
Student s4 = new Student("林青霞", 26);
Student s5 = new Student("林青霞", 66);
Student s6 = new Student("林志玲", 16);
// 添加元素
hs.add(s1);
// hs.add(s1);
hs.add(s2);
hs.add(s3);
hs.add(s4);
hs.add(s5);
hs.add(s6);
// 遍历
for (Student s : hs) {
System.out.println(s.getName() + "***" + s.getAge());
}
}
} 结果：
分析：
这里标红的两个元素，在我们看来就属于同一个对象，但是HashSet并没能识别出来，是因为在Student类里面，没有实现hashCode（）和equls（）方法。
下面我们改进一下代码，让HashSet在存储我们自定义对象的时候，能识别出来
改进版Student.java代码
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 int hashCode() {
// // return 0;
// /*
// * name:30,age:40
// * name:20,age:50
// */
// return this.name.hashCode() + this.age*13;
// }
//
// @Override
// public boolean equals(Object obj) {
// // System.out.println(this + "------------------------------" + obj);
// if (this == obj) {
// return true;
// }
//
// if (!(obj instanceof Student)) {
// return false;
// }
//
// Student s = (Student) obj;
// return this.name.equals(s.name) && this.age == s.age;
// }
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.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 (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}结果：
分析：
由于在Student类中，我们实现了hashCode（）和equals（）方法，那么在属性一样的Student对象情况下，只能添加一个。
学习完HashSet后，我们来学习一下TreeSet
TreeSet 最大的特点是可以对集合中的元素进行自然顺序的（字典顺序）或者自定义方式 排序。同时还保证元素的唯一性
图解TreeSet保证元素唯一性：
下面来重点讲解TreeSet实现对元素排序的两种方式：（这里主要是针对自定义对象的排序）
方式一：自定义所在的类实现Comparable接口，并且重写CompareTo方法。
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
方式二：比较器的使用。Comparator接口。这里有两种使用方法：1、自定义一个比较器，实现Comparator接口，重写其中的compare（）
方法；2、直接使用TreeSet的带参构造方法，并且在参数位置使用Comparator的一个自实现类，即匿名内部类。
先来学习下，TreeSet对String类型数据保持唯一性和排序的例子：
代码：
import java.util.TreeSet;
/*
* TreeSet可以对元素进行排序。
* 使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
*/
public class TreeSetDemo {
public static void main(String[] args) {
// 创建集合对象
TreeSet ts = new TreeSet();
// 创建并添加元素
ts.add("hello");
ts.add("world");
ts.add("java");
ts.add("abcde");
ts.add("zone");
ts.add("world");
// 遍历
for (String str : ts) {
System.out.println(str);
}
}
}
结果：
分析：
1、元素输出的顺序和我们传入的顺序不一致，而且是按照一定的顺序来输出，是因为在存入的时候，就按照了自然顺序存入；
2、代码中，添加了两个“world”元素，但是只有一个被输出来，是因为第二个没有被添加进去。是如何实现的呢？
是因为在String类中，实现了Camparable接口，并且重写了compareTo方法。
这一点可以从原码中看出来
现在，我们要实现TreeSet存储自定义对象时，也保证元素唯一和排序
国际惯例：先看一下错误的示范：（对象所在的类，既没有实现Comparable接口，在创建TreeSet是，也没有使用带参构造方法，并且传入
Comparatoe的匿名内部类）
Student.java代码
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 int compareTo(Student s) {
// // 需求是比较年龄
// int num = this.age - s.age;
// // 由于对象有多个成员变量，你不能根据其中的某一个决定其他的。
// // 当某一个相同的时候，你还需要判断其他的是不是也是相同的。
// int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;
// return num2;
// }
// 需求:我想按照姓名的长度排序，从小到大排序。怎么做?
// @Override
// public int compareTo(Student s) {
// // 姓名的长度
// int num = this.name.length() - s.name.length();
//// System.out.println(num);
// // 很多时候，别人给我们的需求其实只是一个主要需要
// // 还有很多的次要需求是需要我们自己进行分析的。
// // 比较姓名的内容
// int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;
// // 继续分析，姓名长度和内容都相同的情况下，年龄还可能不一样呢?
// // 所以，当姓名长度和内容都相同的时候，我们在比较下年龄就好了
// int num3 = (num2 == 0) ? (this.age - s.age) : num2;
// return num3;
// }
}
TreeSetDemo2.java代码
public class TreeSetDemo2 {
public static void main(String[] args) {
// 创建集合对象
TreeSet ts = new TreeSet();
// 创建元素对象
Student s1 = new Student("liudehua", 52);
Student s2 = new Student("chenglong", 60);
Student s3 = new Student("zhouxinchi", 44);
Student s4 = new Student("sunyanzi", 34);
Student s5 = new Student("linqingxia", 26);
Student s6 = new Student("linqingxia", 36);
Student s7 = new Student("linqing", 26);
Student s8 = new Student("linqingxia", 26);
// 添加元素
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
ts.add(s7);
ts.add(s8);
// 遍历
for (Student s : ts) {
System.out.println(s.getName() + "***" + s.getAge());
}
}
}
结果：
分析：
1、ClassCastException：类类型转换异常。这个异常，我们在继承的时候遇到过，发生的原因主要是，两个没有继承或者实现关系
的类进行类型转换。这里也一样，因为Student没有实现Comparable接口。
下面让Student实现Comparable接口，并且重写compareTo方法
Student.java代码
public class Student implements Comparable {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 int compareTo(Student s) {
// // 需求是比较年龄
// int num = this.age - s.age;
// // 由于对象有多个成员变量，你不能根据其中的某一个决定其他的。
// // 当某一个相同的时候，你还需要判断其他的是不是也是相同的。
// int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;
// return num2;
// }
// 需求:我想按照姓名的长度排序，从小到大排序。怎么做?
@Override
public int compareTo(Student s) {
// 姓名的长度
int num = this.name.length() - s.name.length();
// System.out.println(num);
// 很多时候，别人给我们的需求其实只是一个主要需要
// 还有很多的次要需求是需要我们自己进行分析的。
// 比较姓名的内容
int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;
// 继续分析，姓名长度和内容都相同的情况下，年龄还可能不一样呢?
// 所以，当姓名长度和内容都相同的时候，我们在比较下年龄就好了
int num3 = (num2 == 0) ? (this.age - s.age) : num2;
return num3;
}
}
TreeSetDemo2.java代码不变
结果：
分析：
1、结果中，数据实现了排序，也保证了元素的唯一性。主要规则，在compareTo（）方法中。
我们可以在该方法中，定义属于具体需要的具体规则。如按年龄大小，按名字长短等等。
下面，我用匿名内部类的方式，实现同样的功能。这次，Student类就不需要实现Comparable接口了
开发中，推荐使用该方法，因为，开发中有一个原则，对修改关闭，对实现开放。怎么理解呢？就是说在我们的具体类中，定义好就尽量不要
改动，因为可能这个类与其他若干个类有各种关系，修改了一个地方，可能影响到其他类的功能。
Student.java代码
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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;
}
}
TreeSetDemo2.java代码
/*
* 比较器接口 Comparator。带参构造。
*
* 开发原则：
* 对修改关闭，对扩展开放。
*/
public class TreeSetDemo {
public static void main(String[] args) {
// 创建集合对象
// public TreeSet(Comparator comparator)
// Comparator c = new MyComparator();
// TreeSet ts = new TreeSet(c);
// 两句写一句
// TreeSet ts = new TreeSet(new MyComparator());
// 匿名内部类
TreeSet ts = new TreeSet(new Comparator() {
@Override
public int compare(Student s1, Student s2) {
// 按年龄排序，从小到大
int num = s1.getAge() - s2.getAge();
// 次要条件
int num2 = (num == 0) ? (s1.getName().compareTo(s2.getName())) : num;
return num2;
}
});
// 创建元素对象
Student s1 = new Student("liudehua", 52);
Student s2 = new Student("chenglong", 60);
Student s3 = new Student("zhouxinchi", 44);
Student s4 = new Student("sunyanzi", 34);
Student s5 = new Student("linqingxia", 26);
Student s6 = new Student("linqingxia", 36);
Student s7 = new Student("linqing", 26);
Student s8 = new Student("linqingxia", 26);
// 添加元素
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
ts.add(s7);
ts.add(s8);
// 遍历
for (Student s : ts) {
System.out.println(s.getName() + "***" + s.getAge());
}
}
}
结果：
分析：
1、这样做可以实现同样的功能。
2、需要理解匿名内部类的使用。
Collection和Collections
区别：（面试题）
Collection:是Collection集合的顶层接口，定义了Collection集合的共性方法。
Collections:是一个类，定义了针对Collection集合操作的功能。有排序，查找，反转等。
Collections的功能：
排序：public static void sort(List list)
二分查找：public static int binarySearch(List list,T key)
反转：public static void reverse(List list)
最大值：public static T max(Collection coll)
随机置换：public static void shuffle(List list)
马上使用之：
代码：
public class CollectionsDemo {
public static void main(String[] args) {
// 创建集合对象
ArrayList array = new ArrayList();
// 添加元素
array.add(60);
array.add(25);
array.add(38);
array.add(213);
array.add(99);
array.add(22);
System.out.println("array:" + array);
// 排序
// public static void sort(List list)
// Collections.sort(array);
// System.out.println("array:" + array);
// 二分查找
// public static int binarySearch(List list,T key)
// [22, 25, 38, 60, 99, 213]
// int index = Collections.binarySearch(array, 60);
// System.out.println("index:" + index);
// 反转
// public static void reverse(List list)
// [60, 25, 38, 213, 99, 22]
// Collections.reverse(array);
// System.out.println("array:" + array);
// 最大值
// public static T max(Collection coll)
// Integer i = Collections.max(array);
// System.out.println(i);
// 随机置换：public static void shuffle(List list)
Collections.shuffle(array);
System.out.println("array:" + array);
}
}
有了Collections的随机置换功能，我们可以模拟一下斗地主发牌的功能
代码
/*
* 斗地主：
* 模拟斗地主发牌
*
* 思路：
* 买牌
* 黑桃A、2、 3、 4、 5、 6、 7、 8、 9、 J、 Q、 K
* 红桃A、2、 3、 4、 5、 6、 7、 8、 9、 J、 Q、 K
* 梅花A、2、 3、 4、 5、 6、 7、 8、 9、 J、 Q、 K
* 方块A、2、 3、 4、 5、 6、 7、 8、 9、 J、 Q、 K
* 大王、小王
* 洗牌
* 利用Collections 的随机置换方法
* 发牌
* 发给3个人
* 看牌
* 留三张
*/
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
public class DouDiZhu {
public static void main(String[] args) {
// 创建一个数组,表示花色
String[] colors = { "黑桃", "红桃", "梅花", "方块" };
// 创建一个表示数字的数组
String[] number = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
// 造一个牌盒
ArrayList array = new ArrayList();
// 想把大小王装进去
array.add("大王");
array.add("小王");
// 增强for循环装牌
for (String c : colors) {
for (String n : number) {
// 组合牌
String s = c + n;
// 装牌
array.add(s);
}
}
// 打印一下牌
// System.out.print(array);
// 洗牌
Collections.shuffle(array);
// 打印一下洗牌后的牌
// System.out.print(array);
// 发牌,3个人,定义3个集合
ArrayList weiweiList = new ArrayList();
ArrayList minminList = new ArrayList();
ArrayList guangtouList = new ArrayList();
// 循环发牌,由于需要留三张牌,所以只能循环到array.size()-3
for (int x = 0; x < array.size()-3; x++) {
// 轮着发三张
if (x % 3 == 0) {
// 给第一个人发牌
weiweiList.add(array.get(x));
} else if (x % 3 == 1) {
// 给第二个人发牌
minminList.add(array.get(x));
} else if (x % 3 == 2) {
// 给第三个人发牌
guangtouList.add(array.get(x));
}
}
// 打印一下三个人手上的牌
System.out.println("weiweiList " + weiweiList);
System.out.println("minminList " + minminList);
System.out.println("guangtouList " + guangtouList);
//看底牌
//由于前面发牌的动作只到集合的size()-3,所以剩下三张
//这三张牌,使用ArrayList的get(index)方法获取,那么下标应该从array.size()-3开始,到array.size()
System.out.println("底牌是: ");
for(int x=array.size()-3; x//打印底牌出来
System.out.print(array.get(x)+ " ");
}
System.out.println("要叫地主吗?");
}
}
结果：
不分析了，大家看看哪一家会赢！！！