2022-08-08 顾宇佳 学习笔记

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

单元测试的编码规范
1.类名： 定义测试类，类名是由被测试类名Test构成。例如：CalculatorTest
2.包名： 定义的测试类需要放在xxx.xxx.xxx.test包中。例如：packagecom.mylifes1110.test;
3.方法名： 测试方法的方法名有两种定义方式test测试方法和测试方法。例如：testAdd和add
4.返回值： 因为我们的方法只是在类中测试，可以独立运行，所以不需要处理任何返回值，所以这里使用void。例如：public void add();
5.参数列表： 因为我们的方法是用来测试的，至于参数列表的传入是没有必要的。我们在测试的时候自行传入需要的参数测试即可。所以在此参数列表为空。例如：例如：public void add();
6.@Test注解： 测试是需要运行来完成的。如果我们只有一个main方法，显然在结构上还是需要我们去注释掉测试过的。解决此问题这里我们需要在测试方法上方加@Test注解来完成测试，只要是加该注解的方法，可以单独运行此方法来完成测试。
7.@Test注解jar包Junit4、5： @Test注解是需要我们导入jar包才能使用的。jar包有两个分别是：junit-4.13-rc-2和hamcrest-core-1.3。这里我使用的是Junit4，单元测试还有Junit5，版本差异我没有做了解。

测试方法：
1.不能有返回值
2.不能有参数列表
3.要有@Test注解

 JUnit中的所有断言都包含在Assert类中，这个类提供了很多有用的断言来编写测试用例。

断言不成功会抛异常，即使程序正常运行但是结果不正确，也会以失败结束。

断言方法	描述
assertNull(java.lang.Object object)	检查条件是否为空
assertNotNull(java.lang.Object object)	检查条件是否不为空
assertEquals(long expected, long actual)	检查long类型的值是否相等
assertEquals(double expected, double actual, double delta)	检查指定精度的double值是否相等
assertFalse(boolean condition)	检查条件是否为假
assertTrue(boolean condition)	检查条件是否为真

 1.Test

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

 3.After

public class Ch03 {

    @Test
    public void test01() {
        System.out.println("test01方法执行...");
    }
    @Test
    public void test02() {
        System.out.println("test02方法执行...");
    }

    @Before
    public void testBefore(){
        System.out.println("before方法执行...");
    }

    @After
    public void testAfter() {
        System.out.println("after方法执行...");
    }
}
//运行结果：
//before方法执行...
//test01方法执行...
//after方法执行...
//before方法执行...
//test02方法执行...
//after方法执行...

Stream可以看做处理的元素集合一种流

Stream创建

  1.获取一个数据源
 2.执行操作获取想要的结果
 3.每次操作，原有的流对象不改变，返回一个新的Stream对象
Stream可以通过集合数组创建。

1、通过 java.util.Collection.stream() 方法用集合创建流

List list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream stream = list.stream();
// 创建一个并行流
Stream parallelStream = list.parallelStream();

2、使用java.util.Arrays.stream(T[] array)方法用数组创建流

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

3、使用Stream的静态方法：of()、iterate()、generate()

Stream stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);

Stream stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

Stream特性

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

Stream的使用

Optional类是java8为了解决null问题

1.遍历：foreach

2.匹配：match

3.收集：collect

4.规约：reduce

5.筛选：filter

public class StreamTest {
	public static void main(String[] args) {
		List list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
		Stream stream = list.stream();
		stream.filter(x -> x > 7).forEach(System.out::println);
	}
}

6.映射：map  

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

7.排序：sorted

public class StreamTest {
	public static void main(String[] args) {
		List list = Arrays.asList(7, 6, 9, 4, 11, 6);

		// 自然排序
		Optional max = list.stream().max(Integer::compareTo);
		// 自定义排序
		Optional max2 = list.stream().max(new Comparator() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return o1.compareTo(o2);
			}
		});
		System.out.println("自然排序的最大值：" + max.get());
		System.out.println("自定义排序的最大值：" + max2.get());
	}
}

例子：

import org.junit.Before;
import org.junit.Test;

import java.lang.invoke.VarHandle;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Ch06 {

    // 创建一个复杂的集合
    List personList = new ArrayList<>();
    // 创建一个简单的集合
    List simpleList = Arrays.asList(15,22,15,11,33,52,22,14,33,52);

    @Before
    public void before() {
        personList.add(new Person("张三",3000,23,"男","长春"));
        personList.add(new Person("李四",7000,34,"男","西安"));
        personList.add(new Person("王五",5000,22,"女","长春"));
        personList.add(new Person("小明",1000,33,"女","上海"));
        personList.add(new Person("小红",8000,44,"女","北京"));
        personList.add(new Person("小黑",6000,36,"女","南京"));
    }

    @Test
    public void test01(){
        // 打印集合元素
        // 双冒号语法，方法引用
        simpleList.stream().forEach(System.out::println);
        // 其实还可以简化操作
        simpleList.forEach(System.out::println);
    }

    @Test
    public void test02() {
        // 找到第一个元素
        Optional first = simpleList.stream().findFirst();

        // 随便找一个
        // 如果没有并行，any也是第一个
        Optional any = simpleList.stream().findAny();

        System.out.println("第一个：" + first.get());
        System.out.println("任意一个：" + any.get());
    }

    @Test
    public void test03() {
        // 判断有没有任意一个人年龄大于35岁
        // 任意匹配
        boolean b = personList.stream()
                .anyMatch(item -> item.getAge() > 35);
        System.out.println(b);

        // 判断是不是所有人年龄都大于35岁
        b = personList.stream().allMatch(item -> item.getAge() > 35);
        System.out.println(b);
    }

    @Test
    public void Ch07() {

        List collect = simpleList.stream().collect(Collectors.toList());
        System.out.println(collect);
        Set collect1 = simpleList.stream().collect(Collectors.toSet());
        System.out.println(collect1);
        Map map = simpleList.stream()
                .collect(Collectors
                        .toMap(item -> item, item -> item + 1));
        System.out.println(map);
    }

    @Test
    public void Ch08() {
        // 统计
        long count = new Random().ints().limit(50).count();
        System.out.println(count);
        OptionalDouble average = new Random().ints().limit(50).average();
        average.ifPresent(System.out::println);
        int sum = new Random().ints().limit(50).sum();
        System.out.println(sum);
    }

    
    @Test
    public void test09(){
        Integer result = simpleList.stream().reduce(1, (n1, n2) -> n1 - n2);
        System.out.println(result);
    }

    @Test
    public void test10(){
        List list = Arrays.asList("A","B","C");
        String string = list.stream().collect(Collectors.joining("-"));
        System.out.println("拼接后的字符串：" + string);
    }

    
    @Test
    public void test11() {
        // 根据工资分组
        Map> collect = personList.stream().collect(Collectors.groupingBy(x -> x.getSalary() > 5000));
        System.out.println(collect);
        // 根据性别分组
        Map> collect1 = personList.stream().collect(Collectors.groupingBy(Person::getGender));
        System.out.println(collect1);

        // 将员工根据性别分组，再按地区分组
        Map>> collect2 = personList.stream()
                .collect(Collectors.groupingBy(Person::getGender, Collectors.groupingBy(Person::getArea)));
        System.out.println(collect2);
    }

    
    @Test
    public void test12() {
//        simpleList.stream().filter(item -> item > 17).forEach(System.out::println);

        // 筛选员工中工资大于8000的人，并形成新的集合
        List collect = personList
                .stream()
                .filter(item -> item.getSalary() > 5000)
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    
    @Test
    public void test13(){
        // 将员工的工资全部增加1000
//        personList
//                .stream().map(item -> {
//            item.setSalary(item.getSalary() + 1000);
//            return item;
//        }).forEach(System.out::println);
        List collect = simpleList.stream().map(item -> {
            StringBuilder strb = new StringBuilder();
            strb.append(item);
            return strb;
        }).collect(Collectors.toList());
        System.out.println(collect);
    }

    
    @Test
    public void test14() {
        // 将员工按工资由低到高排序（自然排序--升序）
        List collect = personList.stream()
                .sorted(Comparator.comparing(Person::getSalary))
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println(collect);
        // 按照员工工资的降序
        List collect1 = personList
                .stream()
                .sorted(Comparator.comparing(Person::getSalary).reversed())
                .map(Person::getName)
                .collect(Collectors.toList());
        System.out.println(collect1);
    }

    
    @Test
    public void test15(){
        // 在stream中调试，stream不支持debug
        List collect = personList.stream()
                .filter(item -> item.getSalary() > 5000)
                .peek(System.out::println)
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    
    @Test
    public void test16() {
        
        simpleList
                .stream()
                .distinct()
                .skip(2)
                .limit(6)
                .forEach(System.out::println);


    }

}

IO流：对于文件的操作
 Input：把数据从物理内存加载到运行内存。（读文件）
 Output：把数据从运行内存写到物理内存。（写文件）

 java.io包下的类
 计算机的输入输出都是通过二进制(0和1)完成。
 

File操作文件的类
1.文件的路径
  正斜杠：左斜杠，撇，/
  反斜杠：右斜杠，捺，
 在Unix/Linux，路径的分隔采用正斜杠/，
  在windows中，路径分隔采用反斜杠。

  在java中，代表转义

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

绝对路径和相对路径
绝对路径：以盘符开头
相对路径：没有指定的盘符开头

public class Ch02 {

    public static void main(String[] args) {
        // file就代表了当前的目录
        File file1 = new File("E:\workspace\idea");
        System.out.println("file1 = " + file1);
        File file2 = new File("E:\workspace\idea","aaa");
        System.out.println("file2 = " + file2);
        File file3 = new File(file1,"aaa");
        System.out.println("file3 = " + file3);
    }
}

 创建一个文件

 @Test
    public void test01() {
        // 创建一个文件
        File file1 = new File("e:\aaa.txt");
        try {
            file1.createNewFile();
            System.out.println("文件创建成功...");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}