2022-8-8 第一小组 甘源册 学习笔记

目录

• 知识点掌握情况
• 1.JUnit单元测试
  • 1.1JUnit注解
  • 1.2流式编程
• 2.IO流
  • 2.1工具类（File操作文件的类）：
• 集合的面试题

知识点掌握情况

JUnit单元测试框架（了解） 流式编程（不太懂） File类（了解）集合面试题（理解）

1.JUnit单元测试

• JUnit是一个Java语言单元测试框架

• 好处

  • 可以书写一些列的测试方法，对项目的所有的接口或者方法进行单元测试
  • 启动后，自动化的测试
  • 只需要查看最后的结果
  • 每个单元测试的用例相对独立，由JUnit启动
  • 添加，删除，屏蔽测试方法

• jar包

  • 如果要引入第三方的插件，引入的是xxx.jar的文件
  • 流程
    1. 首先要把这个文件导入到我们的工程目录下。
    2. 要添加到工程的依赖目录中。

• 测试方法：

  • 不能有返回值

  • 不能有参数

  • 必须有Test注解

  •     // Test注解是JUnit提供的一个单元测试的注解,
        // 如果你的工程没有导入JUnit的jar包,Test注解是不认识的
        @Test
        public void test01(){
            System.out.println("ad");
        }
    

• JUnit的断言

  • JUnit所有的断言都包含在一个Assert类当中
    • 这个类提供了很多有用的断言来编写测试用例
    • 只有失败的断言才会被记录
    • 断言不成功会抛异常，帮我们去预判结果，即使程序正常运行但是结果不正确，也会以失败结束
  • 方法
    • assertEquals：检查两个变量或等式是否相等
    • assertTrue：检查条件是否为真
    • assertFalse：检查条件是否为假
    • assertNotNull：检查对象是否不为空
    • assertNull：检查对象是否为空

• 命名规范：

  • 单元测试类的命名：被测试类的类名+Test
  • 测试方法的命名：test+被测试方法的方法名

1.1JUnit注解

• Test

• Before

  • 在测试之前执行的操作

  •     @Before
        public void testBefore(){
            System.out.println("before");
        }
    

• After

  • 在测试之后执行的操作

  •     @After
        public void testAfter(){
            System.out.println("after");
        }
    

1.2流式编程

• JDK8新增

  • Stream编程

  • 容器对象功能的增强

  • 我们可以将流看成流水线，这个流水线是处理数据的流水线

  • 当我们使用流的时候，通常包括3个步骤

    • 获取一个数据源
    • 执行操作获取想要的结果
    • 每次操作，获取原有的流对象不改变，返回一个新的流对象

  • Stream有几个特性：

    • Stream不存储数据，一般会输出结果
    • Stream不会改变数据源，通常会生成新的一个集合
    • Stream具有延迟执行的特性，只有调用中断操作时中间操作才会执行。

  •     // 双冒号语法---方法引用
    // 遍历
            integers.stream().forEach(System.out::println);
            integers.forEach(System.out::println);
    // 查找
            System.out.println(integers.stream().findFirst());
            // 如果没有并行 Any也是第一个
            System.out.println(integers.stream().findAny());
    // 匹配
            // 任意匹配
            boolean b = list.stream().anyMatch(it -> it.getAge() > 35);
            System.out.println(b);
            // 全部匹配
            b = list.stream().allMatch(it -> it.getAge() > 35);
            System.out.println(b);
    // 排序 sorted
            // 自然排序
            System.out.println();
            List<String> collect = list.stream().sorted(
                    Comparator.comparing(Person::getSal)).
                    map(Person::getName).
                    collect(Collectors.toList());
            System.out.println(collect);
    

• 映射

  • 将一个流的元素按照一定的映射规则映射到另一个流中。

• JDK8函数式接口

  • Consumer：消费者 void accept（T t）
  • Supplier：供应商 T get（）
  • Function： R apply（T t），将一个数据转化成另一个数据
  • Predicate：断言 boolean test（T t），判断返回值是Boolean

• JDK8新增

  • 函数式接口——必须会
  • 箭头函数（lambda表达式）——必须会【不是Java特有的】
  • Optional类
  • 断言
  • Stream编程

2.IO流

• IO——InputOutput【对于文件的操作】
  • Input：把数据从物理内存加载到运行内存。（读文件）
  • Output：把数据从运行内存写到物理内存。（写文件）
• java.io包下的类
• 计算机的输入和输出都是通过二进制来完成的。

2.1工具类（File操作文件的类）：

• 文件的路径

  • 正斜杠：左斜杠 ， 撇，/
  • 反斜杠：右斜杠，捺，\
  • 在Unix/Linux，路径的分隔是采用【正斜杠】的
  • 在Windows中，路径分隔采用【反斜杠】。
  • 在Java中【反斜杠】代表转义
  • 在File类中，定义了路径分隔符的常量
  • 绝对路径和相对路径
    • 绝对路径：以盘符开头
    • 相对路径：不以盘符开头

• File类的构造器

  •     File file = new File("C:\\Users\\Administrator\\Documents");
        File file1 = new File("C:\\Users\\Administrator\\Documents","aaa");
        File file2 = new File(file,"aaa");
        System.out.println("file"+file);
        System.out.println("file1"+file1);
        System.out.println("file2"+file2);
    

• 文件的操作

  • 新建文件是不会覆盖已有文件

  •     @Test
        public void test03(){
            File file = new File("c:\\ a");
            File file1 = new File("c:\\ a\\c\\d");
            // 文件夹创建
            boolean mkdir = file.mkdir();
            // 多级文件夹创建
            boolean mkdirs = file1.mkdirs();
            System.out.println("大"+mkdirs);
            System.out.println("都是"+mkdir);
        }
    
        @Test
        public void test02(){
            File file = new File("C:\\aaa.txt");
            // 文件删除
            // file类的删除是不走回收站的
            boolean delete = file.delete();
            System.out.println(delete);
        }
    
        @Test
        public void test01(){
            File file = new File("C:\\aaa.txt");
            try {
                // 文件创建(不创建文件夹)
                file.createNewFile();
                System.out.println("文件创建成功");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    

• File类的方法：

  • ​

集合的面试题

• Hashtable和ConcurrentHashMap性能测试

  •     // 开辟50个线程--每个线程向集合中添加100000个元素 测试两个类所需的时间
        @Test
        public void hashtableTest() throws InterruptedException {
            final Map<Integer, Integer> map =new Hashtable<>(9000000);
            System.out.println("开始测试hashtable-------------");
            long l = System.currentTimeMillis();
            for (int i = 0; i < 50; i++) {
                 int j=i;
                Thread thread = new Thread(()->{
                    for (int i1 = 0; i1 < 1000000; i1++) {
                        map.put(j*i1,i1);
                    }
                });
                thread.start();
            }
            long l1 = System.currentTimeMillis();
            System.out.println("hashtable执行了:"+(l1-l));
        }
        @Test
        public void hashmapTest() throws InterruptedException {
            final Map<Integer, Integer> map =new ConcurrentHashMap<>(5000000);
            System.out.println("开始测试ConcurrentHashMap-------------");
            long l = System.currentTimeMillis();
            for (int i = 0; i < 50; i++) {
                final int j=i;
                Thread thread = new Thread(()->{
                    for (int i1 = 0; i1 < 1000000; i1++) {
                        map.put(j*i1,i1);
                    }
                    // 记录添加数据的次数
                });
                thread.start();
            }
            long l1 = System.currentTimeMillis();
            System.out.println("hashtable执行了:"+(l1-l));
        }
    

• ArrayList和LinkedList性能测试

  • 数组查询快，插入慢，链表插入快，查询慢
  • 遍历数组快
  • 尾插数组快，链表慢
  • 头插链表快，数组慢
  • 随机删除，如果要过滤，建议用链表（LinkedList）
  • 开发中还是以ArrayList为主