2022-08-08 第六小组 张宁杰 流
知识点
JUnit单元测试
JUnit是一个Java语言单元测试框架
JUnit单元测试的好处：
1.可以书写一系列的测试方法，对项目的所有接口或者方法进行单元测试
2.启动后，自动化的测试
3.只需要查看最后的结果
4.每个单元测试的用例相对独立，由JUnit启动
5.添加，删除，屏蔽测试方法
jar包
如果要引入第三方的插件，xxx.jar的文件
首先要把这个文件导入到工程目录下，其次要添加到工程的依赖目录中
Test注解是JUnit提供的一个单元测试注解，如果工程没有导入JUnit的jar包，Test注解是不认识的
测试方法：
不能有返回值，不能有参数，必须有Test注解
JUnit断言
JUnit的所有断言都包含在Assert类中，这个类提供了很多有用的断言来编写测试用例，只有失败的断言才会被记录
1.assertEquals检查两个变量或者等式是否平衡
2.assertTrue检查条件是否为真
3.assertFalse检查条件是否不为空
4.assertNotNull检查对象是否不为空
5.assertNull检查对象是否为空
断言不成功会抛出异常，即使程序正常运行，但是结果不正确，也会以失败结束
public class Ch02 {
@Test
public void test01() {
Assert.assertTrue(false);
}
}
JUnit注解
1.Test
2.Beforre：在测试方法执行之前执行的方法
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为主
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)); // 71ms
}
}
Stream编程（JDK8新增）
容器对象功能的增强
我们可以将流看做流水线，这个流水线是处理数据的流水线
当我们使用一个流的时候，通常包括三个步骤：
1.获取一个数据源
2.执行操作获取想要的结果
3.每次操作，原有的流对象不改变，返回一个新的Stream对象
Stream有几个特性：
1.Stream不存储数据，一般会输出结果
2.Stream不会改变数据源，通常情况下会生成一个新的集合
3.Stream具有延迟执行的特性，只有调用终端操作时，中间操作才会执行
public class Ch05 {
@Test
public void test01() {
List<String> list = Arrays.asList("a","b","c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();
Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
}
}
JDK8函数式接口
Consumer
Supplier：供应商 T get()
Function： R apply(T t)，将一个数据转化成另一个数据
Predicate：断言，boolean test(T t)，判断返回值是boolean
Optional类是java8为了解决null问题
JDK8新增：
1.函数式接口
2.箭头函数（lambda表达式），不是java特有的。阉割版
3.Optional类
4.断言
5.Stream编程
public class Ch08 {
@Test
public void test01() {
String str = null;
// 返回一个对象值为空的Optional对象
// Optional<String> empty = Optional.empty();
// Optional<String> hello = Optional.of(str);
Optional<String> o = Optional.ofNullable(null);
System.out.println(o.get());
}
}
Java IO流---对于文件的操作
Input：把数据从物理内存加载到运行内存。（读文件）
Output：把数据从运行内存写到物理内存。（写文件）
java.io包下的类
计算机的输入输出都是通过二进制完成。
0和1
工具类：File操作文件的类
文件的路径
正斜杠：左斜杠，撇，/
反斜杠：右斜杠，捺，
在Unix/Linux，路径的分隔采用正斜杠/，
在windows中，路径分隔采用反斜杠\。
在java中，\代表转义
在File类中，定义了路径分隔符的常量，自动识别操作系统。
public class Ch01 {
public static void main(String[] args) {
// System.out.println("\t");
// System.out.println("E:\\");
// System.out.println("E:/workspace");
System.out.println(File.separator);
System.out.println("e:" + File.separator + "workspace");
System.out.println(File.pathSeparator);
}
}
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);
}
}
