Java笔记(17)：集合框架(03)

1、登录注册分析及代码实现

分析：

需求：用户登录注册案例。

按照如下的操作，可以让我们更符号面向对象思想
A:有哪些类呢?
B:每个类有哪些东西呢?
C:类与类之间的关系是什么呢?

分析：
A:有哪些类呢?
用户类
测试类
B:每个类有哪些东西呢?
用户类：
成员变量：用户名，密码
构造方法：无参构造
成员方法：getXxx()/setXxx()
登录，注册

假如用户类的内容比较对，将来维护起来就比较麻烦，为了更清晰的分类，我们就把用户又划分成了两类
用户基本描述类
成员变量：用户名，密码
构造方法：无参构造
成员方法：getXxx()/setXxx()
用户操作类
登录，注册
测试类：
main方法。
C:类与类之间的关系是什么呢?
在测试类中创建用户操作类和用户基本描述类的对象，并使用其功能。

分包：
A:功能划分
B:模块划分
C:先按模块划分，再按功能划分

今天我们选择按照功能划分：
用户基本描述类包 cn.itcast.pojo
用户操作接口 cn.itcast.dao
用户操作类包 cn.itcast.dao.impl
用户测试类 cn.itcast.test

1）用户基本描述类实现：

 1 package cn.itcast.pojo;
 2 
 3 /**
 4  * 这是用户基本描述类
 5  * 
 6  * @author 风清扬
 7  * @version V1.0
 8  * 
 9  */
10 public class User {
11     // 用户名
12     private String username;
13     // 密码
14     private String password;
15 
16     public User() {
17     }
18 
19     public String getUsername() {
20         return username;
21     }
22 
23     public void setUsername(String username) {
24         this.username = username;
25     }
26 
27     public String getPassword() {
28         return password;
29     }
30 
31     public void setPassword(String password) {
32         this.password = password;
33     }
34 }

2）用户操作接口的实现：

 1 package cn.itcast.dao;
 2 
 3 import cn.itcast.pojo.User;
 4 
 5 /**
 6  * 这是针对用户进行操作的接口
 7  * 
 8  * @author 风清扬
 9  * @version V1.0
10  * 
11  */
12 public interface UserDao {
13     /**
14      * 这是用户登录功能
15      * 
16      * @param username
17      *            用户名
18      * @param password
19      *            密码
20      * @return 返回登录是否成功
21      */
22     public abstract boolean isLogin(String username, String password);
23 
24     /**
25      * 这是用户注册功能
26      * 
27      * @param user
28      *            要注册的用户信息
29      */
30     public abstract void regist(User user);
31 }

3）用户操作类的具体实现：

 1 package cn.itcast.dao.impl;
 2 
 3 import java.util.ArrayList;
 4 
 5 import cn.itcast.dao.UserDao;
 6 import cn.itcast.pojo.User;
 7 
 8 /**
 9  * 这是用户操作的具体实现类(集合版)
10  * 
11  * @author 风清扬
12  * @version V1.0
13  * 
14  */
15 public class UserDaoImpl implements UserDao {
16     // 为了让多个方法能够使用同一个集合，就把集合定义为成员变量
17     // 为了不让外人看到，用private
18     // 为了让多个对象共享同一个成员变量，用static
19     private static ArrayList<User> array = new ArrayList<User>();
20 
21     @Override
22     public boolean isLogin(String username, String password) {
23         // 遍历集合，获取每一个用户，并判断该用户的用户名和密码是否和传递过来的匹配
24         boolean flag = false;
25 
26         for (User u : array) {
27             if (u.getUsername().equals(username)
28                     && u.getPassword().equals(password)) {
29                 flag = true;
30                 break;
31             }
32         }
33 
34         return flag;
35     }
36 
37     @Override
38     public void regist(User user) {
39         // 把用户信息存储集合
40         // ArrayList<User> array = new ArrayList<User>();
41         array.add(user);
42     }
43 }

4）猜数字小游戏类的实现：

 1 package cn.itcast.game;
 2 
 3 import java.util.Scanner;
 4 
 5 /**
 6  * 这是猜数字小游戏
 7  * 
 8  * @author 风清扬
 9  * @version V1.0
10  * 
11  */
12 public class GuessNumber {
13     private GuessNumber() {
14     }
15 
16     public static void start() {
17         // 产生一个随机数
18         int number = (int) (Math.random() * 100) + 1;
19 
20         // 定义一个统计变量
21         int count = 0;
22 
23         while (true) {
24             // 键盘录入一个数据
25             Scanner sc = new Scanner(System.in);
26             System.out.println("请输入数据(1-100)：");
27             int guessNumber = sc.nextInt();
28 
29             count++;
30 
31             // 判断
32             if (guessNumber > number) {
33                 System.out.println("你猜的数据" + guessNumber + "大了");
34             } else if (guessNumber < number) {
35                 System.out.println("你猜的数据" + guessNumber + "小了");
36             } else {
37                 System.out.println("恭喜你，" + count + "次就猜中了");
38                 break;
39             }
40         }
41     }
42 }

5）用户测试类的实现

  1 package cn.itcast.test;
  2 
  3 import java.util.Scanner;
  4 
  5 import cn.itcast.dao.UserDao;
  6 import cn.itcast.dao.impl.UserDaoImpl;
  7 import cn.itcast.game.GuessNumber;
  8 import cn.itcast.pojo.User;
  9 
 10 /**
 11  * 用户测试类
 12  * 
 13  * @author 风清扬
 14  * @version V1.0
 15  * 
 16  *          新增加了两个小问题 A:多个对象共享同一个成员变量，用静态
 17  *          B:循环里面如果有switch，并且在switch里面有break，那么结束的不是循环，而是switch语句
 18  * 
 19  */
 20 public class UserTest {
 21     public static void main(String[] args) {
 22         // 为了能够回来
 23         while (true) {
 24             // 欢迎界面，给出选择项
 25             System.out.println("--------------欢迎光临--------------");
 26             System.out.println("1 登录");
 27             System.out.println("2 注册");
 28             System.out.println("3 退出");
 29             System.out.println("请输入你的选择:");
 30             // 键盘录入选择，根据选择做不同的操作
 31             Scanner sc = new Scanner(System.in);
 32             // 为了后面的录入信息的方便，我所有的数据录入全部用字符接收
 33             String choiceString = sc.nextLine();
 34 
 35             // switch语句的多个地方要使用，我就定义到外面
 36             UserDao ud = new UserDaoImpl();
 37 
 38             // 经过简单的思考，我选择了switch
 39             switch (choiceString) {
 40             case "1":
 41                 // 登录界面，请输入用户名和密码
 42                 System.out.println("--------------登录界面--------------");
 43                 System.out.println("请输入用户名：");
 44                 String username = sc.nextLine();
 45                 System.out.println("请输入密码：");
 46                 String password = sc.nextLine();
 47 
 48                 // 调用登录功能
 49                 // UserDao ud = new UserDaomImpl();
 50 
 51                 boolean flag = ud.isLogin(username, password);
 52                 if (flag) {
 53                     System.out.println("登录成功,可以开始玩游戏了");
 54 
 55                     System.out.println("你玩吗?y/n");
 56                     while (true) {
 57                         String resultString = sc.nextLine();
 58                         if (resultString.equalsIgnoreCase("y")) {
 59                             // 玩游戏
 60                             GuessNumber.start();
 61                             System.out.println("你还玩吗?y/n");
 62                         } else {
 63                             break;
 64                         }
 65                     }
 66                     System.out.println("谢谢使用，欢迎下次再来");
 67                     System.exit(0);
 68                     // break; //这里写break，结束的是switch
 69                 } else {
 70                     System.out.println("用户名或者密码有误,登录失败");
 71                 }
 72                 break;
 73             case "2":
 74                 // 欢迎界面，请输入用户名和密码
 75                 System.out.println("--------------注册界面--------------");
 76                 System.out.println("请输入用户名：");
 77                 String newUsername = sc.nextLine();
 78                 System.out.println("请输入密码：");
 79                 String newPassword = sc.nextLine();
 80 
 81                 // 把用户名和密码封装到一个对象中
 82                 User user = new User();
 83                 user.setUsername(newUsername);
 84                 user.setPassword(newPassword);
 85 
 86                 // 调用注册功能
 87                 // 多态
 88                 // UserDao ud = new UserDaoImpl();
 89                 // 具体类使用
 90                 // UserDaoImpl udi = new UserDaoImpl();
 91 
 92                 ud.regist(user);
 93                 System.out.println("注册成功");
 94                 break;
 95             case "3":
 96             default:
 97                 System.out.println("谢谢使用，欢迎下次再来");
 98                 System.exit(0);
 99                 break;
100             }
101         }
102     }
103 }

2、Set集合概述及特点

 1 package cn.itcast_01;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 /*
 7  * Collection
 8  *         |--List
 9  *             有序(存储顺序和取出顺序一致),可重复
10  *         |--Set
11  *             无序(存储顺序和取出顺序不一致),唯一
12  * 
13  * HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
14  * 注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，
15  * 而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。
16  */
17 public class SetDemo {
18     public static void main(String[] args) {
19         // 创建集合对象
20         Set<String> set = new HashSet<String>();
21 
22         // 创建并添加元素
23         set.add("hello");
24         set.add("java");
25         set.add("world");
26         set.add("java");
27         set.add("world");
28 
29         // 增强for
30         for (String s : set) {
31             System.out.println(s);
32         }
33     }
34 }

3、HashSet保证元素唯一性的源码解析

 1 package cn.itcast_02;
 2 
 3 import java.util.HashSet;
 4 
 5 /*
 6  * HashSet:存储字符串并遍历
 7  * 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢?
 8  * 通过查看add方法的源码，我们知道这个方法底层依赖 两个方法：hashCode()和equals()。
 9  * 步骤：
10  *         首先比较哈希值
11  *         如果相同，继续走，比较地址值或者走equals()
12  *         如果不同,就直接添加到集合中    
13  * 按照方法的步骤来说：    
14  *         先看hashCode()值是否相同
15  *             相同:继续走equals()方法
16  *                 返回true：    说明元素重复，就不添加
17  *                 返回false：说明元素不重复，就添加到集合
18  *             不同：就直接把元素添加到集合
19  * 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
20  * 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。
21  */
22 public class HashSetDemo {
23     public static void main(String[] args) {
24         // 创建集合对象
25         HashSet<String> hs = new HashSet<String>();
26 
27         // 创建并添加元素
28         hs.add("hello");
29         hs.add("world");
30         hs.add("java");
31         hs.add("world");
32 
33         // 遍历集合
34         for (String s : hs) {
35             System.out.println(s);
36         }
37     }
38 }

4、HashSet存储自定义对象并遍历

 1 package cn.itcast_02;
 2 
 3 /**
 4  * @author Administrator
 5  * 
 6  */
 7 public class Student {
 8     private String name;
 9     private int age;
10 
11     public Student() {
12         super();
13     }
14 
15     public Student(String name, int age) {
16         super();
17         this.name = name;
18         this.age = age;
19     }
20 
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public int getAge() {
30         return age;
31     }
32 
33     public void setAge(int age) {
34         this.age = age;
35     }
36 
37     @Override
38     public int hashCode() {
39         final int prime = 31;
40         int result = 1;
41         result = prime * result + age;
42         result = prime * result + ((name == null) ? 0 : name.hashCode());
43         return result;
44     }
45 
46     @Override
47     public boolean equals(Object obj) {
48         if (this == obj)
49             return true;
50         if (obj == null)
51             return false;
52         if (getClass() != obj.getClass())
53             return false;
54         Student other = (Student) obj;
55         if (age != other.age)
56             return false;
57         if (name == null) {
58             if (other.name != null)
59                 return false;
60         } else if (!name.equals(other.name))
61             return false;
62         return true;
63     }
64 
65     // @Override
66     // public int hashCode() {
67     // // return 0;
68     // // 因为成员变量值影响了哈希值，所以我们把成员变量值相加即可
69     // // return this.name.hashCode() + this.age;
70     // // 看下面
71     // // s1:name.hashCode()=40,age=30
72     // // s2:name.hashCode()=20,age=50
73     // // 尽可能的区分,我们可以把它们乘以一些整数
74     // return this.name.hashCode() + this.age * 15;
75     // }
76     //
77     // @Override
78     // public boolean equals(Object obj) {
79     // // System.out.println(this + "---" + obj);
80     // if (this == obj) {
81     // return true;
82     // }
83     //
84     // if (!(obj instanceof Student)) {
85     // return false;
86     // }
87     //
88     // Student s = (Student) obj;
89     // return this.name.equals(s.name) && this.age == s.age;
90     // }
91     //
92     // @Override
93     // public String toString() {
94     // return "Student [name=" + name + ", age=" + age + "]";
95     // }
96 
97 }

 1 package cn.itcast_02;
 2 
 3 import java.util.HashSet;
 4 
 5 /*
 6  * 需求：存储自定义对象，并保证元素的唯一性
 7  * 要求：如果两个对象的成员变量值都相同，则为同一个元素。
 8  * 
 9  * 目前是不符合我的要求的：因为我们知道HashSet底层依赖的是hashCode()和equals()方法。
10  * 而这两个方法我们在学生类中没有重写，所以，默认使用的是Object类。
11  * 这个时候，他们的哈希值是不会一样的，根本就不会继续判断，执行了添加操作。
12  */
13 public class HashSetDemo2 {
14     public static void main(String[] args) {
15         // 创建集合对象
16         HashSet<Student> hs = new HashSet<Student>();
17 
18         // 创建学生对象
19         Student s1 = new Student("林青霞", 27);
20         Student s2 = new Student("柳岩", 22);
21         Student s3 = new Student("王祖贤", 30);
22         Student s4 = new Student("林青霞", 27);
23         Student s5 = new Student("林青霞", 20);
24         Student s6 = new Student("范冰冰", 22);
25 
26         // 添加元素
27         hs.add(s1);
28         hs.add(s2);
29         hs.add(s3);
30         hs.add(s4);
31         hs.add(s5);
32         hs.add(s6);
33 
34         // 遍历集合
35         for (Student s : hs) {
36             System.out.println(s.getName() + "---" + s.getAge());
37         }
38     }
39 }

练习：HashSet存储自定义对象并遍历练习

 1 package cn.itcast_03;
 2 
 3 public class Dog {
 4     private String name;
 5     private int age;
 6     private String color;
 7     private char sex;
 8 
 9     public Dog() {
10         super();
11     }
12 
13     public Dog(String name, int age, String color, char sex) {
14         super();
15         this.name = name;
16         this.age = age;
17         this.color = color;
18         this.sex = sex;
19     }
20 
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public int getAge() {
30         return age;
31     }
32 
33     public void setAge(int age) {
34         this.age = age;
35     }
36 
37     public String getColor() {
38         return color;
39     }
40 
41     public void setColor(String color) {
42         this.color = color;
43     }
44 
45     public char getSex() {
46         return sex;
47     }
48 
49     public void setSex(char sex) {
50         this.sex = sex;
51     }
52 
53     @Override
54     public int hashCode() {
55         final int prime = 31;
56         int result = 1;
57         result = prime * result + age;
58         result = prime * result + ((color == null) ? 0 : color.hashCode());
59         result = prime * result + ((name == null) ? 0 : name.hashCode());
60         result = prime * result + sex;
61         return result;
62     }
63 
64     @Override
65     public boolean equals(Object obj) {
66         if (this == obj)
67             return true;
68         if (obj == null)
69             return false;
70         if (getClass() != obj.getClass())
71             return false;
72         Dog other = (Dog) obj;
73         if (age != other.age)
74             return false;
75         if (color == null) {
76             if (other.color != null)
77                 return false;
78         } else if (!color.equals(other.color))
79             return false;
80         if (name == null) {
81             if (other.name != null)
82                 return false;
83         } else if (!name.equals(other.name))
84             return false;
85         if (sex != other.sex)
86             return false;
87         return true;
88     }
89 
90 }

 1 package cn.itcast_03;
 2 
 3 import java.util.HashSet;
 4 
 5 /*
 6  * HashSet集合存储自定义对象并遍历。如果对象的成员变量值相同即为同一个对象
 7  * 
 8  * 注意了：
 9  *         你使用的是HashSet集合，这个集合的底层是哈希表结构。
10  *         而哈希表结构底层依赖:hashCode()和equals()方法。
11  *         如果你认为对象的成员变量值相同即为同一个对象的话，你就应该重写这两个方法。
12  *         如何重写呢?不同担心，自动生成即可。
13  */
14 public class DogDemo {
15     public static void main(String[] args) {
16         // 创建集合对象
17         HashSet<Dog> hs = new HashSet<Dog>();
18 
19         // 创建狗对象
20         Dog d1 = new Dog("秦桧", 25, "红色", '男');
21         Dog d2 = new Dog("高俅", 22, "黑色", '女');
22         Dog d3 = new Dog("秦桧", 25, "红色", '男');
23         Dog d4 = new Dog("秦桧", 20, "红色", '女');
24         Dog d5 = new Dog("魏忠贤", 28, "白色", '男');
25         Dog d6 = new Dog("李莲英", 23, "黄色", '女');
26         Dog d7 = new Dog("李莲英", 23, "黄色", '女');
27         Dog d8 = new Dog("李莲英", 23, "黄色", '男');
28 
29         // 添加元素
30         hs.add(d1);
31         hs.add(d2);
32         hs.add(d3);
33         hs.add(d4);
34         hs.add(d5);
35         hs.add(d6);
36         hs.add(d7);
37         hs.add(d8);
38 
39         // 遍历
40         for (Dog d : hs) {
41             System.out.println(d.getName() + "---" + d.getAge() + "---"
42                     + d.getColor() + "---" + d.getSex());
43         }
44     }
45 }

5、LinkedHashSet的概述和使用

 1 package cn.itcast_04;
 2 
 3 import java.util.LinkedHashSet;
 4 
 5 /*
 6  * LinkedHashSet:底层数据结构由哈希表和链表组成。
 7  * 哈希表保证元素的唯一性。
 8  * 链表保证元素有素。(存储和取出是一致)
 9  */
10 public class LinkedHashSetDemo {
11     public static void main(String[] args) {
12         // 创建集合对象
13         LinkedHashSet<String> hs = new LinkedHashSet<String>();
14 
15         // 创建并添加元素
16         hs.add("hello");
17         hs.add("world");
18         hs.add("java");
19         hs.add("world");
20         hs.add("java");
21 
22         // 遍历
23         for (String s : hs) {
24             System.out.println(s);
25         }
26     }
27 }

6、TreeSet存储Integer类型的元素并遍历

 1 package cn.itcast_05;
 2 
 3 import java.util.TreeSet;
 4 
 5 /*
 6  * TreeSet：能够对元素按照某种规则进行排序。
 7  * 排序有两种方式
 8  * A:自然排序
 9  * B:比较器排序
10  * 
11  * TreeSet集合的特点：排序和唯一
12  * 
13  * 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。
14  */
15 public class TreeSetDemo {
16     public static void main(String[] args) {
17         // 创建集合对象
18         // 自然顺序进行排序
19         TreeSet<Integer> ts = new TreeSet<Integer>();
20 
21         // 创建元素并添加
22         // 20,18,23,22,17,24,19,18,24
23         ts.add(20);
24         ts.add(18);
25         ts.add(23);
26         ts.add(22);
27         ts.add(17);
28         ts.add(24);
29         ts.add(19);
30         ts.add(18);
31         ts.add(24);
32 
33         // 遍历
34         for (Integer i : ts) {
35             System.out.println(i);
36         }
37     }
38 }

7、TreeSet保证元素唯一性和自然排序的原理和图解

练习：TreeSet存储自定义对象并遍历练习1

 1 package cn.itcast_05;
 2 
 3 /*
 4  * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
 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         // return 0;
39         // return 1;
40         // return -1;
41 
42         // 这里返回什么，其实应该根据我的排序规则来做
43         // 按照年龄排序,主要条件
44         int num = this.age - s.age;
45         // 次要条件
46         // 年龄相同的时候，还得去看姓名是否也相同
47         // 如果年龄和姓名都相同，才是同一个元素
48         int num2 = num == 0 ? this.name.compareTo(s.name) : num;
49         return num2;
50     }
51 }

 1 package cn.itcast_05;
 2 
 3 import java.util.TreeSet;
 4 
 5 /*
 6  * TreeSet存储自定义对象并保证排序和唯一。
 7  * 
 8  * A:你没有告诉我们怎么排序
 9  *         自然排序，按照年龄从小到大排序
10  * B:元素什么情况算唯一你也没告诉我
11  *         成员变量值都相同即为同一个元素
12  */
13 public class TreeSetDemo2 {
14     public static void main(String[] args) {
15         // 创建集合对象
16         TreeSet<Student> ts = new TreeSet<Student>();
17 
18         // 创建元素
19         Student s1 = new Student("linqingxia", 27);
20         Student s2 = new Student("zhangguorong", 29);
21         Student s3 = new Student("wanglihong", 23);
22         Student s4 = new Student("linqingxia", 27);
23         Student s5 = new Student("liushishi", 22);
24         Student s6 = new Student("wuqilong", 40);
25         Student s7 = new Student("fengqingy", 22);
26 
27         // 添加元素
28         ts.add(s1);
29         ts.add(s2);
30         ts.add(s3);
31         ts.add(s4);
32         ts.add(s5);
33         ts.add(s6);
34         ts.add(s7);
35 
36         // 遍历
37         for (Student s : ts) {
38             System.out.println(s.getName() + "---" + s.getAge());
39         }
40     }
41 }

练习：TreeSet存储自定义对象并遍历练习2

 1 package cn.itcast_06;
 2 
 3 /*
 4  * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
 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         // 姓名的长度相同，不代表姓名的内容相同
41         int num2 = num == 0 ? this.name.compareTo(s.name) : num;
42         // 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄
43         int num3 = num2 == 0 ? this.age - s.age : num2;
44         return num3;
45     }
46 }

 1 package cn.itcast_06;
 2 
 3 import java.util.TreeSet;
 4 
 5 /*
 6  * 需求：请按照姓名的长度排序
 7  */
 8 public class TreeSetDemo {
 9     public static void main(String[] args) {
10         // 创建集合对象
11         TreeSet<Student> ts = new TreeSet<Student>();
12 
13         // 创建元素
14         Student s1 = new Student("linqingxia", 27);
15         Student s2 = new Student("zhangguorong", 29);
16         Student s3 = new Student("wanglihong", 23);
17         Student s4 = new Student("linqingxia", 27);
18         Student s5 = new Student("liushishi", 22);
19         Student s6 = new Student("wuqilong", 40);
20         Student s7 = new Student("fengqingy", 22);
21         Student s8 = new Student("linqingxia", 29);
22 
23         // 添加元素
24         ts.add(s1);
25         ts.add(s2);
26         ts.add(s3);
27         ts.add(s4);
28         ts.add(s5);
29         ts.add(s6);
30         ts.add(s7);
31         ts.add(s8);
32 
33         // 遍历
34         for (Student s : ts) {
35             System.out.println(s.getName() + "---" + s.getAge());
36         }
37     }
38 }

8、TreeSet保证元素唯一性和比较器排序的原理及代码实现

 1 package cn.itcast_07;
 2 
 3 public class Student {
 4     private String name;
 5     private int age;
 6 
 7     public Student() {
 8         super();
 9     }
10 
11     public Student(String name, int age) {
12         super();
13         this.name = name;
14         this.age = age;
15     }
16 
17     public String getName() {
18         return name;
19     }
20 
21     public void setName(String name) {
22         this.name = name;
23     }
24 
25     public int getAge() {
26         return age;
27     }
28 
29     public void setAge(int age) {
30         this.age = age;
31     }
32 }

 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         // int num = this.name.length() - s.name.length();
10         // this -- s1
11         // s -- s2
12         // 姓名长度
13         int num = s1.getName().length() - s2.getName().length();
14         // 姓名内容
15         int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
16         // 年龄
17         int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
18         return num3;
19     }
20 
21 }

 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<Student> ts = new TreeSet<Student>(); //自然排序
21         // public TreeSet(Comparator comparator) //比较器排序
22         // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());
23 
24         // 如果一个方法的参数是接口，那么真正要的是接口的实现类的对象
25         // 而匿名内部类就可以实现这个东西
26         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
27             @Override
28             public int compare(Student s1, Student s2) {
29                 // 姓名长度
30                 int num = s1.getName().length() - s2.getName().length();
31                 // 姓名内容
32                 int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
33                         : num;
34                 // 年龄
35                 int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
36                 return num3;
37             }
38         });
39 
40         // 创建元素
41         Student s1 = new Student("linqingxia", 27);
42         Student s2 = new Student("zhangguorong", 29);
43         Student s3 = new Student("wanglihong", 23);
44         Student s4 = new Student("linqingxia", 27);
45         Student s5 = new Student("liushishi", 22);
46         Student s6 = new Student("wuqilong", 40);
47         Student s7 = new Student("fengqingy", 22);
48         Student s8 = new Student("linqingxia", 29);
49 
50         // 添加元素
51         ts.add(s1);
52         ts.add(s2);
53         ts.add(s3);
54         ts.add(s4);
55         ts.add(s5);
56         ts.add(s6);
57         ts.add(s7);
58         ts.add(s8);
59 
60         // 遍历
61         for (Student s : ts) {
62             System.out.println(s.getName() + "---" + s.getAge());
63         }
64     }
65 }

练习：产生10个1-20之间的随机数要求随机数不能重复案例简洁版

 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
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         // 创建一个Set集合
23         HashSet<Integer> ts = new HashSet<Integer>();
24 
25         // 判断集合的长度是不是小于10
26         while (ts.size() < 10) {
27             int num = r.nextInt(20) + 1;
28             ts.add(num);
29         }
30 
31         // 遍历Set集合
32         for (Integer i : ts) {
33             System.out.println(i);
34         }
35     }
36 }

练习：键盘录入学生信息按照总分排序后输出在控制台案例

 1 package cn.itcast_08;
 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())
33                         : num4;
34                 return num5;
35             }
36         });
37 
38         System.out.println("学生信息录入开始");
39         // 键盘录入5个学生信息
40         for (int x = 1; x <= 5; x++) {
41             Scanner sc = new Scanner(System.in);
42             System.out.println("请输入第" + x + "个学生的姓名:");
43             String name = sc.nextLine();
44             System.out.println("请输入第" + x + "个学生的语文成绩:");
45             String chineseString = sc.nextLine();
46             System.out.println("请输入第" + x + "个学生的数学成绩:");
47             String mathString = sc.nextLine();
48             System.out.println("请输入第" + x + "个学生的英语成绩:");
49             String englishString = sc.nextLine();
50 
51             // 把数据封装到学生对象中
52             Student s = new Student();
53             s.setName(name);
54             s.setChinese(Integer.parseInt(chineseString));
55             s.setMath(Integer.parseInt(mathString));
56             s.setEnglish(Integer.parseInt(englishString));
57 
58             // 把学生对象添加到集合
59             ts.add(s);
60         }
61         System.out.println("学生信息录入完毕");
62 
63         System.out.println("学习信息从高到低排序如下：");
64         System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩");
65         // 遍历集合
66         for (Student s : ts) {
67             System.out.println(s.getName() + "\t" + s.getChinese() + "\t"
68                     + s.getMath() + "\t" + s.getEnglish());
69         }
70     }
71 }

posted @ 2017-05-31 13:48 花醉红尘阅读(248) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

花醉红尘

婆罗樱花终相见相伴人世共翩跹

Java笔记(17)：集合框架(03)

公告

花醉红尘

婆罗樱花终相见 相伴人世共翩跹

Java笔记(17)：集合框架(03)

公告

婆罗樱花终相见相伴人世共翩跹