=============================================================================
=============================================================================
涉及到的知识点有：
1:用户登录注册案例(集合版)(理解)
2:Set集合(理解)
(1)Set集合的特点
(2)HashSet集合(掌握)
(3)TreeSet集合(理解)
(4)案例
3:Collection集合总结(掌握)
4:针对Collection集合我们到底使用谁呢？(掌握)
5:在集合中常见的数据结构(掌握)
=============================================================================
=============================================================================
1:用户登录注册案例(集合版)(理解)
-----------------------------------------------------------------------------
2:Set集合(理解)
(1)Set集合的特点
无序:存和取的顺序不一致,无索引,不可以存储重复元素(唯一)
---------------------------------------
(2)HashSet集合(掌握)
A:底层的数据结构是哈希表(是一个元素为链表的数组)
![]()
B:哈希表底层依赖两个方法：hashCode()和equals()
执行顺序：
首先比较哈希值是否相同
相同：继续执行equals()方法
返回true：元素重复了，不添加
返回false：直接把元素添加到集合
不相同：就直接把元素添加到集合
C:如何保证元素唯一性的呢?
由hashCode()和equals()保证的。
即：int hashCode()
boolean equals(Object obj)
D:开发的时候，代码非常的简单，自动生成即可。
E:案例
1.HashSet存储字符串并遍历(注意：字符串默认重写了hasCode()和equals()方法)
2.HashSet存储自定义对象并遍历(对象的成员变量值都相同即为同一个元素)
F:LinkedHashSet：底层的数据结构由哈希表和链表组成。
哈希表保证元素的唯一性。
链表保证元素有序。(存储和取出顺序一致)
注意事项：
1.一般来说，不同的字符串的哈希值是不同的。
哈希值仅仅是逻辑值，可能一样。
地址值是实际的物理值，不一样。
2.HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，
而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。
---------------------------------------
(3)TreeSet集合(理解)
A:底层数据结构是红黑树(是一个自平衡的二叉树)(自平衡:说明其结构不会太深)
![]()
B:保证元素的排序方式(具体那种方式取决于使用TreeSet的构造方法)
a:自然排序(元素具备比较性)
让元素所属的类实现自然排序 Comparable接口。
示例代码如下：
![]()
![]()
1 package cn.itcast_06;
2
3 /*
4 * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口，然后重写compareTo()方法
5 */
6 public class Student implements Comparable<Student>{
7 private String name;
8 private int age;
9
10 public Student() {
11 super();
12 }
13
14 public Student(String name, int age) {
15 super();
16 this.name = name;
17 this.age = age;
18 }
19
20 public String getName() {
21 return name;
22 }
23
24 public void setName(String name) {
25 this.name = name;
26 }
27
28 public int getAge() {
29 return age;
30 }
31
32 public void setAge(int age) {
33 this.age = age;
34 }
35
36 @Override
37 public int compareTo(Student s) {
38 // 主要条件：姓名的长度
39 int num = this.name.length() - s.name.length();
40 // 次要条件1：姓名的长度相同，不代表姓名的内容相同
41 int num2 = (num == 0 ? this.name.compareTo(s.name) : num);
42 // 次要条件2：姓名的长度和内容相同，不代表年龄也相同，所以还得继续比较年龄
43 int num3 = (num2 == 0 ? this.age - s.age : num2);
44 return num3;
45 }
46
47 }
Student.java
![]()
![]()
1 package cn.itcast_06;
2
3 import java.util.TreeSet;
4
5 /*
6 * TreeSet存储自定义对象并保证排序和唯一
7 *
8 * 需求：请按照姓名的长度排序。
9 *
10 * TreeSet集合保证元素排序和唯一性的原理：
11 * 唯一性：是根据比较的返回是否是0来决定。
12 * 排序：
13 * A:自然排序(元素具备比较性)
14 * 让元素所属的类实现自然排序 Comparable接口。
15 * B:比较器排序(集合具备比较性)
16 * 让集合的构造方法接收一个比较器接口 Comparator的实现类对象，一般用匿名内部类实现。
17 */
18 public class TreeSetDemo {
19 public static void main(String[] args) {
20 // 创建集合对象
21 // TreeSet的构造方法：public TreeSet() // 自然排序
22 TreeSet<Student> ts = new TreeSet<Student>();
23
24 // 创建元素对象
25 Student s1 = new Student("linqingxia", 27);
26 Student s2 = new Student("zhangguorong", 29);
27 Student s3 = new Student("wanglihong", 23);
28 Student s4 = new Student("linqingxia", 27);
29 Student s5 = new Student("liushishi", 22);
30 Student s6 = new Student("wuqilong", 40);
31 Student s7 = new Student("fengqingy", 22);
32 Student s8 = new Student("linqingxia", 29);
33
34 // 添加元素到集合
35 ts.add(s1);
36 ts.add(s2);
37 ts.add(s3);
38 ts.add(s4);
39 ts.add(s5);
40 ts.add(s6);
41 ts.add(s7);
42 ts.add(s8);
43
44 // 遍历集合
45 for (Student s : ts) {
46 System.out.println(s.getName() + "---" + s.getAge());
47 }
48 }
49 }
TreeSetDemo.java
b:比较器排序(集合具备比较性)
让集合的构造方法接收一个比较器接口 Comparator的实现类对象，一般用匿名内部类实现。
示例代码如下：
（1）用自己新建的实现类实现
![]()
![]()
1 package cn.itcast_07;
2
3 /*
4 * 如果一个类的元素要想能够进行比较器排序。
5 */
6 public class Student {
7 private String name;
8 private int age;
9
10 public Student() {
11 super();
12 }
13
14 public Student(String name, int age) {
15 super();
16 this.name = name;
17 this.age = age;
18 }
19
20 public String getName() {
21 return name;
22 }
23
24 public void setName(String name) {
25 this.name = name;
26 }
27
28 public int getAge() {
29 return age;
30 }
31
32 public void setAge(int age) {
33 this.age = age;
34 }
35
36 }
Student.java
![]()
![]()
1 package cn.itcast_07;
2
3 import java.util.Comparator;
4
5 public class MyComparator implements Comparator<Student> {
6
7 @Override
8 public int compare(Student s1, Student s2) {
9 // return 0;
10
11 // 需求：请按照姓名的长度排序
12 // int num = this.name.length() - s.name.length();
13 // this --> s1 // s1不能直接访问name，因为s1是在MyComparator类中，而name是在Student类中，要想访问，需要通过getXxx()方法
14 // s --> s2
15
16 // 姓名长度
17 int num = s1.getName().length() - s2.getName().length();
18 // 姓名内容
19 int num2 = (num == 0 ? s1.getName().compareTo(s2.getName()) : num);
20 // 年龄
21 int num3 = (num2 == 0 ? s1.getAge() - s2.getAge() : num2);
22 return num3;
23 }
24
25 }
MyComparator.java
![]()
![]()
1 package cn.itcast_07;
2
3 import java.util.TreeSet;
4
5 /*
6 * 需求：请按照姓名的长度排序
7 *
8 * TreeSet集合保证元素排序和唯一性的原理：
9 * 唯一性：是根据比较的返回是否是0来决定。
10 * 排序：
11 * A:自然排序(元素具备比较性)
12 * 让元素所属的类实现自然排序 Comparable接口。
13 * B:比较器排序(集合具备比较性)
14 * 让集合的构造方法接收一个比较器接口 Comparator的实现类对象，一般用匿名内部类实现。
15 */
16 public class TreeSetDemo {
17 public static void main(String[] args) {
18 // 创建集合对象
19 // TreeSet的构造方法：public TreeSet(Comparator<? super E> comparator) // 比较器排序，传递的数据类型是引用数据类型中的接口，说明传递的是实现类对象
20 TreeSet<Student> ts = new TreeSet<Student>(new MyComparator()); // 示例：自己写了个具体实现类MyMyComparator，并重写compare()方法
21
22 // 创建元素对象
23 Student s1 = new Student("linqingxia", 27);
24 Student s2 = new Student("zhangguorong", 29);
25 Student s3 = new Student("wanglihong", 23);
26 Student s4 = new Student("linqingxia", 27);
27 Student s5 = new Student("liushishi", 22);
28 Student s6 = new Student("wuqilong", 40);
29 Student s7 = new Student("fengqingy", 22);
30 Student s8 = new Student("linqingxia", 29);
31
32 // 添加元素到集合
33 ts.add(s1);
34 ts.add(s2);
35 ts.add(s3);
36 ts.add(s4);
37 ts.add(s5);
38 ts.add(s6);
39 ts.add(s7);
40 ts.add(s8);
41
42 // 遍历集合
43 for (Student s : ts) {
44 System.out.println(s.getName() + "---" + s.getAge());
45 }
46 }
47 }
TreeSetDemo.java
（2）用用匿名内部类实现
![]()
![]()
1 package cn.itcast_07;
2
3 /*
4 * 如果一个类的元素要想能够进行比较器排序。
5 */
6 public class Student {
7 private String name;
8 private int age;
9
10 public Student() {
11 super();
12 }
13
14 public Student(String name, int age) {
15 super();
16 this.name = name;
17 this.age = age;
18 }
19
20 public String getName() {
21 return name;
22 }
23
24 public void setName(String name) {
25 this.name = name;
26 }
27
28 public int getAge() {
29 return age;
30 }
31
32 public void setAge(int age) {
33 this.age = age;
34 }
35
36 }
Student.java
![]()
![]()
1 package cn.itcast_07;
2
3 import java.util.Comparator;
4 import java.util.TreeSet;
5
6 /*
7 * 需求：请按照姓名的长度排序
8 *
9 * TreeSet集合保证元素排序和唯一性的原理：
10 * 唯一性：是根据比较的返回是否是0来决定。
11 * 排序：
12 * A:自然排序(元素具备比较性)
13 * 让元素所属的类实现自然排序 Comparable接口。
14 * B:比较器排序(集合具备比较性)
15 * 让集合的构造方法接收一个比较器接口 Comparator的实现类对象，一般用匿名内部类实现。
16 */
17 public class TreeSetDemo {
18 public static void main(String[] args) {
19 // 创建集合对象
20 // TreeSet的构造方法：public TreeSet() // 自然排序
21 // TreeSet<Student> ts = new TreeSet<Student>();
22
23 // TreeSet的构造方法：public TreeSet(Comparator<? super E> comparator) // 比较器排序，传递的数据类型是引用数据类型中的接口，说明传递的是实现类对象
24 // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator()); // 示例：自己写了个具体实现类MyComparator，并重写compare()方法
25
26 // 如果一个方法的参数是接口，那么真正需要的是接口的实现类的对象，而且该方法只调用一次。
27 // 所以使用匿名内部类就可以实现这个东西，这样就不用自己去重新写一个具体的实现类了。其实这种方式是很常见的。
28 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
29 @Override
30 public int compare(Student s1, Student s2) {
31 // 姓名长度
32 int num = s1.getName().length() - s2.getName().length();
33 // 姓名内容
34 int num2 = (num == 0 ? s1.getName().compareTo(s2.getName()) : num);
35 // 年龄
36 int num3 = (num2 == 0 ? s1.getAge() - s2.getAge() : num2);
37 return num3;
38 }
39 });
40
41 // 创建元素对象
42 Student s1 = new Student("linqingxia", 27);
43 Student s2 = new Student("zhangguorong", 29);
44 Student s3 = new Student("wanglihong", 23);
45 Student s4 = new Student("linqingxia", 27);
46 Student s5 = new Student("liushishi", 22);
47 Student s6 = new Student("wuqilong", 40);
48 Student s7 = new Student("fengqingy", 22);
49 Student s8 = new Student("linqingxia", 29);
50
51 // 添加元素到集合
52 ts.add(s1);
53 ts.add(s2);
54 ts.add(s3);
55 ts.add(s4);
56 ts.add(s5);
57 ts.add(s6);
58 ts.add(s7);
59 ts.add(s8);
60
61 // 遍历集合
62 for (Student s : ts) {
63 System.out.println(s.getName() + "---" + s.getAge());
64 }
65 }
66 }
TreeSetDemo.java
C:把我们讲过的代码看一遍即可
(4)案例
A:编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
1.用集合HashSet实现
![]()
![]()
1 package cn.itcast_08;
2
3 import java.util.HashSet;
4 import java.util.Random;
5
6 /*
7 * 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
8 *
9 * 分析：
10 * A:创建随机数对象
11 * B:创建一个HashSet集合
12 * C:判断集合的长度是不是小于10，因为Integer包装类默认实现了Comparable接口，所以Integer类能自动判断是否有重复元素
13 * 是：就创建一个随机数添加
14 * 否：不搭理它
15 * D:遍历HashSet集合
16 */
17 public class HashSetDemo {
18 public static void main(String[] args) {
19 // 创建随机数对象
20 Random r = new Random();
21
22 // 创建一个HashSet集合
23 HashSet<Integer> hs = new HashSet<Integer>();
24
25 // 判断集合的长度是不是小于10，因为Integer包装类默认实现了Comparable接口，所以Integer类能自动判断是否有重复元素
26 while (hs.size() < 10) {
27 int num = r.nextInt(20) + 1;
28 hs.add(num);
29 }
30
31 // 遍历HashSet集合
32 for (Integer i : hs) {
33 System.out.println(i);
34 }
35 }
36 }
HashSetDemo.java
2.用集合ArrayList实现
![]()
![]()
1 package cn.itcast_02;
2
3 import java.util.ArrayList;
4 import java.util.Random;
5
6 /*
7 * 获取10个1-20之间的随机数，要求不能重复
8 *
9 * 用数组实现，但是数组的长度是固定的。
10 * 长度不好确定，所以我们使用集合实现。
11 *
12 * 分析：
13 * A:创建产生随机数的对象。
14 * B:创建一个存储随机数的集合ArrayList。
15 * C:定义一个统计变量。从0开始。
16 * D:判断统计遍历是否小于10
17 * 是:产生一个随机数，判断该随机数在集合中是否存在。
18 * 如果不存在:就添加，统计变量++。
19 * 如果存在:就不搭理它。
20 * 否：不搭理它
21 * E:遍历ArrayList集合
22 */
23 public class ArrayListDemo {
24 public static void main(String[] args) {
25 // 创建产生随机数的对象。
26 Random r = new Random();
27
28 // 创建一个存储随机数的集合。
29 ArrayList<Integer> array = new ArrayList<Integer>();
30
31 // 定义一个统计变量。从0开始。
32 int count = 0;
33
34 // 判断统计遍历是否小于10
35 while (count < 10) {
36 // 产生一个随机数
37 int number = r.nextInt(20) + 1;
38
39 // 判断该随机数在集合中是否存在。
40 if (!array.contains(number)) {
41 // 如果不存在:就添加，统计变量++。
42 array.add(number);
43 count++;
44 }
45 }
46
47 // 遍历集合
48 for (Integer i : array) {
49 System.out.println(i);
50 }
51 }
52 }
ArrayListDemo.java
B:键盘录入5个学生信息(姓名、语文成绩、数学成绩、英语成绩)，按照总分从高到低输出到控制台。
![]()
![]()
1 package cn.itcast_09;
2
3 public class Student {
4 // 姓名
5 private String name;
6 // 语文成绩
7 private int chinese;
8 // 数学成绩
9 private int math;
10 // 英语成绩
11 private int english;
12
13 public Student() {
14 super();
15 }
16
17 public Student(String name, int chinese, int math, int english) {
18 super();
19 this.name = name;
20 this.chinese = chinese;
21 this.math = math;
22 this.english = english;
23 }
24
25 public String getName() {
26 return name;
27 }
28
29 public void setName(String name) {
30 this.name = name;
31 }
32
33 public int getChinese() {
34 return chinese;
35 }
36
37 public void setChinese(int chinese) {
38 this.chinese = chinese;
39 }
40
41 public int getMath() {
42 return math;
43 }
44
45 public void setMath(int math) {
46 this.math = math;
47 }
48
49 public int getEnglish() {
50 return english;
51 }
52
53 public void setEnglish(int english) {
54 this.english = english;
55 }
56
57 public int getSum() {
58 return this.chinese + this.math + this.english;
59 }
60 }
Student.java
![]()
![]()
1 package cn.itcast_09;
2
3 import java.util.Comparator;
4 import java.util.Scanner;
5 import java.util.TreeSet;
6
7 /*
8 * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台
9 *
10 * 分析：
11 * A:定义学生类
12 * B:创建一个TreeSet集合
13 * C:总分从高到底如何实现呢?
14 * D:键盘录入5个学生信息
15 * E:遍历TreeSet集合
16 */
17 public class TreeSetDemo {
18 public static void main(String[] args) {
19 // 创建一个TreeSet集合
20 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
21 @Override
22 public int compare(Student s1, Student s2) {
23 // 总分从高到低
24 int num = s2.getSum() - s1.getSum();
25 // 总分相同的不一定语文相同
26 int num2 = (num == 0 ? s1.getChinese() - s2.getChinese() : num);
27 // 总分和语文相同的不一定数序相同
28 int num3 = (num2 == 0 ? s1.getMath() - s2.getMath() : num2);
29 // 总分、语文和数学相同的不一定英语相同
30 int num4 = (num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3);
31 // 总分、语文、数学和英语相同的姓名还不一定相同
32 int num5 = (num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4);
33 return num5;
34 }
35 });
36
37 System.out.println("学生信息录入开始");
38 // 键盘录入5个学生信息
39 for (int x = 1; x <= 5; x++) {
40 Scanner sc = new Scanner(System.in);
41
42 System.out.println("请输入第" + x + "个学生的姓名:");
43 String name = sc.nextLine();
44
45 System.out.println("请输入第" + x + "个学生的语文成绩:");
46 String chineseString = sc.nextLine();
47
48 System.out.println("请输入第" + x + "个学生的数学成绩:");
49 String mathString = sc.nextLine();
50
51 System.out.println("请输入第" + x + "个学生的英语成绩:");
52 String englishString = sc.nextLine();
53
54 // 把录入的数据封装到学生对象中
55 Student s = new Student();
56 s.setName(name);
57 s.setChinese(Integer.parseInt(chineseString)); // 把字符串类型转换为int类型
58 s.setMath(Integer.parseInt(mathString)); // 把字符串类型转换为int类型
59 s.setEnglish(Integer.parseInt(englishString)); // 把字符串类型转换为int类型
60
61 // 把学生对象添加到集合
62 ts.add(s);
63 }
64 System.out.println("学生信息录入完毕");
65
66 System.out.println("学习信息从高到低排序如下：");
67 System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩");
68 // 遍历TreeSet集合
69 for (Student s : ts) {
70 System.out.println(s.getName() + "\t" + s.getChinese() + "\t" + s.getMath() + "\t" + s.getEnglish());
71 }
72 }
73 }
TreeSetDemo.java
-----------------------------------------------------------------------------
3:Collection集合总结(掌握)
Collection
|--List 有序,元素可重复
|--ArrayList
底层数据结构是数组。查询快，增删慢。
线程不安全，效率高
|--Vector
底层数据结构是数组。查询快，增删慢。
线程安全，效率低
|--LinkedList
底层数据结构是链表。查询慢，增删快。
线程不安全，效率高
|--Set 无序,元素唯一
|--HashSet
底层数据结构是哈希表。
如何保证元素唯一性的呢?
依赖两个方法：hashCode()和equals()
开发中自动生成这两个方法即可。
|--LinkedHashSet
底层数据结构是链表和哈希表。
由链表保证元素有序。
由哈希表保证元素唯一。
|--TreeSet
底层数据结构是红黑树(二叉树)。
如何保证元素排序的呢？
自然排序
比较器排序
如何保证元素唯一性的呢？
根据比较的返回值是否是0来决定。
-----------------------------------------------------------------------------
4:针对Collection集合我们到底使用谁呢？(掌握)
元素唯一吗？
是：用Set
元素排序吗？
是：TreeSet
否：HashSet
如果你知道是用Set，但是不知道是用哪个Set，就用HashSet。
否：用List
要安全吗？
是：Vector
否：ArrayList 或者 LinkedList
查询多：ArrayList
增删多：LinkedList
如果你知道是用List，但是不知道是用哪个List，就用ArrayList。
---------------------------------------
如果你知道是用 Collection 集合，但是不知道使用谁，就用 ArrayList。
如果你仅仅知道用集合，就用ArrayList。
由此可见，ArrayList用的最多。
-----------------------------------------------------------------------------
5:在集合中常见的数据结构(掌握)
ArrayXxx: 底层数据结构是数组，查询快，增删慢。
LinkedXxx: 底层数据结构是链表，查询慢，增删快。
HashXxx: 底层数据结构是哈希表。依赖两个方法：hashCode()和equals()。
TreeXxx: 底层数据结构是二叉树。两种方式排序：自然排序和比较器排序。
=============================================================================
我的GitHub地址：
https://github.com/heizemingjun
我的博客园地址：
http://www.cnblogs.com/chenmingjun
我的蚂蚁笔记博客地址：
http://blog.leanote.com/chenmingjun
Copyright ©2018 黑泽明军
【转载文章务必保留出处和署名，谢谢！】
