2022-08-08 第五组张明敏学习笔记

最新推荐文章于 2024-08-07 21:26:38 发布

小张同学的小张

最新推荐文章于 2024-08-07 21:26:38 发布

阅读量133

点赞数

分类专栏： Java 文章标签：学习 junit 单元测试

本文链接：https://blog.csdn.net/qq_50392643/article/details/126236409

版权

Java 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

这篇博客详细介绍了JUnit单元测试的好处，包括自动化测试、独立性等，并演示了JUnit的Test注解、断言以及测试方法的编写。接着讲解了JDK8的新特性，如Stream API、函数式接口、Optional类，通过实例展示了如何使用这些新特性进行数据处理。此外，还探讨了Java IO流的基本概念、File类的使用以及文件操作的方法。博客最后分享了作者的学习心得。

摘要由CSDN通过智能技术生成

一、JUnit单元测试（重要）

JUnit是一个java语言单元测试框架。

JUnit单元测试好处：

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

jar包

如果要引用第三方的插件，xxx。jar的文件
首先要把这个文件导入到我们的工程下
其次，要添加到工程的依赖目录中

Test注解

是JUnit提供的一个单元测试注解
如果你的工程没有导入JUnit的jar包，Test直接是不认识的

测试方法：

1.不能有返回值
2.不能传参
3.必须有Test注解

 @Test
    public void test01(){
        System.out.println("hell junit");
    }

    @Test
    public void test02(){
        System.out.println("jjjj");
    }

JUnit断言

JUnit的所有的断言都包含Assert类中
这个类提供了很多有用的断言来编写测试用例
只有失败的断言才会被记录

1.assertEquals：检查两个变量或等式是否平衡
2.assertTrue：检查条件是否为真
3.assertFalse：检查条件是否为假
4。assertNotNull：检查对象是否不为空
5.assertNull：检查对象是否为空

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

public class Ch02 {
    @Test
    public void test01(){
        Assert.assertTrue(false);
    }
}

集合的面试题：

1.Hashtable和ConcurrentHashMap性能测试
2.ArrayList和LinkedList性能测试

数组查询快，插入慢，链表插入块，查询慢

1.尾插数组快，链表慢
2.遍历，数组快
3.头插，链表快，数组慢
4.随机删除，如果要过滤，建议用LinkedList

开发中，还是以ArrayList为主。

JDK8新增

stream编程
容器对象功能的增强

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

当我们使用一个流的时候，通常包括三个步骤;
1.获取一个数据源
2.执行操作获取想要的结果
3.每次操作，原有的流对象,返回一个新的Stream对象

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

案例：

public class Ch06 {
    //创建一个复杂的集合1 usage
    List<Person> personList = new ArrayList<>();//创建一个简单的集合
    List<Integer> simpleList = Arrays.asList(15, 22, 9, 11, 33, 52, 14);

    @Before
    public void before() {
        personList.add(new Person("aa",34,1234,"男","长春"));
        personList.add(new Person("cc",45,3455,"男","杭州"));
        personList.add(new Person("ff",54,2345,"男","长春"));
        personList.add(new Person("bd",32,6784,"男","北京"));
        personList.add(new Person("ee",56,6434,"男","上海"));
    }

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

    @Test
    public void testo2() {
        //找到第一个元素
        Optional<Integer> first = simpleList.stream().findFirst();
        //随便找一个
        //如果没有并行，any也是第一个
        Optional<Integer> 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<Integer> collect = simpleList.stream().collect(Collectors.toList());
        System.out.println(collect);
        Set<Integer> collect1 = simpleList.stream().collect(Collectors.toSet());
        System.out.println(collect1);
        Map<Integer, Integer> 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);
    }

    /*
        归约（reduce）缩减，把一个流缩减成一个值，
        可以实现对集合的求和，求乘积，求最值
     */
    @Test
    public void test09(){
        Integer result = simpleList.stream().reduce(1, (n1, n2) -> n1 - n2);
        System.out.println(result);
    }

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

    /*
        分组将集合分为多个map，
        比如员工按性别分组
        员工按薪资是否高于8000分组
     */
    @Test
    public void test11() {
        // 根据工资分组
        Map<Boolean, List<Person>> collect = personList.stream().collect(Collectors.groupingBy(x -> x.getSalary() > 5000));
        System.out.println(collect);
        // 根据性别分组
        Map<String, List<Person>> collect1 = personList.stream().collect(Collectors.groupingBy(Person::getGender));
        System.out.println(collect1);

        // 将员工根据性别分组，再按地区分组
        Map<String, Map<String, List<Person>>> 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<Person> 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<StringBuilder> collect = simpleList.stream().map(item -> {
            StringBuilder strb = new StringBuilder();
            strb.append(item);
            return strb;
        }).collect(Collectors.toList());
        System.out.println(collect);
    }

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

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

    /**
     * 其他操作：合并、去重、限制、跳过。。。。
     */
    @Test
    public void test16() {
        /*
            distinct：去重
            skip：跳过几个数据
            limit：限制使用几个数据
         */
        simpleList
                .stream()
                .distinct()
                .skip(2)
                .limit(6)
                .forEach(System.out::println);


    }

}


public class Person {


    private String name;
    private Integer salary;
    private Integer age;
    private String gender;
    private String area;

    public Person() {
    }

    public Person(String name, Integer salary, Integer age, String gender, String area) {
        this.name = name;
        this.salary = salary;
        this.age = age;
        this.gender = gender;
        this.area = area;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getSalary() {
        return salary;
    }

    public void setSalary(Integer salary) {
        this.salary = salary;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getArea() {
        return area;
    }

    public void setArea(String area) {
        this.area = area;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", area='" + area + '\'' +
                '}';
    }


}

方法：

打印集合元素：simpleList.stream().forEach(System.out::println);

双冒号语法，方法引用：System.out::println

找到第一个元素：Optional<Integer> first = simpleList.stream().findFirst(); first.get()

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

判断有没有任意一个人年龄大于35岁：boolean b = personList.stream().anyMatch(item -> item.getAge() > 35);

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

筛选：List<Person> collect = personList .stream() .filter(item -> item.getSalary() > 5000) .collect(Collectors.toList());

映射：List<StringBuilder> collect = simpleList.stream().map(item -> {
    StringBuilder strb = new StringBuilder();
    strb.append(item);
    return strb;
}).collect(Collectors.toList());

排序：sorted
自然排序：List<String> collect = personList.stream()
        .sorted(Comparator.comparing(Person::getSalary))
        .map(Person::getName)
        .collect(Collectors.toList());

临时排序：List<String> collect1 = personList
        .stream()
        .sorted(Comparator.comparing(Person::getSalary).reversed())
        .map(Person::getName)
        .collect(Collectors.toList());

JDK8：函数是接口

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

Optional类是java8为了解决null问题

JDK8新增：

1.函数是接口
2.箭头函数（lambda表达式），不是java特有
3.Optional类
4.断言
5.Stream编程

二、Java IO流

Input:把数据从物理内存加载到运行内存（读文件）
output:把数据从运行内存写到物理内存（写文件）

java. io包下的类

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

工具类: File操作文件的类

1.文件的路径

正斜杠:左斜杠，撇，/
反斜杠:右斜杠，捺，\
在Unix/Linux，路径的分隔采用正斜杠/,
在windows中，路径分隔采用反斜杠\。
在java中，\代表转义
在File类中，定义了路径分隔符,自动识别操作系统

拼接：System.out.println("e:"+File.separator+"work");
路径分隔符：System.out.println(File.pathSeparator);

File类的构造器

 public static void main(String[] args) {
        //file代表了当前目录
        File file=new File("D:\\IDEA");
        System.out.println("file="+file);
        File file1=new File("D:\\IDEA","20220808");
        System.out.println("file1="+file1);

        File file2=new File(file1,"src");
        System.out.println("file2="+file2);
    }

文件的操作

所有的关于文件属性的操作都是File类解决

        1.exists()           判断File对象是否存在
        2.mkdir()            创建一级目录
        3.mkdirs()           创建多级目录
        4.isDirectory()      是否是目录
        5.isFile()           是否是文件
        6.createNewFile()    创建新文件（不是目录）
        7.canExecute()       是否能执行

public class Ch03 {

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

    @Test
    public void test02() {
        File file = new File("D:\\aaa.txt");
        //如果存在就删除，如果不存在就拉倒
        // file类的删除是不走回收站
        boolean delete = file.delete();
        System.out.println(delete);
    }

    @Test
    public void test03() {
        File file = new File("D:\\a/b/c/d/e/f/g");
        //一层
//        boolean mkdir = file.mkdir();
        //多层
        boolean b = file.mkdirs();
        System.out.println(b);


    }

    @Test
    public void test04() throws IOException {
        //新建某一个路径下的某- -个文件， 这个路径还不存在，没有这个方法， 需要我们封装工具类
        //怎么做?|
        File file = new File("D:/hello/abc. txt");
//        file . mkdirs();
//        file. mkdir();
        File fileParent = file.getParentFile();
        if (!fileParent.exists()) {
            fileParent.mkdirs();
        }
        file.createNewFile();

        System.out.println("D:/hello" + File.separator + "abc. txt");
    }

}