学习心得
有了这个JUnit单元测试，导入jar包。不用主方法了，很便捷。用java或者一些其他的编程软件都可以在自己的电脑上创建删除文件文件夹
心情
今日心情感觉学的知识很有意思，可以用java创建磁盘里的文件
掌握情况：有了一些能在自己电脑上实现的创建功能，感觉理解的更好
1.JUnit单元测试
JUnit是一个Java语言单元测试框架
JUnit单元测试的好处：
- 可以书写一些列的测试方法，对项目的所有接口或者方法进行单元测试
- 启动后，自动化的测试
- 只需要查看最后的结果
- 每个单元测试的用例相对独立，由JUnit启动
- 添加，删除，屏蔽测试方法
jar包
如果要引入第三方插件，xxx.jar文件
1️⃣首先要把这个文件导入到我们的工程目录下。2️⃣其次，要添加到工程的依赖目录中。
Test注解是JUnit提供的一个单元测试注解
如果你的工程没有导入JUnit的jar包，Test注解是不认识的
测试方法：
1.不能有返回值
2.不能有参数
3.必须有@Test注解
JUnit断言
JUnit的所有断言都包含Assert类中，这个类提供了很多有用的断言来编写测试用例。只有失败的断言才会被记录。
assertEquals：检查两个变量或等式是否相等
assertTrue：检查条件是否为真
assertFalse：检查条件是否为假
assertNotNull：检查对象是否不为空
assertNull：检查对象是否为空
JUnit注解：
1.Test
2.Before：在测试方法执行之前执行的方法
3.After
命名规则：
单元测试类的命名：被测试类的类名+Test
测试方法的命名：test+被测试方法的方法名
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方法执行..."); }
集合的好多面试
1.Hashtable 和 ConcurrentHashMap 性能测试
2.ArrayList 和 LinkedList性能测试
数组查询快，插入慢。链表插入快，查询慢。
1.尾插数组快，链表慢
2.遍历：数组快
3.头插，链表快，数组慢
4.随机删除，如果要过滤，建议用LinkedList
开发中还是以ArrayList为主
import org.junit.Before; import org.junit.Test; import java.util.*; import java.util.concurrent.ConcurrentHashMap; public class Ch04 { @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)); } /* 我们尝试开辟50个线程，每个线程向集合中put100000个元素， 测试两个类所需的时间 */ @Test public void hashtableTest() throws InterruptedException { final Map<Integer,Integer> 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 } @Test public void testConcurrentHashMap() throws InterruptedException { final Map<Integer,Integer> 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)); // 71
Stream编程 JDK8新增
容器对象功能的增强
我们可以将流看成流水线，这个流水线是处理数据的流水线
当我们使用一个流的时候，通常包括三个步骤：-=-=-=-=-=-=-=-=-=-=-=-
- 1.获取一个数据源
- 2.执行操作获取想要的结果
- 3.每次操作，原有的流对象不改变，返回一个新的Stream对象
Stream 有几个特征：=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-
- 1.Stream不存储数据，一般会输出结果
- 2.Stream不会改变数据源，通常情况下会生成一个新的集合
- 3.Stream具有延迟执行的特征，只有调用终端操作时，中间操作才会执行
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<Person> personList = new ArrayList<>(); // 创建一个简单的集合 List<Integer> 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<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.ou
归约（reduce）缩减，把一个流缩减成一个值
可以实现对集合的求和，求乘积，求最值
-----------------------------------------------------------------------------
映射：
将一个流的元素按照一定的映射规则映射到另一个流中
-----------------------------------------------------------------------------
JDK8函数式接口：
Consumer<T>：消费者 void accept( T t )
Supplier：供应商 T get( )
Function：R apply( T t )，将一个数据转化成另一个数据
Predicate：断言 boolean ( T t )，判断返回值是boolean。
-------------------------------------------------------------------------------------------------
Optional类是Java为了 解决 null 问题 （Ch08）
Java IO流----对于文件的操作
Input：把数据从物理内存加载到运行内存。（读文件）
Output：把数据从运行内存写到物理内存（写文件）
Java.io包下的类
计算机的输入输出都是通过二进制完成的
0 和 1
工具类：File操作文件的类
1.文件的路径
正斜杠：左斜杠，撇，/
反斜杠：右斜杠，捺，\
在Unix和Linux中。路径的分隔用正斜杠/。
在windows中，路径分隔用反斜杠\。
在java中，\代表转义
在File类中，定义了路径分隔符的常量，自动识别操作系统。
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); } }
==============================================================
浙公网安备 33010602011771号
你点我就回上面去了ヾ(≧O≦)〃嗷~