2022-08-08 第4组蒋萍 JUnit以及stream编程

“就算步伐很小，也要步步前进”

“就算步伐很小，也要步步前进”
1、JUnite单元测试（重要）
2、stream编程

最近效率真的有点低唉，我得缓缓

1、JUnite单元测试（重要）

是啥？

一个框架

为什么要用？

1、可以书写一系列的测试方法，对项目的所有接口或方法进行单元测试

2、启用单元测试后是个自动化测试

3、只需查看最后结果

4、每个单元测试的用例相对独立，由JUnit启动

5、添加，删除，屏蔽测试方法

jar包 ? ?

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

1.1 Test注解

测试方法

1、不能有返回值

2、不能有参数列表

3、有 Test注解

使用前导入jar包

1.2 JUnit断言(Assert)

是啥？

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

其中的一些静态方法：比如：

断言不成功会抛异常，边爱那个我们预判结果，即使程序正常运行但是结果不正确，也会以失败结束-----> 断言只看结果一样不一样

调用

1.3 Before注解（用的不多）

在测试方法之前执行的方法

1.4 After注解（用的不多）

命名规范:
单元测试类的命名：被测试的类名 + Test
测试方法命名： test + 被测试方法方法名

1.5 ArrayList和LinkedList性能测试

1、尾插数组快，链表慢；头插链表快，数组慢
2、遍历数组快
3、随机删除，如果要过滤，建议用LinkedList
开发中还是以ArrayList为主

for 循环遍历的时候，ArrayList 花费的时间远小于 LinkedList；迭代器遍历的时候，两者性能差不多。

    @Test
    public void testArrayList() {
        List<Integer> 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<Integer> iterator = list.iterator();
        while(iterator.hasNext()) {
            // 随机删除
            if(iterator.next() > 500){
                iterator.remove();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("arraylist用时：" + (end - start));
    }

    @Test
    public void testLinkedList() {
        List<Integer> 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<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            if(iterator.next() > 500){
                iterator.remove();
            }
//            iterator.next();
        }
        long end = System.currentTimeMillis();
        System.out.println("linkedlist用时：" + (end - start));
    }

1.6 HashMap 和 ConcurrentHashMap性能测试

ConcurrentHashMap：应付高并发


    /* 我们尝试开辟50个线程，每个线程向集合中put100000个元素，
        测试两个类所需的时间
     */
    @Test
    public void hashtableTest() throws InterruptedException {
        final Map<Integer,Integer> map = new Hashtable<>(500000);
        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);
                }
            }).start();
        }
        long end = System.currentTimeMillis();
        System.out.println("hashtable执行了：" + (end - start)); // 1043ms
    }


    @Test
    public void testConcurrentHashMap() throws InterruptedException {
        final Map<Integer,Integer> map = new ConcurrentHashMap<>(500000);
        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);
                }
            }).start();
        }
        long end = System.currentTimeMillis();
        System.out.println("ConcurrentHashMap执行了：" + (end - start)); // 71ms
    }
}