I/O流

分类：
1.字节流和字符流
2.输入流和输出流
3.节点流和处理流

• 字节流读写文件

import java.io.FileInputStream;

public class import1 {
	public static void main(String[]args) throws Exception{
		//创建一个文件字节输入流来读取文件
		FileInputStream in = new FileInputStream("test.txt");
		//定义一个int类型的变量b
		int b=0;
		//通过循环来读取文件，当返回值为-1时，结束循环
		while((b=in.read())!=-1) {
			System.out.println(b);
		}
		//关闭流
		in.close();
	}
}

• 写入文件

import java.io.FileOutputStream;

public class output1 {
	public static void main(String[]args) throws Exception{
		//创建文件输出流对象，并指定输出文件名称
		FileOutputStream out = new FileOutputStream("out.txt");
		//定义一个字符串
		String str = "Hello";
		//将字符串转换为字节数组进行写入操作
		out.write(str.getBytes());
		//关闭流
		out.close();
	}
}

import java.io.FileOutputStream;

public class output2 {
	public  static void main(String[]args) throws Exception{
		//创建输出流对象，并指定输出的文件名称
		FileOutputStream out = new FileOutputStream("out.text",true);
		String str = "Wolrld\r";
		out.write(str.getBytes());
		/*finally {
			try {
				if(out!=null)
					out.close();
			}catch(Exception e) {
				e.printStackTrace();
			}
		}
	*/
	}
}

import java.io.FileReader;

public class zifuliu1 {
	public static void main(String[]args) throws Exception{
		//创建FileReader对象，并指定需要读取的文件
		FileReader fileReader = new FileReader("reader.txt");
		
		int len = 0;
		//通过循环来判断是否读取到来文件末尾
		while((len = fileReader.read())!=-1) {
			//读出取到的字符
			System.out.print((char)len);
		}
		fileReader.close();
	}
}

import java.io.FileWriter;

public class ziduliu2 {
	public static void main(String[]args) throws  Exception{
		//创建字符输出流对象，并指定输出文件
		FileWriter fileWriter = new FileWriter("writer.txt");
		//将定义的字符写入文件
		fileWriter.write("轻轻的我走了，\n");
		fileWriter.write("正如我轻轻的来，\r\n");
		fileWriter.write("我轻轻的招手，\r");
		fileWriter.write("作别西天的云彩，\r\n");
		//关闭流
		fileWriter.close();
	}
}

import java.io.FileReader;
import java.io.FileWriter;

//使用字符流的缓冲区实现文件的拷贝
public class zifuliu3 {
	public static void main(String[]args) throws Exception{
		//创建FileReader对象，并指定需要读取的文件
		FileReader fileReader = new FileReader("reader.txt");
		//创建FileRWriter对象，并指定需要写入的文件
		FileWriter fileWriter = new FileWriter("writer.txt");
		int len = 0;
		//定义一个长度为1024的字符数组
		char[] buff = new char[1024];
		while((len=fileReader.read(buff))!=-1) {
			//输出读取的字符
			fileWriter.write(buff,0,len);
		}
		fileReader.close();
		fileWriter.close();
		
	}
}

import java.io.*;

//用BufferedRead中的readLine()方法，用于一次读取一行文本‘

public class zifuliu4 {
	public static void main(String[]args) throws Exception{
		//创建一个字符输入流缓冲对象
		BufferedReader br = new BufferedReader(new FileReader("reader.txt"));
		//创建一个字符输出流缓冲对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("writer.txt"));
		String str = null;
		//循环时每次读取一行文本，如果不为null（即到了文件末尾），则继续循环
		while((str = br.readLine())!=null) {
			//通过缓冲流对象写入文件
			bw.write(str);
			bw.newLine();
		}
		br.close();
		bw.close();
	}
}

import java.io.*;

public class zijiehuanchongliu {
	public static void main(String[]sgrs) throws Exception{
		//创建用于输入和输出的字节缓冲流对象
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("source/src.jpg") );
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("target/src.jpg"));
		//定义一个int类型的变量len
		int len = 0;
		//获取拷贝文件前的系统时间
		long beginTime = System.currentTimeMillis();
		//通过循环读取输入字节缓冲流中的数据，并通过输出字节缓冲流写入到新文件
		while((len = bis.read())!=-1) {
					bos.write(len);
				}
		//获取拷贝文件后的系统时间
		long endTime = System.currentTimeMillis();
		//输出拷贝花费时间
		System.out.println("花费时间为："+(endTime-beginTime)+"毫秒");//花费时间为：38毫秒
		//关闭流
		bis.close();
		bos.close();
	}
}

import java.io.*;

public class zhuanhuanliu {
	public static void main(String[]args) throws Exception{
		//1.创建字节输入流对象，获取源文件
		FileInputStream in = new FileInputStream("reader.txt");
		//将字节输入流对象转换成字符输入流对象
		InputStreamReader isr = new InputStreamReader(in);
		//创建字符输出流对象
		BufferedReader br = new BufferedReader(isr);
		//2.创建字节输出流对象，指定目标文件
		FileOutputStream out = new FileOutputStream("writer.txt");
		//将字节输出流对象转换成字符输出流对象
		OutputStreamWriter osw = new OutputStreamWriter(out);
		//创建字符输出缓冲流对象
		BufferedWriter bw = new BufferedWriter(osw);
		//定义一个字符串对象
		String line = null;
		//通过循环判断换是否读到文件末尾
		while((line = br.readLine())!=null) {
			//输出读取到的文件
			bw.write(line);
			bw.newLine();
		}
		//关闭流
		br.close();
		bw.close();
	}
}

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class copy {
	public static void main(String[]args) throws Exception{
		//创建文件输入流对象读取指定目录下的文件
		FileInputStream in = new FileInputStream("source/src.jpg");
		//创建文件输出流对象将读取到的文件内容写入到指定目录的文件中
		FileOutputStream out = new FileOutputStream("target/dest.jpg");
		//定义一个int类型的变量len
		int len = 0;
		//定义一个长度为1024的字节数组
		byte[] buff = new byte[1024];
		//获取拷贝文件前的系统时间
		long beginTime = System.currentTimeMillis();
		//通过循环将读取到的文件字节信息写入到新文件
		while((len = in.read(buff))!=-1) {
			out.write(buff,0,len);
		}
		//获取拷贝文件后的系统时间
		long endTime = System.currentTimeMillis();
		//输出拷贝花费时间
		System.out.println("花费时间为："+(endTime-beginTime)+"毫秒");//花费时间为：28毫秒
		//关闭流
		in.close();
		out.close();
	}
}

import java.io.File;
//查看文件的相关信息
public class File1 {
	public static void main(String[]args) {
		//创建File文件对象
		File file = new File("example.txt");
		System.out.println("文件名称："+file.getName());
		System.out.println("文件的相对路径："+file.getPath());
		System.out.println("文件的绝对路径："+file.getAbsolutePath());
		System.out.println("文件的父路径："+file.getParent());
		System.out.println(file.canRead()?"文件可读":"文件不可读");
		System.out.println(file.canWrite()?"文件可写":"文件不可写");
		System.out.println(file.isFile()?"是一个文件":"不是一个文件");
		System.out.println(file.isDirectory()?"是一个目录":"不是一个目录");
		System.out.println(file.isAbsolute()?"是绝对路径":"不是绝对路径");
		System.out.println("最后的修改时间为："+file.lastModified());
		System.out.println("文件大小为："+file.length());
		System.out.println("是否成功删除文件？"+file.delete());	
	}
}

/*
 文件名称：example.txt
文件的相对路径：example.txt
文件的绝对路径：/Users/a/Desktop/Java/Example/example.txt
文件的父路径：null
文件可读
文件可写
是一个文件
不是一个目录
不是绝对路径
最后的修改时间为：1557913240802
文件大小为：4
是否成功删除文件？true
*/

//遍历目录下的文件

import java.io.File;
import java.util.Arrays;

public class File2 {
	public static void main(String[]args) {
		//创建File对象，并指定文件路径
		File file = new File("/Users/a/Desktop/Java/Example/source");
		//判断是否是目录
		if(file.isDirectory()) {
			//获取目录中的所有文件的名称
			String[] fileNames = file.list();
			//对指定路径下的文件或目录进行遍历
			Arrays.stream(fileNames).forEach(f->System.out.println(f));
		}
	}
}
/*
.DS_Store
src.JPG
*/

import java.io.File;
import java.util.Arrays;

//如何筛选遍历指定目录下所有拓展名为”.txt“的文件
public class File3 {
	public static void main(String[]args) {
		//创建file对象并指定文件路径
		File file = new File("/Users/a/Desktop/Java/Example");
		//判断是否为目录
		if(file.isDirectory()) {
			//使用Lamda表达式过滤目录中所有以“.txt”结尾的文件的名称
			String[] fileNames =file.list((dir,name)->name.endsWith(".txt"));
			//对指定路径下的文件或目录进行遍历
			Arrays.stream(fileNames).forEach(f->System.out.println(f));
		}
	}
}
/*
out.txt
reader.txt
writer.txt
time.txt
test.txt
*/

import java.io.File;

//有子目录需要遍历，使用递归

public class File4 {
	public static void main(String[]args) {
		//创建file对象并指定文件路径
		File file = new File("/Users/a/Desktop/Java/Example");
		//调用fileDir()方法，遍历目录
		fileDir(file);
	}

	private static void fileDir(File file) {
		//获得目录下的全部文件并赋给数组
		File[] listFiles = file.listFiles();
		//循环遍历数组
		for(File files:listFiles) {
			//如果遍历的是目录，则递归调用fileDir()方法
			if(files.isDirectory()) {
				fileDir(file);
			}
			//输出文件路径
			System.out.println(files);
		}
	}
}
/*
/Users/a/Desktop/Java/Example/.DS_Store
/Users/a/Desktop/Java/Example/reader.txt
/Users/a/Desktop/Java/Example/out.tx
*/