1. 简单练习HashSet集合-产生1到20，10个不重复的随机数

//1.创建Random对象
        Random r = new Random();
        //2.因为存储不重复的，我们用HashSet集合
        //这里泛型为什么用Integer知道吗！
        HashSet<Integer> hs = new HashSet<>();
        //3.循环条件hs.size()<10;
         while (hs.size() < 10){
             //4.通过Random方法获取随机数
             //r.nextInt(20):获取到的是0到19的随机数--左开右闭的
             hs.add(r.nextInt(20) + 1);
         }
        System.out.println(hs);

2. 集合小练习

#练习一:
//需求:使用Scanner输入，去掉输入中的重复字符，打印不同的字符
        //1.创建Scanner对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一串字符:");

        //2.创建hashSet对象
        HashSet<Character> hs = new HashSet<>();

        //3.用字符串接收这个输入值，并将字符串转为字符数组
        String str = sc.nextLine();
        char[] arr = str.toCharArray();

        //4.遍历字符数组并加入到hs中
        for (Character c :  arr){
            hs.add(c);
        }
        System.out.println(hs);

#练习二:
//需求:给有重复元素的ArrayList集合创建一个去重方法，直接调用就好
        ArrayList<String> list = new ArrayList<>();
        list.add("tmac");
        list.add("tmac");
        list.add("kobe");
        list.add("kobe");
        list.add("kg");
        list.add("kg");
        list.add("jiangjun");
        list.add("jiangjun");
        System.out.println(list);
        System.out.println("去重之前的值");

        //调用封装的去重方法
        cancelReptList(list);
        System.out.println(list);
        System.out.println("去重之后的值");
    }
    //封装的去重方法
    public static void cancelReptList(List<String> list){
        //1.创建LinkedHashSet对象,这里面不能存储重复值
        LinkedHashSet<String> hs = new LinkedHashSet<>();
        //2.将list加到hs中，就可以在hs中去除重复值了
        hs.addAll(list);
        //3.将list清空
        list.clear();
        //4.将去重后的hs加入到list中
        list.addAll(hs);
    }

3. TreeSet集合的简单使用

 //1.TreeSet集合是对元素进行排序且保证元素唯一的
        //只用LinkedHashSet是保证怎么存就怎么取，且去重的
        TreeSet<Integer> ts = new TreeSet<>();//从小到大排序
        ts.add(78);
        ts.add(45);
        ts.add(109);
        ts.add(23);
        ts.add(12);
        System.out.println(ts);

        //2.TreeSet集合存储自定义对象
        TreeSet<Student> ts1 = new TreeSet<>();
        ts1.add(new Student("tmac",23));
        ts1.add(new Student("kobe",13));
        ts1.add(new Student("king",34));
        ts1.add(new Student("jiangjun",45));
        //我们存储的是自定义对象，TreeSet是对元素排序的，我们看看会怎么回事
        System.out.println(ts1);
        //报错崩溃:java.lang.ClassCastException:类型无法匹配。我们解决方法是
        //实现一个compable接口，就是要告诉TreeSet按照什么要求对Student排序

//延展:
        //TreeSet底层是二叉树结构

4. Map集合的概述和特点和iOS的字典很像

 //1.创建一个map
        Map<String,Integer> map = new HashMap<>();
        //添加元素的方法put--put方法是有返回值的，返回值就是这个值的类型
      Integer i1 = map.put("tmac",19);
        map.put("kobe",37);
        map.put("kiii",98);
        map.put("kdjf",88);
      Integer i2 = map.put("tmac",39);
        System.out.println(map);//看这个打印发现键和值是对应的，但是打印出来顺序是无序的
        System.out.println(i1);
        System.out.println(i2);
        //对比i1和i2的打印值，说明我们呢put方法的返回值只返回被覆盖的键对应的值
        //在Map中键的值是唯一的，我们重复为一个键添加值，就会覆盖原有值，并返回

        System.out.println("1---------------------");
        //2.根据键删除值，返回被删除的值
       Integer i3 = map.remove("tmac");
        System.out.println(i3);

        map.put("jj",45);
        map.put("cc",44);
       //根据键和值删除，返回删除成功与否
        boolean b1 = map.remove("jj",45);
        System.out.println(b1);
        System.out.println("2------------------");
        //3.清除所有元素
       // map.clear();

        //4.判断功能
        //map.containsKey():是否包含这个key
        //map.containsValue():是否包含这个值
        map.isEmpty();//是否为空

        //5.获取集合中所有的值
       Collection<Integer> c =  map.values();
        System.out.println(c);

        //6.map.size():元素个数--一对键值才是一个长度

5. Map集合的遍历—键找值

 //1. Map集合遍历--键找值(map中没有迭代器)
        Map<String,Integer> map = new HashMap<>();
        map.put("jj",67);
        map.put("ji",45);
        map.put("qq",32);
        map.put("aa",13);
        map.put("cc",38);

        //根据键获取值
        //Integer i = map.get("jj");
       //第一种遍历方法
        //获取所有键的集合
        Set<String> keySet = map.keySet();//这个set集合中就有迭代器了

        Iterator<String> it = keySet.iterator();
        while (it.hasNext()){
            String str = it.next();
            Integer i1 =  map.get(str);
            System.out.println(i1);
        }
        System.out.println("-----------------------");
        //第二种 增强for循环遍历
        for (String str : map.keySet()){
            Integer i2 = map.get(str);
            System.out.println(i2);
 }

6. Map使用键值对对象找键和值

 //Map集合键值对对象找键和值
        Map<String,String> map = new HashMap<>();
        map.put("jj","maidi");
        map.put("qq","tmac");
        map.put("bb","kobe");
        map.put("vv","king");
        map.put("cc","polo");
        System.out.println(map);
        //获取键值对对象
        //Map.Entry说明Entry是Map的内部接口
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        System.out.println(entrySet);//现在打印出来和这个map是一样的
        //利用迭代器来遍历entrySet
        Iterator<Map.Entry<String,String>> it = entrySet.iterator();
        while (it.hasNext()){
            //获得每一个entry对象
            Map.Entry<String,String> en = it.next();
            //获取key和值
            String key = en.getKey();
            String value = en.getValue();
            System.out.println(key);
            System.out.println(value);

        }
        System.out.println("下面是增强for循环的结果");
        //用增强for循环解决
        for (Map.Entry<String,String> en : entrySet){
            String key = en.getKey();
            String value = en.getValue();
            System.out.println(key);
            System.out.println(value);
        }
      

7. LinkedHashMap

 //LinkedHashMap
        LinkedHashMap<String,Integer> lhm = new LinkedHashMap<>();
        lhm.put("t",3);
        lhm.put("j",5);
        lhm.put("w",2);
        lhm.put("i",5);
        System.out.println(lhm);
        //打印出来发现是怎么存怎么取的
       

8.

 //TreeMap集合--第一种比较，重写自定义类的方法
        TreeMap<Student,String> tm = new TreeMap<>();
        tm.put(new Student("tmac",19),"成都");
        tm.put(new Student("tma",123),"上海");
        tm.put(new Student("tm",13),"北京");
        tm.put(new Student("t",18),"广州");
        System.out.println(tm);
        //在这里打印tm是会报错的，因为TreeMap会对这个键进行排序，现在
        //我们的键是自定义的学生对象，所以不知道怎么排序，所以我们要去在自定义类中
        //去实现这个Comparable接口
        //这样还是比较复杂的，我们有传比较器的构造方法
        System.out.println("1----------------------");
   
#自定义类中的操作
public class Student implements Comparable<Student> //实现接口
//重写接口中的方法
  //实现这个Comparable<Student>接口，告诉这个TreeMap怎么去比较这个Student
    @Override
    public int compareTo(Student s) {
        int num = this.age - s.age;
        return num == 0 ? this.name.compareTo(s.name) : num;
        //以比较年龄为主要条件，姓名为次要条件
    }

#第二种比较方法—传入匿名内部类
  //在我们创建这个tm1时，就传一个匿名内部类，并重写里面的方法
        TreeMap<Student,String> tm1 = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getName().compareTo(o2.getName());//前面这个比较是按照码表值比较的(可以传入中文试试)
                 return num == 0 ? o1.getAge() - o2.getAge() : num;//首要按姓名排序，其次年龄
            }

        });
        tm1.put(new Student("蒋介石",19),"成都");
        tm1.put(new Student("曾国藩",89),"上海");
        tm1.put(new Student("易中天",13),"北京");
        tm1.put(new Student("邋遢大王",18),"广州");
        System.out.println(tm1);

9. 统计字符串中字符出现的次数

//小练习--统计字符串中字符出现的次数
        //1.定义一个字符串
        String str = "aaaaaahhhhhhhbbbbbbbddddddduuuuuuiiiiiiii";
        //2.将字符串转为字符数组
        char[] charr = str.toCharArray();
        //3.定义双列集合，存储字符串及字符串出现的次数
        HashMap<Character,Integer> hs = new HashMap<>();
        //4.遍历字符数组中所有字符，并将每个字符存入集合中
        for (char c : charr){
            //存储过程中要判断，如果集合中不包含这个key，就将键和值存入，且值为1.如果包含，就将值加1
//            if (!hs.containsKey(c)){
//                hs.put(c,1);
//            }else{
//               hs.put(c, hs.get(c) + 1);
//            }
             hs.put(c, hs.containsKey(c) ? hs.get(c) + 1 : 1 );
             //三目运算符:表达式？ 结果1 : 结果2 (表达式为真，执行结果1,否则执行结果2)
 }
        System.out.println(hs);
 

10. HashMap嵌套HashMap

 //HashMap嵌套HashMap
        //定义一个班级
        HashMap<Student, String> hm88 = new HashMap<>();
        hm88.put(new Student("孙悟空", 23), "fd");
        hm88.put(new Student("泰森", 24), "dd");
        hm88.put(new Student("麦斯", 25), "dd");
        hm88.put(new Student("科比", 26), "fgd");

        //定义另一个班级
        HashMap<Student, String> hm99 = new HashMap<>();
        hm99.put(new Student("Ã∆…Æ", 1023), "±±æ©");
        hm99.put(new Student("ÀÔŒÚø’",1024), "±±æ©");
        hm99.put(new Student("÷Ì∞ÀΩ‰",1025), "…œ∫£");
        hm99.put(new Student("…≥∫Õ…–",1026), "π„÷›");

        //再定义一个HashMap来存，注意键--就是HashMap
        HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
        hm.put(hm88, "µ⁄88∆⁄ª˘¥°∞‡");
        hm.put(hm99, "µ⁄99∆⁄ª˘¥°∞‡");

        //遍历
        for(HashMap<Student, String> h : hm.keySet()) {
            String value = hm.get(h);

            for(Student key : h.keySet()) {
                String value2 = h.get(key);

                System.out.println(key + "=" + value2 + "=" + value);
            }
        }

11. HashMap和Hashtable的简单区别

 //HashMap和Hashtable的区别
        /*共同点:底层都是hash算法，都是双列集合
        不同点:
        HashMap:是线程不安全的，效率高
        2.可以存储null键和null值
        Hashtable:是线程安全的，效率低
        2.不能存储null键和null值
        */

12. 集合框架Collections工具类简单使用

//集合框架Collections工具类
     /*
    public static <T> void sort(List<T> list):排序
    public static <T> int binarySearch(List<?> list,T key):二分查找法
    public static <T> T max(Collection<?> coll):获取最大值
    public static void reverse(List<?> list)
    public static void shuffle(List<?> list)
    */
     //1.排序
        ArrayList<String> list = new ArrayList<>();
        list.add("d");
        list.add("c");
        list.add("a");
        list.add("b");
        System.out.println(list);//ArrayList是怎么存怎么取的
        System.out.println("排序之后");
        //集合工具类Collections的类方法
        Collections.sort(list);
        System.out.println(list);
        System.out.println("1-------------------------");

     //2.二分查找法--根据值返回值在集合中的索引
        //我们用个有序的集合
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("c");
        list1.add("e");
        list1.add("g");
        list1.add("k");
        list1.add("m");
        list1.add("y");
        int num = Collections.binarySearch(list1,"c");
        int num1 = Collections.binarySearch(list1,"k");
        System.out.println(num);
        System.out.println(num1);
        System.out.println("2------------------------------");

     //3. 获取最大值
        String str = Collections.max(list1);
        System.out.println(str);
        System.out.println("3-------------------------------");

    //4. 反转
      Collections.reverse(list1);
        System.out.println(list1);
        System.out.println("4--------------------------------");
    //5. 洗牌--打乱
        Collections.shuffle(list1);
        System.out.println(list1);

13. 斗地主随机发牌实现

//斗地主发牌小游戏
     //1.创建一个集合对象，将所有扑克存进去
        //牌号
        String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        //花色
        String[] color = {"红桃","黑桃","方片","梅花"};
        ArrayList<String>  poker = new ArrayList<>();
        //拼接花色和数字
        for (String s1 : color){
            for (String s2 : num){
                //拼接
               String s3 = s1.concat(s2);
               poker.add(s3);//一副扑克的基本骨架有了
            }
        }
        //System.out.println(poker);
        //添加大小王
        poker.add("小王");
        poker.add("大王");
        System.out.println(poker.size());

        //2.洗牌
        Collections.shuffle(poker);

        //3.发牌--我们需要三个集合当做三个玩家的牌,创建一个集合作为底牌的集合
        ArrayList<String> tmac = new ArrayList<>();
        ArrayList<String> kobe = new ArrayList<>();
        ArrayList<String> mine = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        //for循环发牌
        for (int i = 0; i < poker.size(); i++){
            //先添加底牌
            if (i >= poker.size() - 3){
                dipai.add(poker.get(i));
            }else if(i % 3 == 0){
               //i%3:这个好好想想--在剩余的51张牌中，有17个下标是可以将3整除的
                tmac.add(poker.get(i));
            }else if(i % 3 == 1){
                kobe.add(poker.get(i));
            }else{
                mine.add(poker.get(i));
            }
        }
        //4.看牌
        System.out.println(tmac);
        System.out.println(kobe);
        System.out.println(mine);
        System.out.println(dipai);