java IO 操作总结

package my.java.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class MyFile {
public static void main(String[] args) throws IOException {
//定义目录
File myFile = new File("D:\\myjava");
File myFile1 = new File("D:\\myjava\\java1");
//System.out.println(myFile.exists());
//判断目录是否存在  不存在则创建
if(!myFile.exists()){
myFile.mkdir();
}
if(!myFile1.exists()){
myFile1.mkdir();
}

//System.out.println(myFile.createNewFile());
//System.out.println(myFile1.createNewFile());
File[] temp = new File[5];
for(int i=0; i<5; i++){
//创建5个文件，文件内容为空
//文件名字    = prefix(长度大于3) + 随机数 + suffix(null 时  是tmp);
temp[i] =  File.createTempFile("aaa", ".txt", myFile);
//System.out.println(temp[i].getName());
}
for(int i=0; i<5; i++){
//创建5个文件，文件内容为空
//文件名字    = prefix(长度大于3) + 随机数 + suffix(null 时  是tmp);
temp[i] =  File.createTempFile("bbb", ".txt", myFile1);
//System.out.println(temp[i].getName());
}

//获取该路径下所有的文件名
//Lambda表达式
//list(FilenameFilter filter);
//实现filter的accept(File dir, String name)接口方法
String [] aStrings = myFile.list((dir,name) -> name.startsWith("aaa7"));
//获取该路径下所有的文件
File[] aFiles = myFile.listFiles();
//fileList(aFiles);
//fileDel(aFiles);

File copyFile = new File("D:\\copy");
copyFile.delete();
if(!copyFile.exists()){
copyFile.mkdir();
}

fileCopy(aFiles,copyFile);
//目录在程序运行结束时删除
//当目录下有文件时，删除不了
//myFile.deleteOnExit();
//myFile.delete();
//myFile1.deleteOnExit();
}

//递归查找所有目录以及文件
public static void fileList(File[] aFiles){
for(File atemp : aFiles){
if(atemp.isFile()){
System.out.println(atemp.getAbsolutePath());
}
if(atemp.isDirectory()){
fileList(atemp.listFiles());
}
}
}
//递归删除所有目录以及文件
public static void fileDel(File[] aFiles){
for(File atemp : aFiles){
if(atemp.isFile()){
//删除文件
atemp.delete();
}
if(atemp.isDirectory()){
fileDel(atemp.listFiles());
}
//文件删除完之后，删除目录
atemp.delete();
}
}

//递归复制所有目录以及文件
public static void fileCopy(File[] aFiles,File directory) throws IOException{

for(File atemp : aFiles){
if(atemp.isFile()){
//System.out.println(atemp.getAbsolutePath());
InputStream inputStream = new FileInputStream(atemp);

String fileName = directory.getPath() + "\\" + atemp.getName();

OutputStream outputStream = new FileOutputStream(fileName);
byte[] buf = new byte[512];
while(inputStream.read(buf) > 0){
outputStream.write(buf);
}
outputStream.flush();
outputStream.close();
inputStream.close();
}
if(atemp.isDirectory()){
//fileList(atemp.listFiles());
String directoryName = directory.getPath() + "\\" + atemp.getName();
//创建子目录
directory = new File(directoryName);
if(!directory.exists()){
directory.mkdir();
}
fileCopy(atemp.listFiles(),directory);
}
}
}

}

package my.java.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
bit：位     一个二进制数据0或1，是1bit；

byte：字节    存储空间的基本计量单位        1 byte = 8 bit

一个英文字符占一个字节；     1 字母 = 1 byte = 8 bit

一个汉字占2个字节；              1 汉字 = 2 byte = 16 bit
*/
//字节流操作的数据单元是8位的字节
//字符流操作的数据单元是16位的字符
//字节流和字符流都属于节点流                 节点流的的构造器参数是一个物理节点   比如一个文件
//输入输出为二进制内容使用字节流            输入输出为文本文件使用字符流
public class ReadWrite01 {

public static void main(String[] args) throws IOException {

readWriteFileInputStream(new File("D:\\test.txt"),new File("D:\\copy1.txt"));
System.out.println("---------------------------------");
readWriteFileReader(new File("D:\\test.txt"),new File("D:\\copy2.txt"));
System.out.println("---------------------------------");
}
//字节流
public static void readWriteFileInputStream(File inFile,File outFile) throws IOException{
//创建字节输入流
FileInputStream input = new FileInputStream(inFile);
//输出流
FileOutputStream output = new FileOutputStream(outFile);

byte[] buf = new byte[1024];

while(input.read(buf) > 0) {
System.out.println(new String(buf));
output.write(buf);
}
output.flush();
output.close();
input.close();
//outFile.delete();
}
//字符流
public static void readWriteFileReader(File inFile,File outFile) throws IOException{
//创建输入流
FileReader input = new FileReader(inFile);
//输出流
FileWriter output = new FileWriter(outFile);

char[] buf = new char[512];
while(input.read(buf) > 0) {
System.out.println(buf);
output.write(buf);
}
output.flush();
output.close();
input.close();
//outFile.delete();
}
}

package my.java.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
//字节流操作的数据单元是8位的字节
//字符流操作的数据单元是16位的字符
//字节流和字符流都输与节点流                 节点流的的构造器参数是一个物理节点   比如一个文件
//处理流             构造参数是一个 节点流
public class ReadWrite2 {

public static void main(String[] args) throws IOException {

readWriteFileInputStream(new File("D:\\test.docx"),new File("D:\\copy.docx"));
System.out.println("---------------------------------");
readWriteFileReader(new File("D:\\test.txt"),new File("D:\\copy2.txt"));
System.out.println("---------------------------------");
}
//字节流
public static void readWriteFileInputStream(File inFile,File outFile) throws IOException{
//创建字节输入流
FileInputStream input = new FileInputStream(inFile);
BufferedInputStream bufferedInputStream = new BufferedInputStream(input);

//输出流
FileOutputStream output = new FileOutputStream(outFile);
BufferedOutputStream outputStream = new BufferedOutputStream(output);

byte[] buf = new byte[1024];
while(bufferedInputStream.read(buf) > 0) {
System.out.println(new String(buf));
outputStream.write(buf);
}
output.flush();
outputStream.close();
bufferedInputStream.close();
//处理流包装了节点流之后，关闭输入输出流时，只要关闭最上层的处理流即可，系统自动关闭被该处理流包装的节点流
//output.close();
//input.close();
//outFile.delete();
}
//字符流
public static void readWriteFileReader(File inFile,File outFile) throws IOException{
FileReader input = new FileReader(inFile);
BufferedReader bReader = new BufferedReader(input);
FileWriter output = new FileWriter(outFile);
BufferedWriter outwriter = new BufferedWriter(output);

//char[] buf = new char[512];
String line = null;
while((line = bReader.readLine()) != null) {
System.out.println(line);
outwriter.write(line);
}
outwriter.flush();
outwriter.close();
bReader.close();
//处理流包装了节点流之后，关闭输入输出流时，只要关闭最上层的处理流即可，系统自动关闭被该处理流包装的节点流
//output.close();
//input.close();
//outFile.delete();
}
}

package my.java.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;
/**
* 转换流
* java 提供了两个转换流    用于实现将字节流转换成字符流
* InputStreamReader  将字节输入流转换成字符输入流
* OutputStreamWriter 将字节输出流转换成字符输出流
*这两个流本身就是字符流
*
* 字节流操作的数据单元是8位的字节
* 字符流操作的数据单元是16位的字符
* 字节流和字符流都输与节点流                 节点流的的构造器参数是一个物理节点   比如一个文件
* 处理流             构造参数是一个 节点流
*/

public class ReadWrite3 {

public static void main(String[] args) throws IOException {

//readWrite1();
System.out.println("---------------------------------");
//readWrite2();
System.out.println("---------------------------------");
}
//java 使用System.in代表标准输入（键盘输入） 该输入流是InputStream的实例    是字节流
//键盘输入内容都是文本内容   使用InputStreamReader将字节流转换成字符流
public static void readWrite1() throws IOException{
//将System.in对象转换成Reader对象      字节流转换成字符流
InputStreamReader input = new InputStreamReader(System.in);
//再次封装成BufferedReader 对象        方便操作
BufferedReader buffer = new BufferedReader(input);

//将System.out对象转换成Reader对象      字节流转换成字符流
OutputStreamWriter out = new OutputStreamWriter(System.out);
//再次封装成BufferedReader 对象        方便操作
//BufferedWriter bufout = new BufferedWriter(out);

String line = null;
//BufferedReader流具有缓冲功能   一次读取一行文本  以换行符为标志
//没有读到换行符  程序阻塞  不会输出        读取到才会输出
while ((line = buffer.readLine()) != null) {
out.write(line);
//使用flush 将流里的缓冲数据输出
out.flush();

//bufout.write(line);
//bufout.flush();
}
out.close();
//bufout.close();
buffer.close();
input.close();
}
//使用Scanner 一个简单的文本扫描器，它可以使用正则表达式解析原始类型和字符串。
//扫描仪打破它的输入令牌使用分隔符模式，默认匹配空格。然后，使用不同的下一个方法，将所得的令牌转换为不同类型的值。
@SuppressWarnings("resource")
public static void readWrite2() throws IOException{
//		Scanner sc = new Scanner(System.in);
//		System.out.println(sc.nextInt());

//		Scanner sc1 = new Scanner(new File("D:\\test.txt"));
//		while (sc1.hasNextLine()) {
//			System.out.println(sc1.nextLine());
//		}

String input = "1 fish 2 fish red fish blue fish";
Scanner sc2 = new Scanner(input).useDelimiter("\\s*fish\\s*");
System.out.println(sc2.nextInt());
System.out.println(sc2.nextInt());
System.out.println(sc2.next());
System.out.println(sc2.next());
sc2.close();
/*1
2
red
blue
*/

}
}