IO流与Lambda表达式的使用

IO流，Lambda表达式，

一.什么是io流？

流是一组有顺序的，有起点和终点的字节集合，是对数据对象的总称或抽象。它的特征是进行数据的传输。

例如从水源地长江（资源）把水导入到自来水厂（程序），然后自来水厂在把水输送到每家每户（文件），长江到自来水厂之间就是输入流，自来水厂再把水送到每家每户，我们称为输出流。

二.流的分类

流按照流向可分为输入流，输出流。

流按照处理数据类型的单位不同可以分为字节流和字符流

三.字节流和字符流

字节流：InputStream和OutputStream是java按照最小字节单位读取的流，每次都读取一个字节。

字符流：是以字符为单位进行数据处理的IO流。

字节流与字符流之间的区别？

1.读取的单位不同：字节流是以字节为单位（8位2进制），字符流是以字符为单位，根据码表来映射字符

2.处理对象不同：字节流可以处理所有类型的数据（如图片，avi等），字符流只可以处理字符类型的数据

四.节点流

1.文件：FileInputStream，FileOutputStream

public class IODemo2 {
	//声明输入流,输出流
	static InputStream in = null;
	static OutputStream os = null;
	public static void main(String[] args) {
		//创建流
		try {
			in = new FileInputStream("D:/text.txt");
			//如果输出流中没有该文件，java会自动帮你创建该路径文件
			os = new FileOutputStream("E:/text.txt");
			//字节数据
			byte[] b = new byte[1024];
			//长度
			int len=0;
			//读取文件内容并写入
			while((len=in.read(b))!=-1) {
				//写入，如果写读取长度范围，就会一次性读取1024范围，造成空间浪费读取
				os.write(b,0,len);
			}
			//清理缓冲
			os.flush();		
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			//关闭资源
			//判断是否存入的流对象为空
			try {	
				if(in!=null) { //防止空指针异常
				
					in.close();
				} 
				if(os!=null) { //防止空指针异常
				os.close();
				}
			}catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
		}
		}
	}

2.FileReader,FileWriter

public class Test01 {

	public static void main(String[] args) throws IOException {
		//输入流，输出流
		Reader rd = new FileReader("D:/text.txt");
		Writer wt = new FileWriter("D:/hao.txt");
		//字符数组
		char[] car = new char[1024];
		//个数
		int len=-1;
		while(-1!=(len=rd.read(car))) {
			wt.write(car,0,len);
			System.out.println("完成拷贝!");
		}
		//刷出
		wt.flush();
		//关闭资源
		wt.close();
		rd.close();
	}
}

五.对象(功能)流

1.ObjectOutputStream(对象输出流)

2.ObjectInputStream(对象输入流)

//对象输出流
	public static void getWrite(String name) throws  IOException {
		ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(name));
		os.writeBoolean(false);
		os.writeChar(97);
		os.writeObject(new Person("李杨",22));
		os.writeUTF("UTF-8");
		//刷出
		os.flush();
		//关闭资源
		os.close();
	}
	
	//对象输入流
	public static void getRead(String name) throws IOException, ClassNotFoundException {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(name));
		boolean b = ois.readBoolean();
		char c = ois.readChar();
		Object o = ois.readObject();
		System.out.println(b+"---->"+c+"----->"+o);
		//关闭资源
		ois.close();
	}

六.lambda表达式

1.什么是lambda？

用来简化匿名内部类的代码量。

2.lambda的用法

（）：代表重写方法的参数列表。

​ ->：lambda表达式，具有推倒作用，可以让该显示为lambda表达式。

｛｝：重写方法的方法体。

3.lambda的使用前提

必需要有函数式接口，函数式接口有且只有一个抽象方法，@FunctionalInterface可以用来检测是否是函数式接口

七.四大核心接口

1.消费性接口：Consumer 方法：void accept(T t)

2.供给型接口：Supplier 方法： T get()

3.函数型接口：Function<T,R> 方法：R apply(T t)

4.断电型接口：Predicate 方法：boolean test(T t)

八.简化lambda表达式

1.方法引用

@Test
	public void test() {
		//Supplier<Employee> sup =()->new Employee();
		//Supplier<Employee> sup = Employee::new;
		//Function<String,Employee> fun=(i)->new Employee(i);
		//简化
		//Function<String,Employee> fun = Employee::new;
		//A<String,Employee> a = (t)->new Employee(t);
		//System.out.println(a.get("你好"));
	}

2.类名：：成员方法

@Test
	public void test02() {
		//BiPredicate<String, String> bi=(s1,s2)->s1.equals(s2);
		//可以直接使用返回类型来做简化对象
		//BiPredicate<String, String> bi = String::equals;
		//System.out.println(bi.test("你好","你好"));
		//A<String,Boolean> a = (s1,s2)->s1.equals(s2);
		A<String,Boolean> a = String::equals;
		System.out.println(a.get("你好", "你好"));
		
	}

3.对象的引用：：成员方法->简化Lambda结构

@Test
	public void test03() {
		List<String> ls =Arrays.asList("aaa","bbb","ccc");
		//ls.forEach((e)->{System.out.println(e);});
		//将打印语句分离
		ls.forEach(System.out::println);
	}

4类名：静态方法名

@Test
	public void test04() {
		//Comparator<Integer> cs = (a,b)->Integer.compare(a, b);
		Comparator<Integer> cs  = Integer::compare;
		System.out.println(cs.compare(3, 4));
	}