IO流及Java8新特性

Day11 IO流及Java8新特性

缓冲流

什么是缓冲流

一般是用户包装其它的流，达到高效的读写

• **BufferedInputStream:**字节缓冲输入流
  构造方法：

  • BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
  • BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用

• BufferedOutputStream
  构造方法：

  • BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
  • BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

• BufferedReader
  构造方法：

  • BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
  • BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

• BufferedWriter
  构造方法：

  • BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
  • BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

什么时候会用到缓冲流

例如文件流程序操作磁盘文件。像直接操作磁盘文件和内存操作节点设备，如果是频繁的操作效率比较低下。缓冲流，可以把读写的数据线存储在缓冲区中，然后在适当的时候刷新（提交）到节点设备中，减少了操作次数

如何使用：

FileInputStream fis = new FileInputStream("H:/b/13.avi");
BufferedInputStream bis = new BufferedInputStream(fis);//把一个字节输入流包装成了一个缓冲流[非常常用]
long start = System.currentTimeMillis();
byte[] b = new byte[1024];
int len;
while((len = fis.read(b))!=-1){
	//System.out.println(new String(b,0,len));
}
long end = System.currentTimeMillis();
System.out.println(end-start);

总结及注意事项

BufferedReader 中具有一个一次读一行的方法 String readLine()
注意此方法是没有读到行分隔符的
如果没有数据了，返回null
BufferedWriter 中具有一个写一个行分隔符的方法 void newLine()

随机访问文件RandomAccessFile

什么是随机访问文件（流）

java.io包中，拓展至Object此类，具有读取和写入的方法，可以实现随机读写，随机不是随意（随机）的；可以自己指定文件位置进行数据读写，如何设置位置，默认的位置是什么？

构造方法：
RandomAccessFile(File file, String mode)
RandomAccessFile(String name, String mode)
mode 指定是模式 ： 读 或者 写 或者读写，r:只读 rw:读写
重要方法：

• long length() 返回此文件的长度。
• long getFilePointer() 返回此文件中的当前偏移量。 文件已经读取的长度
• int read() 从此文件中读取一个数据字节。
• void seek(long pos) 设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
• **void setLength(long newLength) ** 设置此文件的长度。

接口里面的成员

• 1.成员变量 使用接口名调用
• 2.抽象方法 使用接口的实现类对象调用
• 3.静态方法-static 可以有多个---->使用接口名调用
• 4.默认方法-default 可以存在多个(被实现类继承)---->实现类对象调用

函数式接口

什么是函数式接口

• 有且仅有一个抽象方法的接口，但是可以有多个非抽象方法的接口，函数式接口可以被隐式转换为lambda表达式
• 可以通过注解@FunctionalInterface来判断该接口是否为函数式接口

6.2.函数式接口API

JDK1.8之前已有的函数式接口：

• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：

• java.util.function 此包中包含了很多类，用来支持 Java的 函数式编程

Lambda表达式

什么是Lambda表达式

• 简单来说就是可以看成是对匿名内部类的简写，使用Lambda表达式 接口必须是函数式接口

Lambda表达式的语法

基本语法：
	<函数式接口>  <变量名> = (参数1，参数2...) -> {
                    //方法体
         }

特别说明！！！！！！！

• (参数1，参数2…)表示参数列表；->表示连接符；{}内部是方法体

1. =右边的类型会根据左边的函数式接口类型自动判断
2. 如果形参列表为空，只需要保留()
3. 如果形参只有一个，()可以省略，只需要参数的名称即可
4. 如果执行语句只有一句，且无返回值，{}可以省略，若有返回值，则若想省去{}，则必须同时省略return，且执行语句也保证只有一句
5. 形参列表的数据类型会自动判断
6. lambda不会生成一个单独的内部类文件；
7. lambda表达式若访问了局部变量，则局部变量必须是final修饰的，若是局部变量没有加final关键字，系统会自动添加，此后在修改该局部变量，会报错
   

	public static void main(String[] args) {
//		TestInterface t1 = () -> {System.out.println("leryoo");};
//		t1.test();
		
//		TestInterface t2 = () -> 1000;
//		System.out.println(t2.test());;

//		TestInterface t3 = a -> System.out.println("23333");
//		t3.test(1);
		String s = "结果";
		TestInterface t4 = (a,b) -> s+a+b;
		System.out.println(t4.test(2, "8"));
	}
}

interface TestInterface{
	
//	void test();
//	int test();
//	void test(int a);
	String test(int a,String b);
	
}

Lambda调用方法

Person类：

class Person{
	private String name;
	private int  age;
	public Person() {
		
	}
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public Person(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

接口：

interface MyInterface2{
	Person getInstance(String name);
}

---

构造方法的调用

匿名内部类方式:

MyInterface2 t1 = new MyInterface2() {
	
	@Override
	public Person getInstance(String name) {
		return new Person(name);
	}
};
System.out.println(t1.getInstance("柯南"));

Lambda

MyInterface2 t2 = name->{return new Person(name);};
System.out.println(t2.getInstance("小兰"));

简化

MyInterface2 t3 = name->new Person(name);
System.out.println(t2.getInstance("小兰"));

更简化

MyInterface2 t3 = Person::new;
System.out.println(t3.getInstance("小兰"));

静态方法的调用

匿名内部类方式:

MyInterface3 t1 = new MyInterface3() {
	
	@Override
	public Integer getInteger(String name) {
		return Integer.valueOf(name);
	}
};
System.out.println(t1.getInteger("100"));

Lambda

MyInterface3 t2 = name->Integer.valueOf(name);
System.out.println(t2.getInteger("100"));

简化

MyInterface3 t3= Integer::valueOf; 
System.out.println(t3.getInteger("100"));

Function

是为了使用lambda
Function<T,R>
R 方法(T t)

lambda调用方法 ：：

• Integer :: new —>调用构造方法
• Integer :: valueOf —>调用普通方法
• Integer i = 10;
  i :: parsint; —>通过对象调用方法

Consumer

这是一个功能接口，因此可以作为赋值的目标一个lambda表达式或方法参考