2022-08-08 吉林化工学院 第五组 韩嘉宁（Junity单元测试 流 File类）

JUnit单元测试

一、JUnit（Java语言单元测试框架）

1. JUnit单元测试好处：

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

2. jar包

若需引入第三方插件，xxx.jar的文件

首先将文件导入该工程目录下

其次要将其添加至工程依赖目录下

3. 测试方法

不能有返回值

不能有参数列表

必须有Test注解

4. JUnit断言

1. JUnit的所有断言都包含在Assert类中
2. 这个类提供了许多断言来编写测试用例
3. 只有失败的断言才会被记录
4. 断言不成功会抛异常，帮我们去预判结果，即使程序正常运行但是结果不正确，也会以失败结束

5. Assert中的常用方法

assertEquals：检查两个变量是否相等
assertTrue：检查条件是否为真
assertFalse：检查条件是否为假
assertNotNull：检查对象是否不为空
assertNull：检查对象是否为空

6. JUnit注解

1.Test

2.Before：在测试方法执行之前执行的方法

3.After

测试结果：

7. 命名规范

1. 单元测试类的命名：被测试类的类名 + Test
2. 测试方法的命名： test + 被测试方法的方法名

JDK8新增

1. stream编程
2. 容器对象功能的增强
3. 我们可以将流看做流水线，这个流水线是处理数据的流水线
4. 当我们使用一个流的时候，通常包括三个步骤:
(1) 获取一个数据源
(2) 执行操作获取想要的结果
(3) 每次操作，获取原有的流对象不改变，返回一个新的流对象
5. 函数式接口——必须会
6. 箭头函数（lambda表达式）——必须会【不是Java特有的】
7. Optional类
8. 断言

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);

！！！！过滤筛选

二、IO流

Java I0流---对于文件的操作

Input:把数据从物理内存加载到运行内存。(读文件) Output:把数据从运行内存写到物理内存。(写文件)

java.io包下的类

计算机的输入输出都是通过二进制完成。

• 0和1

• 工具类：File操作文件得类

  文件的路径：

•  正斜杠：左斜杠，/
  

• 反斜杠：右斜杠，\
  

• 在Unix/Linux，路径的分隔采用正斜杠 /
  

• 在Window中，路径分隔采用反斜杠 \
  

• 在Java中【反斜杠】代表转义
  

• 在File类中，定义了路径分隔符的常量
  

• 绝对路径和相对路径
   绝对路径：以盘符开头
   相对路径：不以盘符开头
  

在File中定义分隔符的常量，自动识别操作系统。

File类

File类的构造器（3种）

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();
    }
}

• 文件删除（delete（）不走回收站）
• createNewFile() :创建文件，不创建文件夹

面试题

1.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));
}

2.ArrayList 和 LinkedList性能测试

1. 数组查询快插入慢，链表插入快查询慢
2. 尾插数组快，链表慢
3. 数组遍历快
4. 头插链表快，数组慢
5. 随机删除建议用LinkedList（要过滤）

知识思维导图如下

原文地址：https://www.cnblogs.com/WorkerHevien/p/16564412.html