目录

JUnit单元测试

 JUnit特点

JUnit单元测试的好处

jar包

JUnit断言

那assert与if的区别是什么

JUnit注解

1.Test

2.Before(不常用)

3.After（不常用）

ArrayList和LinkedList性能测试

使用ArrayList遍历

使用LinkedList

Hashtable和ConcurrentHashMap性能测试

使用Hashtable

使用ConcurrentHashMap（针对高并发）

Stream编程

Stream特点

筛选（重要）

映射（重要）

排序sorted（重要）

JDK8函数式接口（了解）

JUnit单元测试

JUnit是一个Java编程语言编写的单元测试框架。

 JUnit特点

• 提供了注释，以确定测试方法
• 提供断言测试预期结果。
• 提供了测试运行的运行测试。
• JUnit是优雅简洁。它是不那么复杂以及不需要花费太多的时间。
• JUnit测试可以自动运行，检查自己的结果，没有必要通过测试结果报告来手动梳理。

JUnit单元测试的好处

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

jar包

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

JUnit断言

java的断言是通过Assert语句来实现的，用于捕获运行时不应该发生的非法情况。如果在执行断言时，对应的断言为真，啥事都没有发生，如果对应的断言为假，JVM会抛出AssertionError的异常

 
 assert ;
 
 assert  : <错误信息表达式>;

断言就像是一个定制化功能的if语句一样。

 int parameter = 0;
 assert parameter!=0;
 int parameter1 = 1;
        if(parameter==0){
            throw new AssertionError();
        }

那assert与if的区别是什么

1. assert语句仅仅在debug版本中才有效，而在release版本中无效；
2. java在执行assert时默认是不启动断言检查的，无论是什么环境下，如果要开启断言检查，则需要增加命令行参数 -enableassertions 或 -ea 来开启。
3. if是正常程序逻辑的一部分，而assert只是用于调试、定位错误。

assertEquals：检查两个变量或等式是否平衡

assertTrue：检查条件是否为真

assertFalse：检查条件是否为假

assertNotNull：检查对象是否不为空

assertNull：检查对象是否为空

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

JUnit注解

1.Test

1.不能有返回值

2.不能有参数列表

3.必须有Test注解

2.Before(不常用)

三种方法都执行

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方法执行...");
    }
}

3.After（不常用）

命名规范：

单元测试类的命名：被测试类的类名 + Test

测试方法的命名：test + 被测试方法的方法名

  @After
    public void testAfter() {
        System.out.println("after方法执行...");
    }

ArrayList和LinkedList性能测试

数组查询快，插入慢；头插：链表快，数组慢；遍历，数组快

链表插入快，查询慢

尾插数组快，链表慢

随机删除，如果要过滤，建议用linkedlist 

• 当for循环遍历，ArrayList用的时间<

使用ArrayList遍历

  @Test
    public void testArrayList() {
        List list = new ArrayList<>();

        for (int i = 0; i < 10000000; i++) {
            list.add((int)Math.random()*100);
        }
        long start = System.currentTimeMillis();
//        for (int i = 0; i < list.size(); i++) {
//            list.get(i);
//        }
        Iterator iterator = list.iterator();
        while(iterator.hasNext()) {
            // 随机删除
            if(iterator.next() > 500){
                iterator.remove();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("arraylist用时：" + (end - start));
    }

使用LinkedList

 @Test
    public void testLinkedList() {
        List list = new LinkedList<>();

        for (int i = 0; i < 10000000; i++) {
            list.add((int)Math.random()*100);
        }
        long start = System.currentTimeMillis();
//        for (int i = 0; i < list.size(); i++) {
//            list.get(i);
//        }
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            if(iterator.next() > 500){
                iterator.remove();
            }
//            iterator.next();
        }
        long end = System.currentTimeMillis();
        System.out.println("linkedlist用时：" + (end - start));
    }

Hashtable和ConcurrentHashMap性能测试

尝试开辟50个线程，每个线程向集合中put100000个元素， 测试两个类所需的时间。

使用Hashtable

 @Test
    public void hashtableTest() throws InterruptedException {
        final Map map = new Hashtable<>(500000);
        // 计数器
//        final CountDownLatch countDownLatch = new CountDownLatch(50);
        System.out.println("开始测试hashtable-----------------------");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 50; i++) {
            final int j = i;
            new Thread(()->{
                for (int k = 0;k < 100000;k++){
                    map.put(j*k,1);
                }
                // 记录添加的数据次数
//                countDownLatch.countDown();
            }).start();
        }
//        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println("hashtable执行了：" + (end - start)); // 1043ms
    }

使用ConcurrentHashMap（针对高并发）

 @Test
    public void testConcurrentHashMap() throws InterruptedException {
        final Map map = new ConcurrentHashMap<>(500000);
        // 计数器
//        final CountDownLatch countDownLatch = new CountDownLatch(50);
        System.out.println("开始测试ConcurrentHashMap-----------------------");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 50; i++) {
            final int j = i;
            new Thread(()->{
                for (int k = 0;k < 100000;k++){
                    map.put(j*k,1);
                }
                // 记录添加的数据次数
//                countDownLatch.countDown();
            }).start();
        }
//        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println("ConcurrentHashMap执行了：" + (end - start)); // 71ms
    }

Stream编程

温馨提示：Stream()是jdk8才有的新特性，如果想使用stream()请保证jdk版本至少是jdk8及jdk8以上。 

---

steam是个单独的接口，用于数据处理

流：流水线就是 处理数据；

当我们使用一个流时，通常包括三个步骤：

1.获取一个数据源

2.执行操作获取想要的结果

3.每次操作，原有的流对象不改变，返回一个新的Stream对象

Stream特点

不存储数据，一般会输出结果

Stream不会改变数据源，通常情况下会生成一个新的集合

Stream具有延迟执行的特性，只有调用终端操作时，中间操作才会执行。

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

先拿到流，再调用方法；item是方法

筛选（重要）

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

排序sorted（重要）

分为：自然排序（升序）、临时排序

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

JDK8函数式接口（了解）

Consumer：消费者 void accept(T t)

Supplier：供应商 T get()

Function： R apply(T t)，将一个数据转化成另一个数据

Predicate：断言，boolean test(T t)，判断返回值是boolean