steam流

ArrayList<String> list1 = new ArrayList<>();
1ist1.add("张无忌");
1ist1.add("周芷若"）;
1ist1.add("赵敏");
1ist1.add("张强"）;
1ist1.add("张三丰");
list1.stream().filter(name->name.startswith("张")).filter(name -> name.length() == 3).forEach(name-> System.out.println(name));

distinct
元素去重，依赖(hashCode和equals方法)
合并a和b两个流为一个流
concat
注意1：中间方法，返回新的stream流，原来的stream流只能使用一次，建议使用链式编程
注意2：修改stream流中的数据，不会影响原来集合或者数组中的数据

collect超详解

*参数一：
Function泛型一：表示流中每一个数据的类型
*
泛型二：表示Map集合中键的数据类型
*
*
方法apply形参：依次表示流里面的每一个数据
*
方法体：生成键的代码
*
返回值：已经生成的键
*
*
参数二：
Function泛型一：表示流中每一个数据的类型
泛型二：表示Map集合中值的数据类型
*
方法apply形参：依次表示流里面的每一个数据
方法体：生成键的代码
返回值：已经生成的键
**/
.collect(Collectors.toMap(new Function<String, String>() {
@Override
public String apply(String s){
return null;
}
},
new Function<String, Integer>() {
@Override
public Integer apply(String s){
returh null;
}
}));

收集流中的数据，放到集合中（List Set Map)
collect(Collector collector)
注意点：
如果我们要收集到Map集合当中，键不能重复，否则会报错

方法引用

方法引用
1.引用处需要是函数式接口
2.被引用的方法需要已经存在
3.被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
4.被引用方法的功能需要满足当前的要求

引用静态方法
格式：类名：：静态方法
范例：Integer::parseInt

静态方法中没有this！！！

引用本类或者父类的成员方法

引用构造方法

目的：为了创建对象

引用方法成员

方法引用的规则：
1.需要有函数式接口
2.被引用的方法必须已经存在
3.被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致。
4.被引用方法的功能需要满足当前的需求
抽象方法形参的详解：
第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法
在stream流当中，第一个参数一般都表示流里面的每一个数据。
假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用string这个类中的方法
第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

方法引用(引用成员方法)
格式
其他类：其他类对象：：方法名
本类：this:：方法名(引用处不能是静态方法)
父类：super:：方法名(引用处不能是静态方法）

引用数组的构造方法

格式：数据类型[]：:new
范例：int[]:：new
细节：数组的类型，需要跟流中数据的类型保持一致。

目的：
创建一个指定类型的数组
需求：
集合中存储一些整数，收集到数组当中
细节：
数组的类型，需要跟流中数据的类型保持一致。
*1
//1.创建集合并添加元素
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, ...elements: 1, 2, 3, 4, 5);
//2.收集到数组当中
Integer[] arr2 = list.stream().toArray(Integer[]::new);
System.out.println(Arrays.toString(arr2));
/*Integer[] arr = list.stream().toArray(ne IntFunction<Integer[]>() {
@0verride
public Integer[] apply(int value){
return new Integer[value];
})；*/

转成自定义对象

//1.创建集合并添加元素
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,.…."张无忌,15","周芷若,14","赵敏,13","张强,20","张三丰,100"，"张翠山,40")
//2.先把字符串变成Student对象，然后再把Student对象收集起来
Student[] arr = list.stream().map(Student::new).toArray(Student[]::new);
//打印数组
System.out.println(Arrays.tostring(arr));

获取部分属性并收集到数组

//1.创建集合
ArrayList<Student> list = new ArrayList<>();
//2.添加元素
list.add(new Student(  "zhangsan",  23));
list.add(new Student(  "lisi",  24));
list.add(new Student(  "wangwu", 25));
//3.获取姓名并放到数组当中
String[] arr = list.stream().map(Student: :getName).toArray(String[]: :new);
/* String[] arr = list.stream().map(new Function<Student, String>() {
@0verride
public String apply(Student student) {
return student.getName();
3
}).toArray(String[]::new);*/
System.out.println(Arrays.toString(arr));

异常

1.error：硬件类的问题
2.Exception：叫做异常，代表程序可能出现的问题。
我们通常会用Exception以及他的子类来封装程序出现的问题。
运行时异常：RuntimeException及其子类，|编译阶段不会出现异常提醒。
运行时出现的异常（如：数组索引越界异常）

1)编译时异常：没有继承RuntimeExcpetion的异常，直接继承于Excpetion。
编译阶段就会错误提示
2)运行时异常：RuntimeException本身和子类。
编译阶段没有错误提示，运行时出现的

/*
自己处理（捕获异常)
格式：
try {
可能出现异常的代码；
}catch(异常类名变量名）{
异常的处理代码；
}
*/


int[] arr = {1, 2, 3, 4, 5, 6};
try{
/可能出现异常的代码；
System.out.println(arr[10]);//此处出现了异常，程序就会在这里创建一个ArrayIndexOutOfBoundsException对象
//new ArrayIndexOutOfBoundsException();
/∥拿着这个对象到catch的小括号中对比，看括号中的变量是否可以接收这个对象
//如果能被收，就表示该异常就被捕获（抓住），执行catch里面对应的代码
//当catch里面所有的代码执行完毕，继续执行try...catch体系下面的其他代码
}catch(ArrayIndexOutOfBoundsException e){
//如果出现了ArrayIndexOutOfBoundsException异常，我该如何处理
System.out.println("索引越界了");
}
System.out.println("看看我执行了吗？");

细节：
如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面

异常中的常见方法

抛出 处理

自定义异常

1.定义异常类
2.写继承关系
3.空参构造
4.带参构造

运行时：RuntimeException核心就表示由于参数错误而导致的问题
‘编译时：Exception 核心提醒程序员检查本地信息

注：如果是编译时期的异常，就一定要加throws
捕获异常printStackTrace()

catch (NumberFormatException e){
e.printStackTrace();

File的概述和构造方法

创建文件对象（拼接）

//父级路径：C:\Users\alienware\Desktop
//子级路径：a.txt
String parent = "C:\\Users\\alienware\\Desktop";
String child = "a.txt";
File f2 = new File(parent,child);
//C: \Users\alienware\Desktop\a.txt

细节：
length方法只能返回文件的大小，单位是字节

创建、删除

1.createNewFile 创建一个新的空的文件
细节1：如果当前路径表示的文件是不存在的，则创建成功，方法返回true
如果当前路径表示的文件是存在的，则创建失败，方法返回false
细节2：如果父级路径是不存在的，那么方法会有异常IOException
细节3：createNewFtle方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件

2.mkdir make Directory,文件夹（目录）
细节1：windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false
细节2：mkdir方法只能创建单级文件夹，无法创建多级文件夹。

File f2 = new File("D:\\aaa\\aaa\\bbb\\ccc");
boolean b = f2.mkdir();
System.out.println(b);*/

3.mkdirs 创建多级文件夹
/细节：既可以创建单级的，又可以创建多级的文件夹

public boolean delete()
删除文件、空文件夹
细节：
如果删除的是文件，则直接删除，不走回收站。
如果删除的是空文件夹，则直接删除，不走回收站
如果删除的是有内容的文件夹，则删除失败

获取并遍历

当调用者File表示的路径不存在时，返回null
当调用者File表示的路径是文件时，返回null
当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
当调用者File表示的路径是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
当调用者File表示的路径是需要权限才能访问的文件夹时，返回null

findAVI（file）参数一定要是src的次一级路径

delete只能删除文件或者一个空文件夹

如果要删除，要先删除里面的所有的文件或者文件夹，然后在删除自己（采用递归）

public static void delete(File src){
//1.先删除文件夹里面所有的内容
//进入src
File[] files = src.listFiles();
∥遍历
for (File file : files) {
//判断，如果是文件，删除
if(file.isFile()){
file.delete();
}else {
//判断，如果是文件夹，就递归
delete(file);
}
}
//2.再删除自己
src.delete();
}

统计文件夹大小

1.定义变量进行累加
2.进入src文件夹
3.遍历数组
4.判断
把当前文件的大小累加到len当中
判断，如果是文件夹就递归

IO流

用于读写文件中的数据(可以读写文件，或网络中的数据


写出数据：write（）
释放数据：close（）

字节输出流的细节：
1.创建字节输出流对象
细节1:参数是字符串表示的路径或者是File对象都是可以的
细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
细节3：如果文件已经存在，则会清空文件
2.写数据
细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
3.释放资源
细节：每次使用完流之后都要释放资源

字节输出流写数据

换行写和续写

换行写：
再次写出一个换行符就可以了
windows: \r\n
Linux:\n
Mac:\r
细节：
在windows操作系统当中，java对回车换行进行了优化。
虽然完整的是\r\n，但是我们写其中一个\r或者\n，
java也可以实现换行，因为java在底层会补全。
建议：
不要省略，还是写全了。

续写：
如果想要续写，打开续写开关即可
开关位置：创建对象的第二个参数
默认false：表示关闭续写，此时创建对象会清空文件
手动传递true：表示打开续写，此时创建对象不会清空文件

字节输入流的基本用法

read是一个一个读的，度到最后会没有的话会显示-1，独处的是ASCII值

输入流如果不存在，就会报错呢?
因为创建出来的文件是没有数据的，没有任何意义。
所以Java就没有设计这种无意义的逻辑，文件不存在直接报错。
程序中最重要的是：数据。

字节输入流循环读取

I//1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.循环读取
int b;
while ((b =
fis.read())!= -1){
System.out.println((char) b);
//3.释放资源
fis.close();

文件的拷贝

1.创建对象
2.拷贝

核心思想：边读边写
int b;
while((b = fis.read())!= -1){
fos.write(b);
}

//3.释放资源
//规则：先开的最后关闭

fos.close();
fis.close();

弊端和解决方案