【Java学习笔记】

最新推荐文章于 2024-08-06 10:22:43 发布
最新推荐文章于 2024-08-06 10:22:43 发布
阅读量414 收藏 6
点赞数 4
文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56612950/article/details/136684482
版权

集合进阶

MAP

双列集合的特点

  1. 双列集合一次需要存一对数据，分别为键和值

  2. 键不能重复，值可以重复

  3. 键和值是一一对应的，每一个键只能找到自己对应的值

  4. 键+值这个整体我们称之为“键值对”或者“键值对对象”，在Java中叫做"Entry对象"

  5. Map的常见API

    Map是双列集合的顶层接口，它的功能是全部双列集合都可以继承使用的

    方法名称说明
    V put(K key,V value)添加元素
    V remove(Object key)根据键删除键值对元素
    void clear()移除所有的键值对元素
    boolean containsKey(Object key)判断集合是否包含指定的键
    boolean containsValue(Object value)判断集合是否包含指定的值
    boolean isEmpty()判断集合是否为空
    int size()集合的长度，也就是集合中键值对的个数
    public class MapDemo01 {
    public static void main(String[] args) {
        /*
            V put(K key,V value)                 添加元素
            V remove(Object key)                 根据键删除键值对元素
            void clear()                         移除所有的键值对元素
            boolean containsKey(Object key)      判断集合是否包含指定的键
            boolean containsValue(Object value)  判断集合是否包含指定的值
            boolean isEmpty()                    判断集合是否为空
            int size()                           集合的长度，也就是集合中键值对的个数

         */

        //1.创建Map集合的对象
        Map<String,String> m = new HashMap<>();

        //2.添加元素
        //put方法的细节：
        //添加/覆盖

        //在添加数据的时候，如果键不存在，那么直接把键值对对象添加到Map集合当中
        //在添加数据的时候，如果键存在，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。
        String value1 = m.put("mini", "lary");
        //System.out.println(value1);//null
        m.put("lili","jeck");
        m.put("sary","roen");

        //String value2 = m.put("lili", "jin");
        //System.out.println(value2);//jeck

        //删除
        //String value3 = m.remove("mini");//lary
        //System.out.println(value3);

        //清空
        //m.clear();

        //判断是否包含
        //boolean keyResult = m.containsKey("mini");
        //System.out.println(keyResult);//true

        //boolean valueResult = m.containsValue("lary");
        //System.out.println(valueResult);//true

        //判断map集合是否为空
        //boolean result = m.isEmpty();
        //System.out.println(result);//false

        //返回集合的长度也就是键值对个数
        int size = m.size();
        System.out.println(size);//3

        //3.打印集合
        System.out.println(m);
    }
}

  6. Map的遍历方式（键找值）

    public class MapDemo02 {
    public static void main(String[] args) {
        //Map集合的第一种遍历方式

        //1.创建Map集合的对象
        Map<String,String> m = new HashMap<>();

        //2.添加元素
        m.put("尹志平","小龙女");
        m.put("郭靖","穆念慈");
        m.put("欧阳克","黄蓉");

        //3.通过键找值

        //3.1 获取所有的键，把这些键放到一个单列结合当中
        Set<String> keys = m.keySet();
        //3.2 遍历单列集合，得到每一个键
        //(1)增强for
        /*for (String key : keys) {
            //System.out.println(key);
            //3.3 利用map集合中的键获取对应的值 get
            String value = m.get(key);
            System.out.println(key + "=" + value);
        }*/
        
        //(2)迭代器
        /*Iterator<String> mit = keys.iterator();
        while (mit.hasNext()) {
            String key = mit.next();
            String value = m.get(key);
            System.out.println(key + "=" + value);
        }*/

        //(3)lambda表达式
        keys.forEach(key -> {
                String value = m.get(key);
                System.out.println(key + "=" + value);
            }
        );
    }
}

  7. Map的遍历方式（键值对）

    public class MapDemo03 {
    public static void main(String[] args) {
        //Map集合的第二种遍历方式

        //1.创建Map集合的对象
        Map<String,String> m = new HashMap<>();

        //2.添加元素
        //键：人物的外号
        //值：人物的名字
        m.put("标枪选手","马超");
        m.put("人物挂件","瑶");
        m.put("御龙骑士","小龙女");

        //3.通过键值对对象进行遍历
        //3.1 通过一个方法获取所有的键值对对象，返回一个Set集合
        Set<Map.Entry<String, String>> entries = m.entrySet();
        //3.2 遍历entries这个集合，去得到里面的每一个键值对对象
        //增强for
        /*for (Map.Entry<String, String> entry : entries) {
            //3.3 利用entry调用get方法获取键和值
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }*/

        //迭代器
        /*Iterator<Map.Entry<String, String>> mit = entries.iterator();
        while(mit.hasNext()) {
            Map.Entry<String, String> next = mit.next();
            String key = next.getKey();
            String value = next.getValue();
            System.out.println(key + "=" + value);
        }*/

        //lambda表达式
        entries.forEach(entry -> {
                String key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key + "=" + value);
            }
        );
    }
}

  8. Map的遍历方式（Lambda表达式）

    方法名说明
    default void forEach(BiConsumer<? super K,? super V> action)结合lambda遍历Map集合
    public class MapDemo04 {
    public static void main(String[] args) {
        //Map集合的第三种遍历方式

        //1.创建Map集合的对象
        HashMap<String,String> map = new HashMap<>();

        //2.添加元素
        //键：人物的名字
        //值：名人名言
        map.put("鲁迅","这句话是我说的");
        map.put("曹操","不可能绝对不可能");
        map.put("刘备","接着奏乐接着舞");
        map.put("柯镇恶","看我眼色行事");

        //3.利用lambda表达式进行遍历
        map.forEach((key,value) -> System.out.println(key + "=" + value));
    }
}

HashMap

  1. HashMap的特点

    • HashMap是Map里面的一个实现类
    • 没有额外学习的特有方法，直接使用Map里面的方法就可以了。
    • 特点都是由键决定的：无序、不重复、无索引
    • HashMap跟HashSet底层原理是一模一样的，都是哈希表结构
    • 依赖hashCode方法和equals方法保证键的唯一
    • 如果键存储的是自定义对象，需要重写hashCode和equals方法，如果值存储自定义对象，不需要重写hashCode和equals方法

  2. 案例1——存储学生对象并遍历

    需求：创建一个HashMap集合，键是学生对象（Student），值是籍贯（String）。存储三个键值对元素，并遍历。

    要求：同姓名，同年龄认为是同一个学生。

    public class HashMapDemo01 {
    public static void main(String[] args) {
        /*
            需求：创建一个HashMap集合，
            键是学生对象（Student），
            值是籍贯（String）。
            存储三个键值对元素，并遍历。

            要求：同姓名，同年龄认为是同一个学生。

            核心点：
                HashMap的键位置如果存储的是自定义对象，需要重写hashCode和equals方法
         */

        //1.创建HashMap的对象
        HashMap<Student, String> hm = new HashMap<>();

        //2.创建三个学生对象
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("wangwu", 25);
        Student s4 = new Student("wangwu", 25);

        //3.添加元素
        hm.put(s1,"江苏");
        hm.put(s2,"浙江");
        hm.put(s3,"上海");
        hm.put(s4,"山东");

        //4.遍历集合
        // (1). 键找值
        Set<Student> keys = hm.keySet();
        for (Student key : keys) {
            String value = hm.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("-----------------------------");
        // (2). 键值对
        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        System.out.println("-----------------------------");
        // (3). lambda表达式
        hm.forEach((key, value) -> System.out.println(key + "=" + value));
    }
}

    public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

  3. Map案例2——统计投票人数

    需求：某个班级80名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D），每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多。

    public class HashMapDemo02 {
    public static void main(String[] args) {
        /*
            需求：某个班级80名学生，现在需要组成秋游活动，
            班长提供了四个景点依次是（A、B、C、D），
            每个学生只能选择一个景点，
            请统计出最终哪个景点想去的人数最多。
         */

        //1.需要先让同学们投票

        //定义一个数组，存储4个景点
        String[] arr = {"A","B","C","D"};
        //利用随机数模拟80个同学的投票，并把投票的结果存储起来
        ArrayList<String> list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            int index = r.nextInt(arr.length);
            list.add(arr[index]);
        }

        //2.如果要统计的东西比较多，不方便使用计数器思想
        //我们可以定义map集合，利用集合进行统计
        HashMap<String, Integer> hm = new HashMap<>();

        for (String name : list) {
            //判断当前的景点在map集合当中是否存在
            if(hm.containsKey(name)) {
                //存在
                //先获取当前景点已经被投票的次数
                int count = hm.get(name);
                //表示当前景点又被投了一次
                count++;
                //把新的次数再次添加到集合当中
                hm.put(name,count);
            }else {
                //不存在
                hm.put(name,1);
            }
        }
        System.out.println(hm);

        //3.求最大值
        int max = 0;
        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            int count = entry.getValue();
            if(count > max) {
                max = count;
            }
        }

        System.out.println(max);

        //4.判断哪个景点的次数跟最大值一样，如果一样，打印出来
        for (Map.Entry<String, Integer> entry : entries) {
            int count = entry.getValue();
            if(count == max) {
                System.out.println(entry.getKey());
                break;
            }
        }
    }
}

LinkedHashMap

  1. 由键决定：有序、不重复、无索引
  2. 这里的有序指的是保证存储和取出的元素顺序一致
  3. 原理：底层数据结构依然是哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。
public class LinkedHashMapDemo01 {
    public static void main(String[] args) {
        /*
            由键决定：
                有序、不重复、无索引
            有序:
                保证存储和取出的元素顺序一致
            原理：
                底层数据结构依然是哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。
         */

        //1.创建集合
        LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();

        //2.添加元素
        lhm.put("c",789);
        lhm.put("b",456);
        lhm.put("a",123);
        lhm.put("a",111);

        //3.打印集合
        System.out.println(lhm);
    }
}

TreeMap

  1. TreeMap跟TreeSet底层原理一样，都是红黑树结构的

  2. 由键决定特性：不重复、无索引、可排序

  3. 可排序：对键进行排序

  4. 注意：默认按照键的的从小到大进行排序，也可以自己规定键的排序规则。

  5. 代码书写两种排序规则

    • 实现Comparable接口，指定比较规则
    • 创建集合时传递Comparator比较器对象，指定比较规则。

  6. 案例——TreeMap基本应用

    • 需求1：

      键：整数表示id

      值：字符串表示商品名称

      要求：按照id的升序排列、按照id的降序排列

      public class TreeMapDemo01 {
    public static void main(String[] args) {
        /*
            TreeMap集合：基本应用

            需求1：
                键：整数表示id
                值：字符串表示商品名称
                要求：按照id的升序排列、按照id的降序排列
         */

        //Integer Double默认情况下都是按照升序排列的
        //String 按照字母在ASCII码表中对应的数字升序进行排列
        //abcdefg...

        //1.创建集合对象
        TreeMap<Integer, String> tm = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //o1:当前要添加的元素
                //o2:表示已经在红黑树中存在的元素
                //降序
                return o2 - o1;
            }
        });

        //2.添加元素
        tm.put(5,"可恰可乐");
        tm.put(4,"雷碧");
        tm.put(3,"九个核桃");
        tm.put(2,"炕师傅");
        tm.put(1,"越利奥");

        //3.打印集合(默认按照键的升序进行排列)
        System.out.println(tm);
    }
}

    • 需求2：

      键：学生对象

      值：籍贯

      要求：按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。

      public class TreeMapDemo02 {
    public static void main(String[] args) {
        /*
            需求2：
                键：学生对象
                值：籍贯
                要求：按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。
         */

        //1.创建集合
        TreeMap<Student, String> tm = new TreeMap<>();

        //2.创建三个学生对象
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("wangwu", 25);

        //3.添加元素
        tm.put(s1,"贵州");
        tm.put(s2,"四川");
        tm.put(s3,"云南");

        //4.打印集合
        System.out.println(tm);
    }
}

      public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }

    @Override
    public int compareTo(Student o) {
        //按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。

        //this:表示当前要添加的元素
        //o:表示已经在红黑树中存在的元素

        //返回值：
        //负数：表示当前要添加的元素是小的，存左边
        //正数：表示当前要添加的元素是大的，存右边
        //0：表示当前要添加的元素已经存在，舍弃

        int i = this.getAge() - o.getAge();
        i = i == 0 ? this.getName().compareTo(o.getName()) : i;
        return 1;
    }
}

  7. 案例——统计个数

    需求：字符串"aababcabcdabcde"

    请统计字符串中每一个字符出现的次数，并按照以下格式输出

    输出结果：

    ​ a(5)b(4)c(3)d(2)e(1)

    public class TreeMapDemo03 {
    public static void main(String[] args) {
        /*
            需求：字符串"aababcabcdabcde"
                请统计字符串中每一个字符出现的次数，并按照以下格式输出

            输出结果：
                a(5)b(4)c(3)d(2)e(1)

            分析:
                统计 ---> 计数器思想
                弊端：如果要统计的东西比较多，非常的不便

                新的统计思想：利用Map集合进行统计
                HashMap：如果说没有要求对结果进行排序，默认使用HashMap
                TreeMap：如果题目要求对结果进行排序，请使用TreeMap

                键：表示要统计的内容
                值：表示次数
         */

        //1.定义字符串
        String s = "aababcabcdabcde";

        //2.创建集合
        TreeMap<Character, Integer> tm = new TreeMap<>();

        //3.遍历字符串得到里面的每一个字符
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            //拿着c到集合中判断是否存在
            //存在，表示当前字符又出现了一次
            //不存在，表示当前字符是第一次出现
            if(tm.containsKey(c)) {
                //存在
                //先把已经出现的次数拿出来
                int count = tm.get(c);
                //当前字符又出现了一次
                count++;
                //把自增之后的结果再添加到集合当中
                tm.put(c,count);
            }else {
                //不存在
                tm.put(c,1);
            }
        }

        //4.遍历集合并按照指定的格式进行拼接
        //StringBuilder
        //StringBuilder sb = new StringBuilder();
        //tm.forEach((key, value) -> sb.append(key).append("(").append(value).append(")"));
        //System.out.println(sb);

        //StringJoiner
        StringJoiner sj = new StringJoiner("", "", "");
        tm.forEach((key, value) -> sj.add(key + "").add("(").add(value + "").add(")"));
        System.out.println(sj);
    }
}

源码解析

此处直接观看b站黑马程序员原视频，讲的很详细更好理解

https://www.bilibili.com/video/BV1yW4y1Y7Ms/?p=20&spm_id_from=pageDriver&vd_source=4847e0790f16c81923882ffffc58528b

可变参数

案例——可变参数的练习

假如需要定义一个方法求和，该方法可以灵活的完成如下需求：

计算2个数据的和、计算3个数据的和、计算4个数据的和、计算n个数据的和

public class ArgsDemo01 {
    public static void main(String[] args) {
        /*
            假如需要定义一个方法求和，
            该方法可以灵活的完成如下需求：
            计算2个数据的和、
            计算3个数据的和、
            计算4个数据的和、
            计算n个数据的和
         */

        System.out.println(getSum(10,20));
        System.out.println(getSum(10,20,30));
        System.out.println(getSum(10,20,30,40));
    }

    //计算2个数据的和
    private static int getSum(int a, int b) {
        return a + b;
    }

    //计算3个数据的和
    private static int getSum(int a, int b,int c) {
        return a + b + c;
    }

    //计算4个数据的和
    private static int getSum(int a, int b,int c,int d) {
        return a + b + c + d;
    }
}

public class ArgsDemo02 {
    public static void main(String[] args) {
        //计算n个数据的和
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int sum = getSum(arr);
        System.out.println(sum);

    }

    public static int getSum(int[] arr) {
        int sum = 0;
        for (int i : arr) {
            sum = sum + i;
        }
        return sum;
    }
}

public class ArgsDemo03 {
    public static void main(String[] args) {
        //计算n个数据的和
        //JDK5提出可变参数的概念
        //方法形参的个数是可以发生变化的，0、1、2、...
        //格式：属性类型...名字
        //int...args

        System.out.println(getSum(1, 2, 3, 4));
    }

    //底层：
    //可变参数底层就是一个数组
    //只不过不需要我们自己创建了，Java会帮我们创建好
    private static int getSum(int...args) {
        //System.out.println(args);//[I@1b6d3586
        int sum = 0;
        for (int i : args) {
            sum = sum + i;
        }
        return sum;
    }
}


public class ArgsDemo04 {
    public static void main(String[] args) {
        //可变参数的小细节：
        //1.在方法的形参中最多只能写一个可变参数
        //可变参数，理解为一个大胖子，有多少吃多少

        //2.在方法当中，如果除了可变参数以外，还有其他的形参，那么可变参数要写在最后
        getSum(1,2,3,4,5,6,7,8,9,10);
    }

    private static int getSum(int i, int...args) {
        return 0;
    }
}

Collections

  1. Collections

    • java.util.Collections：是集合工具类
    • 作用：Collections不是集合，而是集合的工具类

  2. Collections常用的API

    方法名称说明
    public static boolean addALL(Collection c,T…elements)批量添加元素
    public static void shuffle(List<?> list)打乱List集合元素的顺序
    public static void sort(List list)排序
    public static void sort(List list,Comparator c)根据指定的规则进行排序
    public static int binarySearch(List list,T key)以二分查找法查找元素
    public static void copy(List dest,List src)拷贝集合中的元素
    public static int fill(List list,T obj)使用指定的元素填充集合
    public static void max/min(Collection coll)根据默认的自然排序获取最大/最小值
    public static void swap(List<?> list,int i,int j)交换集合中指定位置的元素
  3. public class CollectionsDemo01 {
    public static void main(String[] args) {
        /*
            public static <T> boolean addALL(Collection<T> c,T...elements) 批量添加元素
            public static void shuffle(List<?> list)                       打乱List集合元素的顺序
         */

        //addAll 批量添加元素
        //1.创建集合对象
        ArrayList<String> list = new ArrayList<>();

        //2.批量添加元素
        Collections.addAll(list,"qwe","rty","uio","pas","dfg","hjk");

        //3.打印集合
        System.out.println(list);//[qwe, rty, uio, pas, dfg, hjk]

        //shuffle 打乱
        Collections.shuffle(list);
        System.out.println(list);//[qwe, pas, rty, dfg, uio, hjk]
    }
}

综合练习（集合的嵌套，斗地主等）

  1. 案例——自动点名器1

    班级里有N个学生，实现随机点名器

    public class Test01 {
    public static void main(String[] args) {
        /*
            案例1：
                班级里有N个学生，
                学生属性：姓名、年龄、性别
                实现随机点名器
         */

        //1.定义集合
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list,"叶修","苏沐秋","苏沐橙","韩文清","张新杰","喻文州","黄少天","周泽楷","江波涛","王杰希","楚云秀","方锐","肖时钦","孙翔");
        //3.随机点名
        Random r = new Random();
        //14 0~13
        /*int index = r.nextInt(list.size());
        String name = list.get(index);
        System.out.println(name);*/

        //打乱
        Collections.shuffle(list);
        String name = list.get(0);
        System.out.println(name);
    }
}

  2. 案例——自动点名器2

    班级里有N个学生

    要求：

    70%的概率随机到男生

    30%的概率随机到女生

    public class Test02 {
    public static void main(String[] args) {
        /*
            班级里有N个学生
            要求：
                70%的概率随机到男生
                30%的概率随机到女生

            "叶修","苏沐秋","韩文清","张新杰","喻文州","黄少天","周泽楷","江波涛","王杰希","方锐","肖时钦","孙翔"
            "苏沐橙","楚云秀","唐柔","戴妍琦"
         */

        //1.创建集合
        ArrayList<Integer> list = new ArrayList<>();
        //2.添加数据
        //1111111 000
        Collections.addAll(list,1,1,1,1,1,1,1);
        Collections.addAll(list,0,0,0);
        //3.打乱集合中的数据
        Collections.shuffle(list);
        //System.out.println(list);
        //4.从list集合中随机抽取0或1
        Random r = new Random();
        int index = r.nextInt(list.size());
        int number = list.get(index);
        //System.out.println(number);

        //5.创建两个集合分别存储男生和女生的名字
        ArrayList<String> boyList = new ArrayList<>();
        ArrayList<String> girlList = new ArrayList<>();

        Collections.addAll(boyList,"叶修","苏沐秋","韩文清","张新杰","喻文州","黄少天","周泽楷","江波涛","王杰希","方锐","肖时钦","孙翔");
        Collections.addAll(girlList,"苏沐橙","楚云秀","唐柔","戴妍琦");

        //6.判断此时是从boyList里面抽取还是从girlList中抽取
        String name;
        if(number == 1) {
            //boyList
            int boyIndex = r.nextInt(boyList.size());
            name = boyList.get(boyIndex);
            //System.out.println(name);
        }else {
            //girlList
            int girlIndex = r.nextInt(girlList.size());
            name = girlList.get(girlIndex);
            //System.out.println(name);
        }
        System.out.println(name);
    }
}

  3. 案例——自动点名器3

    班级里有N个学生

    要求：

    被点到的学生不会再被点到，但是如果班级中所有的学生都点完了，需要重新开启第二轮点名。

    public class Test03 {
    public static void main(String[] args) {
        /*
            班级里有N个学生
            要求：
                被点到的学生不会再被点到，
                但是如果班级中所有的学生都点完了，
                需要重新开启第二轮点名。
         */

        //1.定义集合
        ArrayList<String> list1 = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list1, "叶修", "苏沐秋", "韩文清", "张新杰", "喻文州", "黄少天", "周泽楷", "江波涛", "王杰希", "方锐", "肖时钦", "孙翔", "苏沐橙", "楚云秀", "唐柔", "戴妍琦");
        //创建一个临时的集合，用来存已经被点到的学生的名字
        ArrayList<String> list2 = new ArrayList<>();
        //外循环：表示轮数
        for (int i = 0; i < 10; i++) {
            System.out.println("===================第" + (i+1) + "轮点名开始了！===================");
            //3.获取集合长度
            int count = list1.size();
            //4.随机点名
            Random r = new Random();
            //内循环：每一轮中随即循环抽取的过程
            for (int j = 0; j < count; j++) {
                int index = r.nextInt(list1.size());
                String name = list1.remove(index);//每删除一次list.size()就减1
                list2.add(name);
                System.out.println(name);
            }
            //此时表示一轮点名结束
            //list1空了,list2中是所有学生的名字
            list1.addAll(list2);
            list2.clear();
        }
    }
}

  4. 案例——自动点名器4

    TXT文件中事先准备好80个学生的姓名，每个学生的名字独占一行。

    要求1：每次被点到的学生，再次被点到的概率在原先的基础上降低一半。

    举例：80个学生，点名5次，每次都点到小A，概率变化情况如下：

    ​ 第一次每人概率：1.25%

    ​ 第二次小A概率：0.625% 其他学生概率：1.2579%

    ​ 第三次小A概率：0.3125% 其他学生概率：1.261867%

    ​ 第四次小A概率：0.15625% 其他学生概率：1.2638449%

    ​ 第五次小A概率：0.078125% 其他学生概率：1.26483386%

    要求2：作弊要求，第三次点名一定是张三。

    提示：本题需要用到集合，IO，权重随机算法，有基础的可以试试，0基础的等学完IO后再做。

  5. 案例——自动点名器5

    图形化界面

  6. 案例——Map集合，省和市

    需求：

    ​ 定义一个Map集合，键表示省份名称province，值表示市city，但是市会有多个。添加完毕后，遍历结果格式如下：

    江苏省=南京市，扬州市，苏州市，无锡市，常州市

    湖北省=武汉市，孝感市，十堰市，宜昌市，鄂州市

    河北省=石家庄市，唐山市，邢台市，保定市，张家口市

    public class Test06 {
    public static void main(String[] args) {
        /*
            需求：
            定义一个Map集合，键表示省份名称province，
            值表示市city，但是市会有多个。添加完毕后，
            遍历结果格式如下：
                江苏省=南京市，扬州市，苏州市，无锡市，常州市
                湖北省=武汉市，孝感市，十堰市，宜昌市，鄂州市
                河北省=石家庄市，唐山市，邢台市，保定市，张家口市
         */

        //1.创建Map集合
        HashMap<String, ArrayList<String>> hm = new HashMap<>();

        //2.创建单列集合存储市
        ArrayList<String> city1 = new ArrayList<>();
        city1.add("南京市");
        city1.add("扬州市");
        city1.add("苏州市");
        city1.add("无锡市");
        city1.add("常州市");

        ArrayList<String> city2 = new ArrayList<>();
        city2.add("武汉市");
        city2.add("孝感市");
        city2.add("十堰市");
        city2.add("宜昌市");
        city2.add("鄂州市");

        ArrayList<String> city3 = new ArrayList<>();
        city3.add("石家庄市");
        city3.add("唐山市");
        city3.add("邢台市");
        city3.add("保定市");
        city3.add("张家口市");

        //3.把省份和多个市添加到map集合
        hm.put("江苏省",city1);
        hm.put("湖北省",city2);
        hm.put("河北省",city3);

        //System.out.println(hm);

        //键值对方式遍历
        Set<Map.Entry<String, ArrayList<String>>> entries = hm.entrySet();
        for (Map.Entry<String, ArrayList<String>> entry : entries) {
            String key = entry.getKey();
            ArrayList<String> value = entry.getValue();
            StringJoiner sj = new StringJoiner(", ", "", "");
            for (String city : value) {
                sj.add(city);
            }
            System.out.println(key + " = " + sj);
        }
    }
}

说明：

以上笔记学习是学习b站黑马程序员时记下的笔记，仅限于帮助理解学习，不做任何其他商业用途。

黑马程序员

无浪484
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
Java学习笔记
Piglett的博客
12-30 956
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java 学习笔记
weixin_42098295的博客
05-13 1997
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7635
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
JAVA学习笔记
少年左岚
01-25 1844
学习java~
JAVA学习笔记（韩顺平老师）
2301_77385325的博客
04-19 1832
说明：本文为韩顺平老师的JAVA课程学习笔记，仅供自身学习参考，如有纰漏，请多指教，如有帮助，不胜荣幸。
JAVA学习笔记：目录
任性的生鱼片 的博客
12-28 1981
目录 java学习笔记1：了解java、JDK、JRE、JVM java学习笔记2：JDK下载和安装以及测试控制台测试是否配置成功 java学习笔记3：用记事本写第一个java程序，第一个java程序常见错误总结，第一个java程序详细解析 java学习笔记4：常见的DOS命令和java开发工具 java学习笔记5：eclipse的下载及使用，以及java程序的运行 java学习笔记6：注释、标识...
Java学习笔记一
u013033706的博客
10-23 1494
Java学习笔记一1、Java语言的特点2、Java程序开发过程3、Java虚拟机JVM 学习方式： 书籍：《Java基础教程》 吴仁群 清华大学出版社 1、Java语言的特点 一种面向对象且与平台无关的多线程动态语言 2、Java程序开发过程 文件名.java产生applicationapplets源文件编辑器Java编译器字节码文件由Java解释器执行由Web浏览器执行 图1 Java程...
Java学习笔记目录索引 (持续更新中)
热门推荐
Guizy
01-15 12万+
Java学习路线目录索引 一、Java基础(省略) Lambda表达式及函数式接口 二、Java数据库 MySQL 一 概念、DDL、DML、DQL、事务、约束等 数据库设计 一 多表关系、三大范式 JDBC 一 基本使用、DAO组件、连接池、JDBCTemplate 三、JavaWeb HTML相关学习 CSS — 常用属性 CSS — 选择器及三大特性 CSS — 网页的布局方式 C...........................
Java 学习笔记：面向对象
Li__Daxia的博客
03-19 1045
Java 学习笔记：面向对象
java学习笔记（详细）
WD
02-08 8595
java学习笔记 文章目录java学习笔记1.基本的输入输出2.基本数据类型3.复合数据类型4.程序流程语句5.数组6.字符串7.面向对象* 类的基本知识* 封装性* 继承性* 多态性 1.基本的输入输出 java是纯面向对象的语言，连主函数都写在一个类中，java中没有指针 java 用类声明对象的时候 ，实际上，该对象只是一个能够引用对象的简单变量。该声明要创建一个对象的实际的物理拷贝，...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 462
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 224
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1297
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
枚举工具类
qq_43049583的博客
08-04 461
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 535
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
Servlet(2)
xjdkxnhcoskxbco的博客
08-04 762
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
Java学习笔记：从入门到精通
"这是一份详尽的Java学习笔记电子书，特别适合初学者。书中内容细致入微，涵盖了从基础到进阶的各种知识点，通过图片形式生动地展示了Java编程的核心概念。" 在Java学习过程中，了解对象的概念是至关重要的。粗粒度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值