黑马全套Java教程(八):集合进阶(下)

简介: 黑马全套Java教程(八):集合进阶

32.5 类型通配符



package myGeneric.Demo5;
import java.util.ArrayList;
import java.util.List;
public class Demo1 {
    public static void main(String[] args) {
        //类型通配符: <?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("----------------------");
        //类型通配符上限:<? extends 类型>
        //List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("------------------------");
        //类型通配符下限: <? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
        //List<? super Number> list9 = new ArrayList<Integer>();
    }
}


32.6 可变参数



package myGeneric.Demo6;
//测试类
public class Demo1 {
    public static void main(String[] args) {
        System.out.println(sum(10, 20));
        System.out.println(sum(10, 20, 30));
        System.out.println(sum(10, 20, 30, 40));
        System.out.println(sum(10, 20, 30, 40, 50));
        System.out.println(sum(10, 20, 30, 40, 50, 60));
        System.out.println(sum(10, 20, 30, 40, 50, 60, 70));
    }
//    public static int sum(int a, int b) {
//        return a + b;
//    }
//
//    public static int sum(int a, int b, int c) {
//        return a + b + c;
//    }
//
//    public static int sum(int a, int b, int c, int d) {
//        return a + b + c + d;
//    }
//
//    public static int sum(int... a) {  //a其实是数组
//        int sum = 0;
//        for (int i : a) {
//            sum += i;
//        }
//        return sum;
//    }
    public static int sum(int b, int... a){
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        return sum;
    }
}



<32>


32.7 可变参数的使用



package myGeneric.Demo6;
/*
    Arrays工具类中有一个静态方法:
        public static <T> List<T> saList(T... a): 返回由指定数组支持的固定大小的列表
    List接口中有一个静态方法
        public static <E> List<E> of (E... elements): 返回包含任意数量元素的不可变列表
    Set接口中有一个静态方法:
        public static <E> Set<E> of (E... elements): 返回一个包含任意数量元素的不可变集合
 */
import java.util.Arrays;
import java.util.List;
import java.util.Set;
public class Demo2 {
    public static void main(String[] args) {
        //1.
        List<String> list = Arrays.asList("hello", "world", "java", "world");
        System.out.println(list);
        //list.add("javaee");  //java.lang.UnsupportedOperationException
        //list.remove("hello");   //UnsupportedOperationException
        list.set(2, "javaee");
        System.out.println(list);
        System.out.println("------------------");
        //2.
        List<String> list1 = List.of("hello", "world", "java", "world");
        System.out.println(list1);
        //add报错
        //remove报错
        //list1.set(3,"javaee");报错
        System.out.println("--------------------");
        //3.
        //Set<String> set = Set.of("hello", "world", "java", "hello");  //报错 IllegalArgumentException
        Set<String> set = Set.of("hello", "world", "java");
        System.out.println(set);
        //add报错
        //remove报错
        //set没有修改方法
    }
}



33 Map集合


33.1 Map集合概述



package myMap.Demo1;
import java.util.HashMap;
import java.util.Map;
/*
    Map集合概述
        Interface Map<K,V>  K:键的类型 V:值的类型
        将键映射到值的对象:不能包含重复的键;每个键可以映射到最多一个值
        举例:学生的学号和姓名
            01  林青霞
            02  张曼玉
            03  王祖贤
        创建Map集合的对象
            多态的方式
            具体的实现类HashMap
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();
        //put
        map.put("01", "林青霞");
        map.put("02", "张曼玉");
        map.put("03", "王祖贤");
        map.put("03", "张三");      //替代,相当于修改
        //输出集合对象
        System.out.println(map);
    }
}



33.2 Map集合的基本功能



package myMap.Demo1;
import java.util.HashMap;
import java.util.Map;
public class Demo2 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();
        //put添加元素
        map.put("林青霞", "张三");
        map.put("郭靖", "张三");
        map.put("杨过", "小龙女");
        //输出
        System.out.println(map);
        System.out.println("---------------------");
        //2.remove
        System.out.println(map.remove("郭靖"));
        System.out.println(map.remove("李四"));
        System.out.println(map);
        System.out.println("-----------------------");
        //containsKey()
        System.out.println(map.containsKey("林青霞"));
        System.out.println(map.containsKey("李四"));
        System.out.println(map);
        System.out.println("-------------------------");
        //containsValue
        System.out.println(map.containsValue("张三"));
        System.out.println(map.containsValue("李四"));
        System.out.println("--------------------------");
        //size()
        System.out.println(map.size());
        System.out.println("------------------------------");
        //2.clear
        map.clear();
        System.out.println(map);
        System.out.println("-----------------------------");
        //isEmpty
        System.out.println(map.isEmpty());
    }
}



33.3 Map集合的获取功能



package myMap.Demo1;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo3 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();
        //添加元素
        map.put("张无忌", "张三");
        map.put("郭靖", "张三");
        map.put("杨过", "张三");
        System.out.println(map);
        //get根据键获取值
        System.out.println(map.get("张无忌"));
        System.out.println(map.get("张三"));
        System.out.println("------------------------------");
        //keySet获取所有键的集合
        Set<String> keySet = map.keySet();
        System.out.println(keySet);
        System.out.println("------------------------");
        //获取所有值的集合
        Collection<String> values = map.values();
        System.out.println(values);
    }
}



33.4 Map集合的遍历


方式一:



package myMap.Demo1;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo4 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();
        //添加元素
        map.put("张无忌", "张三");
        map.put("郭靖", "张三");
        map.put("杨过", "张三");
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}



方式二:



package myMap.Demo1;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo5 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();
        //添加元素
        map.put("张无忌", "张三");
        map.put("郭靖", "张三");
        map.put("杨过", "张三");
        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}


案例:存储学生对象并遍历



package myMap.Demo2;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo1 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<String, Student> hm = new HashMap<>();
        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);
        //添加
        hm.put("01", s1);
        hm.put("02", s2);
        hm.put("03", s3);
        //方式一:键找值
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            Student value = hm.get(key);
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
        System.out.println("------------------------------");
        //方式二,获取键值对
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        for (Map.Entry<String, Student> i : entrySet) {
            String key = i.getKey();
            Student value = i.getValue();
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
    }
}



案例二



这里Student需要重写hashCode和equals



package myMap.Demo3;
import java.util.HashMap;
import java.util.Set;
public class Demo1 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student, String> hm = new HashMap<>();
        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);
        Student s4 = new Student("王祖贤", 20);
        //添加
        hm.put(s1, "西安");
        hm.put(s2, "武汉");
        hm.put(s3, "郑州");
        hm.put(s4, "北京");
        System.out.println(hm);
        //遍历
        Set<Student> keySet = hm.keySet();
        for (Student key : keySet) {
            String value = hm.get(key);
            System.out.println(key.getName() + "," + key.getAge() + "," + value);
        }
    }
}


案例三:



package myMap.Demo4;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class Demo1 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<HashMap<String, String>> array = new ArrayList<>();
        //创建HashMap集合对象
        HashMap<String, String> hm1 = new HashMap<>();
        hm1.put("孙策", "大乔");
        hm1.put("周瑜", "小乔");
        HashMap<String, String> hm2 = new HashMap<>();
        hm2.put("郭靖", "黄蓉");
        hm2.put("杨过", "小龙女");
        HashMap<String, String> hm3 = new HashMap<>();
        hm3.put("令狐冲", "任盈盈");
        hm3.put("张三", "李四");
        array.add(hm1);
        array.add(hm2);
        array.add(hm3);
        System.out.println(array);
        //遍历
        for (HashMap<String, String> hm : array) {
            Set<String> keySet = hm.keySet();
            for (String key : keySet) {
                String value = hm.get(key);
                System.out.println(key + "," + value);
            }
            System.out.println("----------------------");
        }
    }
}



案例四:



package myMap.Demo5;
import myMap.Demo3.Student;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class Demo1 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        HashMap<String, ArrayList<String>> hm = new HashMap<>();
        //创建ArrayList集合
        ArrayList<String> sgyy = new ArrayList<>();
        sgyy.add("诸葛亮");
        sgyy.add("赵云");
        ArrayList<String> xyj = new ArrayList<>();
        xyj.add("唐僧");
        xyj.add("孙悟空");
        ArrayList<String> shz = new ArrayList<>();
        shz.add("武松");
        shz.add("鲁智深");
        hm.put("三国演义", sgyy);
        hm.put("西游记", xyj);
        hm.put("水浒传", shz);
        System.out.println(hm);
        //遍历
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            System.out.println(key);
            ArrayList<String> value = hm.get(key);
            for (String s : value) {
                System.out.println("\t" + s);
            }
        }
    }
}



案例五:统计字符串中每个字符出现的次数



package myMap.Demo6;
import java.util.*;
public class Demo1 {
    public static void main(String[] args) {
        //键盘录入字符
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String line = sc.nextLine();
        //创建HashMap集合对象
//        HashMap<Character, Integer> hm = new HashMap<Character, Integer>();
        TreeMap<Character, Integer> hm = new TreeMap<>();
        //遍历字符串
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);   //获取每一个字符
            Integer value = hm.get(key);  // 自动装箱
            if (value == null) {
                hm.put(key, 1);
            } else {
                value++;   // 这里会自动拆箱
                hm.put(key, value);
            }
        }
        //进行拼接
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for (Character key : keySet) {
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String result = sb.toString();   //StringBuilder--->String
        System.out.println(result);
    }
}


33.5 Collections



package myMap.Demo7;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
        System.out.println("正常输出:"+list);
        Collections.sort(list);
        System.out.println("排序:"+list);
        Collections.reverse(list);
        System.out.println("倒序:"+list);
        Collections.shuffle(list);   //随机排序,每次执行结果都不一样
        System.out.println("随机排序:"+list);
    }
}



案例:



package myMap.Demo8;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo1 {
    public static void main(String[] args) {
        ArrayList<Student> array = new ArrayList<>();
        Student s1 = new Student("linqingxia", 18);
        Student s2 = new Student("zhangmanyu", 19);
        Student s3 = new Student("wangzuxian", 20);
        Student s4 = new Student("zhangsan", 18);
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        System.out.println(array);
        for (Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}



33.6 模拟斗地主



package myMap.Demo9;
import java.util.ArrayList;
import java.util.Collections;
public class Demo1 {
    public static void main(String[] args) {
        //创建一个牌盒
        ArrayList<String> array = new ArrayList<>();
        //装牌
        //定义花色数组
        String[] colors = {"♦", "♣", "♥", "♠"};
        //定义点数数组
        String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        for (String color : colors) {
            for (String number : numbers) {
                array.add(color + number);
            }
        }
        array.add("小王");
        array.add("大王");
        System.out.println(array);
        //洗牌
        Collections.shuffle(array);
        System.out.println(array);
        //发牌
        //创建三个玩家
        ArrayList<String> lqxArray = new ArrayList<>();
        ArrayList<String> zmyArray = new ArrayList<>();
        ArrayList<String> wzxArray = new ArrayList<>();
        ArrayList<String> dpArray = new ArrayList<>();
        for (int i = 0; i < array.size(); i++) {
            String poker = array.get(i);
            if (i >= array.size() - 3) {
                dpArray.add(poker);
            } else if (i % 3 == 0) {
                lqxArray.add(poker);
            } else if (i % 3 == 1) {
                zmyArray.add(poker);
            } else if (i % 3 == 2) {
                wzxArray.add(poker);
            }
        }
        //看牌
        lookPoker("林青霞", lqxArray);
        lookPoker("张曼玉", zmyArray);
        lookPoker("王祖贤", wzxArray);
        lookPoker("底牌", dpArray);
    }
    //看牌方法
    public static void lookPoker(String name, ArrayList<String> array) {
        System.out.print(name + "的牌是:");
        for (String poker : array) {
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}



案例二:升级版




package myMap.Demo9;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class Demo2 {
    public static void main(String[] args) {
        //创建HashMap集合,键是编号,值是牌
        HashMap<Integer, String> hm = new HashMap<>();
        //创建ArrayList存储编号
        ArrayList<Integer> array = new ArrayList<>();
        //定义花色数组
        String[] colors = {"♦", "♣", "♥", "♠"};
        //定义点数数组
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        //存储键值对,装牌
        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                hm.put(index, color + number);
                array.add(index);
                index++;
            }
        }
        hm.put(index, "小王");
        array.add(index);
        index++;
        hm.put(index, "大王");
        array.add(index);
        //洗牌
        Collections.shuffle(array);
        //发牌,发编号
        TreeSet<Integer> lqxSet = new TreeSet<>();
        TreeSet<Integer> zwySet = new TreeSet<>();
        TreeSet<Integer> wzxSet = new TreeSet<>();
        TreeSet<Integer> dpSet = new TreeSet<>();
        for (int i = 0; i < array.size(); i++) {
            int x = array.get(i);  //索引
            if (i >= array.size() - 3) {
                dpSet.add(x);
            } else if (i % 3 == 0) {
                lqxSet.add(x);
            } else if (i % 3 == 1) {
                zwySet.add(x);
            } else if (i % 3 == 2) {
                wzxSet.add(x);
            }
        }
        //看牌
        lookPoker("林青霞", lqxSet, hm);
        lookPoker("张曼玉", zwySet, hm);
        lookPoker("王祖贤", wzxSet, hm);
        lookPoker("底牌", dpSet, hm);
    }
    public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {
        System.out.print(name + "的牌是:");
        for (Integer key : ts) {
            String poker = hm.get(key);
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}


本博客内容长了点,包含了黑马讲的所有集合类了,到视频d271截止!


只做代码记录,后续遗忘方便学习而已

目录
打赏
0
0
0
0
16
分享
相关文章
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
142 96
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
Java 集合框架中的老炮与新秀:HashTable 和 HashMap 谁更胜一筹?
嗨,大家好,我是技术伙伴小米。今天通过讲故事的方式,详细介绍 Java 中 HashMap 和 HashTable 的区别。从版本、线程安全、null 值支持、性能及迭代器行为等方面对比,帮助你轻松应对面试中的经典问题。HashMap 更高效灵活,适合单线程或需手动处理线程安全的场景;HashTable 较古老,线程安全但性能不佳。现代项目推荐使用 ConcurrentHashMap。关注我的公众号“软件求生”,获取更多技术干货!
51 3
自研Java框架 Sunrays-Framework使用教程「博客之星」
### Sunrays-Framework:助力高效开发的Java微服务框架 **Sunrays-Framework** 是一款基于 Spring Boot 构建的高效微服务开发框架,深度融合了 Spring Cloud 生态中的核心技术组件。它旨在简化数据访问、缓存管理、消息队列、文件存储等常见开发任务,帮助开发者快速构建高质量的企业级应用。 #### 核心功能 - **MyBatis-Plus**:简化数据访问层开发,提供强大的 CRUD 操作和分页功能。 - **Redis**:实现高性能缓存和分布式锁,提升系统响应速度。 - **RabbitMQ**:可靠的消息队列支持,适用于异步
自研Java框架 Sunrays-Framework使用教程「博客之星」
探究Java异常处理【保姆级教程】
Java 异常处理是确保程序稳健运行的关键机制。它通过捕获和处理运行时错误,避免程序崩溃。Java 的异常体系以 `Throwable` 为基础,分为 `Error` 和 `Exception`。前者表示严重错误,后者可细分为受检和非受检异常。常见的异常处理方式包括 `try-catch-finally`、`throws` 和 `throw` 关键字。此外,还可以自定义异常类以满足特定需求。最佳实践包括捕获具体异常、合理使用 `finally` 块和谨慎抛出异常。掌握这些技巧能显著提升程序的健壮性和可靠性。
47 4
【潜意识Java】Java基础教程:从零开始的学习之旅
本文介绍了 Java 编程语言的基础知识,涵盖从简介、程序结构到面向对象编程的核心概念。首先,Java 是一种高级、跨平台的面向对象语言,支持“一次编写,到处运行”。接着,文章详细讲解了 Java 程序的基本结构,包括包声明、导入语句、类声明和 main 方法。随后,深入探讨了基础语法,如数据类型、变量、控制结构、方法和数组。此外,还介绍了面向对象编程的关键概念,例如类与对象、继承和多态。最后,针对常见的编程错误提供了调试技巧,并总结了学习 Java 的重要性和方法。适合初学者逐步掌握 Java 编程。
52 1
Java最新图形化界面开发技术——JavaFx教程(含UI控件用法介绍、属性绑定、事件监听、FXML)
JavaFX是Java的下一代图形用户界面工具包。JavaFX是一组图形和媒体API,我们可以用它们来创建和部署富客户端应用程序。 JavaFX允许开发人员快速构建丰富的跨平台应用程序,允许开发人员在单个编程接口中组合图形,动画和UI控件。本文详细介绍了JavaFx的常见用法,相信读完本教程你一定有所收获!
1303 1
Java最新图形化界面开发技术——JavaFx教程(含UI控件用法介绍、属性绑定、事件监听、FXML)
Liunx部署java项目Tomcat、Redis、Mysql教程
本文详细介绍了如何在 Linux 服务器上安装和配置 Tomcat、MySQL 和 Redis,并部署 Java 项目。通过这些步骤,您可以搭建一个高效稳定的 Java 应用运行环境。希望本文能为您在实际操作中提供有价值的参考。
180 26
Git使用教程-将idea本地Java等文件配置到gitte上【保姆级教程】
本内容详细介绍了使用Git进行版本控制的全过程,涵盖从本地仓库创建到远程仓库配置,以及最终推送代码至远程仓库的步骤。
34 0
Java 集合江湖:底层数据结构的大揭秘!
小米是一位热爱技术分享的程序员,本文详细解析了Java面试中常见的List、Set、Map的区别。不仅介绍了它们的基本特性和实现类,还深入探讨了各自的使用场景和面试技巧,帮助读者更好地理解和应对相关问题。
58 5
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等