🚩前言
🌻今天的学习为Junit单元测试以及进行IO流的部分接触。
JUnit是一个Java语言的单元测试框架。它由Kent Beck和Erich Gamma建立，逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个。 JUnit有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出
文章目录
✏️Junit单与测试
✒️JUnit单元测试
JUnit是一个Java语言单元测试框架。
JUnit单元测试的好处：
1.可以书写一些列的测试方法，对项目的所有的接口或者方法进行单元测试。
2.启动后，自动化的测试。
3.只需要查看最后的结果。
4.每个单元测试的用例相对独立，由JUnit启动。
5.添加，删除，屏蔽测试方法。
jar包
如果要引入第三方的插件，xxx.jar的文件。
首先要把这个文件导入到我们的工程目录下
其次，要添加到工程的依赖目录中
public class Ch01 {
// Test注解是JUnit提供的一个单元测试注解
// 如果你的工程没有导入JUnit的jar包，Test注解是不认识的
/**
* 测试方法：
* 1.不能有返回值
* 2.不能有参数列表
* 3.必须有Test注解
*/
@Test
public void test01(){
System.out.println("hello junit");
}
@Test
public void test02() {
System.out.println("hello junit02");
}
}
✒️JUnit断言
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.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为主
代码表示
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
}
}
✒️JDK8新增
Stream编程
容器对象功能的增强
我们可以将流看做流水线，这个流水线是处理数据的流水线
当我们使用一个流的时候，通常包括三个步骤：
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：消费者 void accept(T t)
Supplier：供应商 T get()
Function： R apply(T t)，将一个数据转化成另一个数据
Predicate：断言，boolean test(T t)，判断返回值是boolean
✒️JDK8总结
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);
}
}
封装类编辑
public class FileUtil {
/*
分析：
1.传入的路径是一个e:\\a\b\c\aaa.txt
2.传入的路径是一个e:/a/b/c/bbb.txt
*/
public static boolean createDirAndFile(String filepath) throws IOException {
File file = null;
if(filepath.contains("/")){
if(filepath.contains("\\")){
throw new RuntimeException("路径不合法");
}else {
// e:\\a\\b\\c\\a.txt
int index = filepath.lastIndexOf("/");
String filename = filepath.substring(index,filepath.length());
filepath = filepath.substring(0, index+ 1);
file = new File(filepath);
file.mkdirs();
// 创建文件
File newFile = new File(filepath,filename);
newFile.createNewFile();
return true;
}
}
if(filepath.contains("\\")){
if(filepath.contains("/")){
throw new RuntimeException("路径不合法");
}else {
// e:\\a\\b\\c\\a.txt
int index = filepath.lastIndexOf("\\");
String filename = filepath.substring(index,filepath.length());
filepath = filepath.substring(0, index+ 1);
file = new File(filepath);
file.mkdirs();
// 创建文件
File newFile = new File(filepath,filename);
newFile.createNewFile();
return true;
}
}
throw new RuntimeException("路径不合法");
}
public static void main(String[] args) {
// String str = "e:\\a\\b\\c\\a.txt";
// System.out.println(str.contains("/"));
try {
createDirAndFile("d");
System.out.println("文件创建成功...");
} catch (IOException e) {
e.printStackTrace();
}
}
}
✒️ 文件的操作
利用代码进行分析
public class Ch03 {
@Test
public void test08() {
File file = new File("D:\\QQ");
File[] files = file.listFiles((f) -> {
if (f.isFile()) {
return true;
}
return false;
});
System.out.println(Arrays.toString(files));
// String[] list = file.list((dir, name) -> {
// if(dir.isDirectory()){
// return true;
// }
if (name.endsWith("xml")) {
return true;
}
// return false;
// });
// System.out.println(Arrays.toString(list));
}
@Test
public void test07() {
File file = new File("E:\\workspace");
String[] fileNames = file.list();
// System.out.println(Arrays.toString(fileNames));
File[] files = file.listFiles();
System.out.println(Arrays.toString(files));
}
@Test
public void test06() {
File file = new File("d:/123.txt");
File file1 = new File("bbb.txt");
// System.out.println(file.getAbsolutePath());
// System.out.println(file1.getAbsolutePath());
// 获取对应的相对路径的那个对象
File absoluteFile = file1.getAbsoluteFile();
// System.out.println(file.getParent());
File parentFile = file.getParentFile();
// System.out.println(file.getName());
// System.out.println(file1.getPath());
// System.out.println(new Date(file.lastModified()));
// System.out.println(file.length());
// 剪切粘贴 移动
file.renameTo(new File("d:\\aaa.txt"));
}
@Test
public void test05() throws IOException {
File file = new File("e:/aaa.txt");
File file2 = new File("E:\\idea");
// System.out.println(file.isHidden());
// System.out.println(file.isFile());
// System.out.println(file2.isDirectory());
/*
绝对路径和相对路径
绝对路径：以盘符开头
相对路径：没有指定的盘符开头
*/
// System.out.println(file.isAbsolute());
// 判断文件是否存在
// System.out.println(file.exists());
// 新建文件是不会覆盖已有的文件
// System.out.println(file.createNewFile());
// System.out.println(file2.mkdirs());
}
☀️总结
今天的学习就到这里了，对于Junit测试类的了解情况不深，需要勤加练习。而从初步接触IO流来看，需要对知识进行深入了解，不断巩固才能进行接下来的IO流的学习。关注小编让我们一起深入学习吧！
5926
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
