黑马程序员_Java(登陆注册案例,set集合,map集合,Collections)

------- android培训、java培训、期待与您交流！ ----------

生命不息,奋斗不止!做个斗士!!!!!

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

public interface UserDao {/** * 这是用户登录功能 *  * @param username *            用户名 * @param password *            密码 * @return 返回登录是否成功 */public abstract boolean isLogin(String username, String password);/** * 这是用户注册功能 *  * @param user *            要注册的用户信息 */public abstract void regist(User user);}

public class UserDaoImpl implements UserDao {// 为了让多个方法能够使用同一个集合，就把集合定义为成员变量// 为了不让外人看到，用private// 为了让多个对象共享同一个成员变量，用staticprivate static ArrayList<User> array = new ArrayList<User>();@Overridepublic boolean isLogin(String username, String password) {// 遍历集合，获取每一个用户，并判断该用户的用户名和密码是否和传递过来的匹配boolean flag = false;for (User u : array) {if (u.getUsername().equals(username)&& u.getPassword().equals(password)) {flag = true;break;}}return flag;}@Overridepublic void regist(User user) {// 把用户信息存储集合// ArrayList<User> array = new ArrayList<User>();array.add(user);}}

public class User {// 用户名private String username;// 密码private String password;public User() {}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}}

public class UserTest {public static void main(String[] args) {// 为了能够回来while (true) {// 欢迎界面，给出选择项System.out.println("--------------欢迎光临--------------");System.out.println("1 登录");System.out.println("2 注册");System.out.println("3 退出");System.out.println("请输入你的选择:");// 键盘录入选择，根据选择做不同的操作Scanner sc = new Scanner(System.in);// 为了后面的录入信息的方便，我所有的数据录入全部用字符接收String choiceString = sc.nextLine();// switch语句的多个地方要使用，我就定义到外面UserDao ud = new UserDaoImpl();// 经过简单的思考，我选择了switchswitch (choiceString) {case "1":// 登录界面，请输入用户名和密码System.out.println("--------------登录界面--------------");System.out.println("请输入用户名：");String username = sc.nextLine();System.out.println("请输入密码：");String password = sc.nextLine();// 调用登录功能// UserDao ud = new UserDaomImpl();boolean flag = ud.isLogin(username, password);if (flag) {System.out.println("登录成功,可以开始玩游戏了");System.out.println("你玩吗?y/n");while (true) {String resultString = sc.nextLine();if (resultString.equalsIgnoreCase("y")) {// 玩游戏GuessNumber.start();System.out.println("你还玩吗?y/n");} else {break;}}System.out.println("谢谢使用，欢迎下次再来");System.exit(0);// break; //这里写break，结束的是switch} else {System.out.println("用户名或者密码有误,登录失败");}break;case "2":// 欢迎界面，请输入用户名和密码System.out.println("--------------注册界面--------------");System.out.println("请输入用户名：");String newUsername = sc.nextLine();System.out.println("请输入密码：");String newPassword = sc.nextLine();// 把用户名和密码封装到一个对象中User user = new User();user.setUsername(newUsername);user.setPassword(newPassword);// 调用注册功能// 多态// UserDao ud = new UserDaoImpl();// 具体类使用// UserDaoImpl udi = new UserDaoImpl();ud.regist(user);System.out.println("注册成功");break;case "3":default:System.out.println("谢谢使用，欢迎下次再来");System.exit(0);break;}}}}

2:Set集合(理解)
(1)Set集合的特点
无序,唯一
(2)HashSet集合(掌握)
A:底层数据结构是哈希表(是一个元素为链表的数组)
B:哈希表底层依赖两个方法：hashCode()和equals()
执行顺序：
首先比较哈希值是否相同
相同：继续执行equals()方法
返回true：元素重复了，不添加
返回false：直接把元素添加到集合
不同：就直接把元素添加到集合
C:如何保证元素唯一性的呢?
由hashCode()和equals()保证的
D:开发的时候，代码非常的简单，自动生成即可。
E:HashSet存储字符串并遍历
F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)
(3)TreeSet集合
A:底层数据结构是红黑树(是一个自平衡的二叉树)
B:保证元素的排序方式
a:自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
b:比较器排序(集合具备比较性)
让集合构造方法接收Comparator的实现类对象
C:把我们讲过的代码看一遍即可
(4)案例：
A:获取无重复的随机数

* * 编写一个程序，获取10个1至20的随机数，要求随机数不能重复。 *  * 分析： * A:创建随机数对象 * B:创建一个HashSet集合 * C:判断集合的长度是不是小于10 * 是：就创建一个随机数添加 * 否：不搭理它 * D:遍历HashSet集合 */public class HashSetDemo {public static void main(String[] args) {// 创建随机数对象Random r = new Random();// 创建一个Set集合HashSet<Integer> ts = new HashSet<Integer>();// 判断集合的长度是不是小于10while (ts.size() < 10) {int num = r.nextInt(20) + 1;ts.add(num);}// 遍历Set集合for (Integer i : ts) {System.out.println(i);}}}

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。

5:在集合中常见的数据结构
ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

3:Map
(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
(2)Map和Collection的区别?
A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对
B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍
(3)Map接口功能概述 

1:添加功能
V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
2:删除功能
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回
3:判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
4:获取功能
Set<Map.Entry<K,V>> entrySet():???
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合
5：长度功能
int size()：返回集合中的键值对的对数

(4)Map集合的遍历
A:键找值
a:获取所有键的集合
b:遍历键的集合,得到每一个键
c:根据键到集合中去找值

B:键值对对象找键和值
a:获取所有的键值对对象的集合
b:遍历键值对对象的集合，获取每一个键值对对象
c:根据键值对对象去获取键和值

图解:

4:Collections
(1)是针对集合进行操作的工具类
(2)面试题：Collection和Collections的区别
A:Collection 是单列集合的顶层接口，有两个子接口List和Set
B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等
(3)常见的几个小方法：
A:public static <T> void sort(List<T> list)
B:public static <T> int binarySearch(List<?> list,T key)
C:public static <T> T max(Collection<?> coll)
D:public static void reverse(List<?> list)
E:public static void shuffle(List<?> list)
(4)案例
A:ArrayList集合存储自定义对象的排序

public class CollectionsDemo {public static void main(String[] args) {// 创建集合对象List<Student> list = new ArrayList<Student>();// 创建学生对象Student s1 = new Student("林青霞", 27);Student s2 = new Student("风清扬", 30);Student s3 = new Student("刘晓曲", 28);Student s4 = new Student("武鑫", 29);Student s5 = new Student("林青霞", 27);// 添加元素对象list.add(s1);list.add(s2);list.add(s3);list.add(s4);list.add(s5);// 排序// 自然排序// Collections.sort(list);// 比较器排序// 如果同时有自然排序和比较器排序，以比较器排序为主Collections.sort(list, new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s2.getAge() - s1.getAge();int num2 = num == 0 ? s1.getName().compareTo(s2.getName()): num;return num2;}});// 遍历集合for (Student s : list) {System.out.println(s.getName() + "---" + s.getAge());}}}

B:模拟斗地主洗牌和发牌

* * 模拟斗地主洗牌和发牌 *  * 分析： * A:创建一个牌盒 * B:装牌 * C:洗牌 * D:发牌 * E:看牌 */public class PokerDemo {public static void main(String[] args) {// 创建一个牌盒ArrayList<String> array = new ArrayList<String>();// 装牌// 黑桃A,黑桃2,黑桃3,...黑桃K// 红桃A,...// 梅花A,...// 方块A,...// 定义一个花色数组String[] colors = { "♠", "♥", "♣", "♦" };// 定义一个点数数组String[] numbers = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10","J", "Q", "K" };// 装牌for (String color : colors) {for (String number : numbers) {array.add(color.concat(number));}}array.add("小王");array.add("大王");// 洗牌Collections.shuffle(array);// System.out.println("array:" + array);// 发牌ArrayList<String> fengQingYang = new ArrayList<String>();ArrayList<String> linQingXia = new ArrayList<String>();ArrayList<String> liuYi = new ArrayList<String>();ArrayList<String> diPai = new ArrayList<String>();for (int x = 0; x < array.size(); x++) {if (x >= array.size() - 3) {diPai.add(array.get(x));} else if (x % 3 == 0) {fengQingYang.add(array.get(x));} else if (x % 3 == 1) {linQingXia.add(array.get(x));} else if (x % 3 == 2) {liuYi.add(array.get(x));}}// 看牌lookPoker("风清扬", fengQingYang);lookPoker("林青霞", linQingXia);lookPoker("刘意", liuYi);lookPoker("底牌", diPai);}public static void lookPoker(String name, ArrayList<String> array) {System.out.print(name + "的牌是：");for (String s : array) {System.out.print(s + " ");}System.out.println();}}

C:模拟斗地主洗牌和发牌并对牌进行排序

* * 思路： * A:创建一个HashMap集合 * B:创建一个ArrayList集合 * C:创建花色数组和点数数组 * D:从0开始往HashMap里面存储编号，并存储对应的牌 *        同时往ArrayList里面存储编号即可。 *      E:洗牌(洗的是编号) *      F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收) *      G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌) */public class PokerDemo {public static void main(String[] args) {// 创建一个HashMap集合HashMap<Integer, String> hm = new HashMap<Integer, String>();// 创建一个ArrayList集合ArrayList<Integer> array = new ArrayList<Integer>();// 创建花色数组和点数数组// 定义一个花色数组String[] colors = { "♠", "♥", "♣", "♦" };// 定义一个点数数组String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q","K", "A", "2", };// 从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。int index = 0;for (String number : numbers) {for (String color : colors) {String poker = color.concat(number);hm.put(index, poker);array.add(index);index++;}}hm.put(index, "小王");array.add(index);index++;hm.put(index, "大王");array.add(index);// 洗牌(洗的是编号)Collections.shuffle(array);// 发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)TreeSet<Integer> fengQingYang = new TreeSet<Integer>();TreeSet<Integer> linQingXia = new TreeSet<Integer>();TreeSet<Integer> liuYi = new TreeSet<Integer>();TreeSet<Integer> diPai = new TreeSet<Integer>();for (int x = 0; x < array.size(); x++) {if (x >= array.size() - 3) {diPai.add(array.get(x));} else if (x % 3 == 0) {fengQingYang.add(array.get(x));} else if (x % 3 == 1) {linQingXia.add(array.get(x));} else if (x % 3 == 2) {liuYi.add(array.get(x));}}// 看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)lookPoker("风清扬", fengQingYang, hm);lookPoker("林青霞", linQingXia, hm);lookPoker("刘意", liuYi, hm);lookPoker("底牌", diPai, hm);}// 写看牌的功能public static void lookPoker(String name, TreeSet<Integer> ts,HashMap<Integer, String> hm) {System.out.print(name + "的牌是：");for (Integer key : ts) {String value = hm.get(key);System.out.print(value + " ");}System.out.println();}}