IO流

一、IO流的分类

从数据类型的角度：
字节流，字符流
从功能角度：
处理流，节点流
站在程序的角度：
输入流，输出流

转换流
如下图，提供一个类字节流转换到字符流

package IO_23;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
//转换流的使用InputStreamReader
//获取输入，Scanner（1.5版本）之前的获取方式
public class ConvertDemo {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		while(true){
			String line=br.readLine();
			if(line.equals("no")){
				break;
			}else {
				System.out.println(line);
			}
		}
	}

}

二、流的概念

文件想象成一个水桶，管子怼到水桶上，打开水龙头
InputStream

OutputStream
如图，BufferedInputStream继承FilterInputStream类

三、两类处理

Data类型
（1）继承自FilterInputStream

（2）功能

基础数据类型的读写和封装，String

package IO_23;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Random;

public class DateTest {

	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub

		DataOutputStream dos = null;
		try {
			dos=new DataOutputStream(new FileOutputStream("D:\\test.dat"));
			dos.writeDouble(10);
			dos.writeBoolean(true);
			dos.flush();

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();

		} finally {
			try {
				dos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		DataInputStream dis = null;
		try {
			dis=new DataInputStream(new FileInputStream("D:\\test.dat"));
			System.out.println(dis.readDouble());
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				dos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

Object类型
（1）继承自ObjectInputStream

（2）对象的读写，也叫序列化，把对象存盘
存盘的对象要实现序列化的接口；
※ 什么时候需要序列化呢？
通过网络传输对象否要进行序列化和反序列化，所以从某种意义上将，序列化的效率影响你程序的性能
我们用的是JDK默认实现的序列化

Student类

package IO_23;

import java.io.Serializable;
import java.util.Date;
//继承实现标签接口，默认JDK实现
public class Student implements Serializable{

String name;
Integer age;
Date birthday;
public Student(String name, Integer age, Date birthday) {
	super();
	this.name = name;
	this.age = age;
	this.birthday = birthday;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public Integer getAge() {
	return age;
}
public void setAge(Integer age) {
	this.age = age;
}
public Date getBirthday() {
	return birthday;
}
public void setBirthday(Date birthday) {
	this.birthday = birthday;
}
}

让Student类继承Serializable接口

ObjectDemo 类

package IO_23;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class ObjectDemo {

	public static void main(String[] args) throws ClassNotFoundException {
		// TODO Auto-generated method stub
		
		ObjectOutputStream oos=null;
		try {
			 oos=new ObjectOutputStream(new FileOutputStream("object.dat"));
			 oos.writeObject(new Student("zhangsan",24, new Date()));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			try {
				oos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		ObjectInputStream ois=null;
		try {
			 ois=new ObjectInputStream(new FileInputStream("object.dat"));
			Object object=ois.readObject();
			if(object instanceof Student){
				Student student=(Student)object;
				System.out.println(student.getName());
				System.out.println(student.getAge());
				System.out.println(student.getBirthday());
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			try {
				oos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

四、File类

package IO_23;

import java.io.File;
import java.io.FileFilter;

public class FileDemos {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			
		File file=new File(".");
		
		System.out.println(file.getUsableSpace());
		System.out.println(file.getParent());
		
//		System.out.println(file.isDirectory());
//		System.out.println(file.getAbsolutePath());
		
//		String names[]=file.list();
//		for(String str:names){
//			System.out.println(str);
//		}
		//匿名内部类
//		File files[]=file.listFiles(new FileFilter() {
//			
//			@Override
//			public boolean accept(File pathname) {
//				// TODO Auto-generated method stubr
//				return pathname.getName().endsWith(".dat");
//			}
//		});
		
		File files[]=file.listFiles(new DatFilter());
		for(File f:files){
//			if(f.isFile()){
//			System.out.println(file.getName());
//		}
			System.out.println(f.getName());
		}
	}
	
}

class DatFilter implements FileFilter{
	public boolean accept(File pathanme){
//		return pathanme.getName().endsWith(".dat");
		
		return pathanme.isDirectory();
	}
}

思考练习题

1.写一个程序，找某一个Java文件
提示：endwith（".java"）


给定一个目录，列出目录下所有Java文件

2.设计程序阶乘输出斐波那契数列
实例如下：
1、1、2、3、5、8、13、21、34、。。。。。

找规律

createNewFile()

附码：

package IO_23;

public class DiguiDemo {
/**
 * 0  1
 * 1  1     1-->1
 * 2  2*1   2-->2*1
 * 3  3*2*1  3--->3*2
 * 
 * 
 * 1 1  =1
 * 2 1  =1
 * 3 2  =
 * 4 3
 * 5 5
 */
	
	//自定义递归函数   阶乘
	static int factorial(int n){
		if(n==1| n==0){
			return 1;
		}else {
			return n*factorial(n-1);
		}
	}
	//自定义求斐波那契数列指定
	static int Fibonacci(int n){
		if(n==1){ 
			return 1;
			}
		if(n==2) {
			return 1;
			}
		return Fibonacci(n-1)+Fibonacci(n-2);
	}
	public static void main(String[] args) {
//		System.out.println(factorial(3));
		//System.out.println(Fibonacci(9));
		for(int i=1;i<10;i++){
			System.out.print(Fibonacci(i)+" ");
		}
	}
}