2022-08-08 第一组顾元皓

最新推荐文章于 2024-07-28 19:41:52 发布

激进的香芋

最新推荐文章于 2024-07-28 19:41:52 发布

阅读量80

点赞数 1

文章标签： junit 单元测试 java

本文链接：https://blog.csdn.net/qq_55019823/article/details/126235519

版权

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