Java当中的IO流(中)

删除目录

import java.io.File;public class Demo{public static void main(String[] args){// 目录File dir = new File("E:\\hello");// 删除目录System.out.println(dir.delete());
// removeDir(dir);
// 下方方法}
}

如果目录里面有文件,或者还有目录,就无法删除,会显示为false的,那么就要从里头往外进行删除,可以进行递归的方法.

进行删除里头文件或文件夹

public static void removeDir(File dir){// 使用listFiles()方法,查看目录下是否有文件以及文件夹File[] files = dir.listFiles();// 如果没有目录if(files.length==0){dir.delete();return;}if(files!=null){for(File file : files){// 进行遍历files对象,判断是否是目录if(file.isDirectory()){// 进行删除目录removeDir(file);}else{// 进行删除文件System.out.println(file+":"+file.delete());}}}System.out.println(dir+":"+dir.delete());
}

对学生信息进行存储

创建学生类:

public class Student implements Comparable<Student>{private String name;private int cn, en, ma;private int sum;public Student(String name, int cn, int en, intma){super();this.name = name;this.cn = cn;this.en = en;this.ma = ma;this.sum = cn + en + ma;}public Student(){super();}// compareTo@Overridepublic int compareTo(Student o){int temp = this.sum - o.sum;return temp==0 ? this.name.compareTo(o.name):temp;}@Overridepublic int hashCode(){final int prime = 31;int result = 1;result = prime + result + cn;result = prime + result + sum;return result;}public String getName(){return name;}public void setName(String name){this.name = name;}public void setCn(int cn){this.cn = cn;}public int getCn(){return cn;}public void setEn(int en){this.en = en;}public int getMa(){return ma;}public void setMa(int ma){this.ma = ma;}public int getSum(){return sum;}public void setSum(int sum){this.sum = sum;}@Overridepublic String toString(){return "Student [name=" + name + ", sum=" + sum + "]";}
}

将学生的成绩等按照分数排序:

将信息保存到文件,就要使用IO流,有很多学生就要存储集合

// 简书作者：达叔小生public class Demo {private static final String LINE_SEPARATOR = System.getProperty("line.separator");public static void main(String[] args) throws IOException {Set<Student> set = new TreeSet<Student>(Collections.reverseOrder());set.add(new Student("da",12,34,55));set.add(new Student("shu",23,44,53));set.add(new Student("dashu",24,12,34));// 创建目录,对应目录File dir = new File("Student");// 如果目录不存在就创建if(!dir.exists()){dir.mkdir();}// 对应目录下的文件File desFiles = new File(dir,"student_info.txt");// 把数据写入到文件中writeToFile(set,desFiles);}// 方法writeToFile(set,desFiles);public static void writeToFile(Set<Student> set, File desFile ) throws IOException {FileOutputStream fos = null;try{fos = new FileOutputStream(desFile);// 遍历对象for(Student stu:set){String info = stu.getName() + "\t" + stu.getSum() + LINE_SEPARATOR;// 数据写到文件中fos.write(info.getBytes());}}finally{if(fos!=null){try{// 关闭资源fos.close();}catch(IOException e){throw new RuntimeException("系统资源关闭失败");}}}}
}

文件清单,就是获取目录中的文件,使用递归的方法,通过过滤器找到指定的所有文件.

public class Demo{private static final String LINE_SEPARATOR = SeparatorTool.LINE_SEPARATOR;public static void main(String[] args) throws IOException {// 明确一个目录File dir = new File("E:\\hello");// 过滤器 创建类 FileFilterByJavaFileFilter filter = new FileFilterBySuffix(".java"); // 创建集合List<File> list = new ArrayList<File>();// 指定文件清单getFileList(dir,filter,list);System.out.println(list.size());File desFile = new File(dir,"javalist.txt");writeToFile(list,desFile);}// 方法writeToFilepublic static void writeToFile(List<File> list, File desFile) throws IOException {FileOutputStream fos = null;BufferedOutputStream bufos = null;try{fos=new FileOutputStream(destFile);bufos=new BufferedOutputStream(fos);for(File file : list){String info = file.getAbsolutePath()+LINE_SEPARATORbufos.write(info.getBytes());bufos.flush();}}finally{if(bufos!=null){try{fos.close();}catch(IOException e){throw new RuntimeException("关闭失败");}}}
}public static void getFileList(File dir, FileFilter filter, List<File> list){// 获取目录下的子目录File[] files = dir.llistFiles();// 过滤器// 遍历子目录for(File file : files){// 进行判断是否是目录,如果是进行递归if(file.isDirectory()){// 进行递归getFileList(file,filter,list);}else{// if(file.getName().endsWith(".java")){if(filter.accept(file)){list.add(file);}}}}
}

FileFilterByJava:

// 简书作者：达叔小生import java.io.File;public class FileFilterBySuffix implements FileFilter {private String suffix;public FileFilterBySuffix(String suffix){super();this.suffix = suffix;}@Overridepublic boolean accept(File pathname) {return pathname.getName().endsWith(suffix);}
}

分隔符工具:

public class SeparatorTool {private SeparatorTool(){super();}public static final String LINE_SEPARATOR = System.getProperty("line.separator");public static final String PATH_SEPARATOR = System.getProperty("path.separator");public static final String FILE_SEPARATOR = System.getProperty("file.separator");
}

字节流输入和输出,字符流,字节流读取字符
InputStream和OutputStream
FileInputStream和FileOutputStream
BufferedInputStream和BufferedOutputStream

// 简书作者：达叔小生public class CharStreamDemo{public static void main(String[] args) throws IOException{// writeCNText();FileInputStream fis = new FileInputStream("dashu\\dashu.txt");// 如何判断? 一个中文默认为两个字节byte[] buff = new byte[1024];int len = 0;while( (len = fis.read(buff) != -1){String str = new String(buff,0,len);System.out.println(str);}fis.close();}public static void readCNText() throws FileNotFoundException{FileInputStream fis = new FileInputStream("dashu\\dashu.txt");}public static void writeCNText() throws FileNotFoundException, IOException{FileOutputStream fos = new FileOutputStream("dashu\\dashu.txt");fos.write("简书作者:达叔小生".getBytes());fos.close();}}

编码表

编码表 ASCII 美国标准信息交换码
将生活中的一切用计算机的二进制进行对应表示关系表
中文的,GB2312,用两个字节表示,6到7千
GBK,常用的中文码表,用两字节表示,2万多
unicode为国际标准码表,用两个字节表示
UTF-8是基于unicode的,用一个字节存储,更加标准.

// Java中char c = 'a';
无论什么都是两个字节

字符流FileReader

解码和编码

字符串
构造方法

方法	说明
`String()`	是初始化一个`String`对象,表示一个空字符序列
`String(byte[] byte)`	是使用平台默认的字符集解(默认的字符集为`gbk`)码指定的`byte`的数组
`String(byte[] bytes, Charset charset)`	是通过使用指定的charset解码指定的`byte`数组

FileInputStream

java.lang.Object
-> java.io.InputStream
-> java.io.FileInputStreampublic class FileInputStream extends InputStream
从文件系统中的某个文件中获取输入字节

如果要读取字符流,就要用FileReader.

字节流是用FileInputStream哦~

读取字符文件的 `FileReader`

java.io类 FileReaderjava.lang.Object-> java.io.Reader-> java.io.InputStreamReader-> java.io.FileReaderpublic class FileReader extends InputStreamReader

此类的构造方法自带默认的字符集编码和字节缓冲区,FileReader用于读取字符流.

// 简书作者：达叔小生// 版本开始为JDK1.1FileInputStream -> InputStreamReader

FileReader类是一个操作字符文件的便捷类,有默认的字符集编码和字节缓冲区

FileReader的构造方法:

方法	说明
`FileReader(File file)`	是用来给定从中读取数据的`File`
`FileReader(FileDescriptor fd)`	是给定从中读取数据的`FileDescriptor`
`FileReader(String fileName)`	是用来读取数据的文件名

java.io.InputStreamReader继承的方法

close, getEncoding, read, ready

java.io.Reader继承的方法

mark, markSupported, read, reset, skip

基础顶层

java.io类 Readerjava.lang.Object-> java.io.Reader

用于读取字符流的抽象类 Reader
public abstract class Reader extends Object
implements Readable, Closeable

Reader方法:

close()为关闭该流,并且释放所有资源mark(int readAheadLinmit)为标记流中的当前位置
markSupported()为判断此流是否支持mark()read()为读取单个字符
read(char[] cbuf)为将字符读入数组
read(char[] sbuf, int off, int len)为将字符一部分读入数组
read(CharBuffer target)为试图将字符读入指定的字符缓冲区ready()为判断是否准备读取此流
reset()为重置此流
skip(long n)为跳过字符

FileReader代码:

FileReader fr = new FileReader("dashu\\dashu.txt");int ch = fr.read();
System.out.println(ch);
fr.close();

int ch = 0;
int count = 0;while((ch=fr.read()) != -1){if(ch=='好'){count++;}
}System.out.println("count =" + count);

字符流FileWriter

java.io类 Writerjava.lang.Object-> java.io.Writerpublic abstract class Writer extends Object
implements Appendable, Closeable, Flushable写入字符流的抽象类

FileWriter

FileWriter是用来写入字符文件的便捷类

FileOutputStream -> OutputStreamWriterpublic class FileWriter extends OutputStreamWriter

java.io 类 FileWriterjava.lang.Object-> java.io.Writer-> java.io.OutputStreamWriter-> java.io.FileWriter

FileWriter此类的构造方法是假定默认的字符编码和默认的字节缓冲区大小,FileWriter是用于写入字符流

FileWriter(File file)
FileWriter(File file, boolean append)FileWriter(FileDescriptor fd)FileWriter(String fileName)
FileWriter(String fileName, boolean append)

FileWriter代码例子:

// 输出流
import java.io.FileWriter;public class FileWriterDemo{public static void main(String[] args) throws IOException {// FileWriter, 如果不存在创建一个FileWriter fw = new FileWriter("dashu\\dashu.txt");fw.write("简书作者:达叔小生");fw.flush();fw.close();}
}

flush()和close()

flush为刷新该流的缓冲,将流中缓冲区的数据刷新到目的地,刷新后的流可以使用

public abstract void flush() throws IOException

close为关闭此流,关闭流之前要先刷新,关闭资源用的,在关闭前会将缓冲区里的数据刷新到目的地,然后在关闭流,关闭了就不可以在使用了.

public void close(){flush();
}

// 简书作者：达叔小生
public abstract void close() throws IOException

异常:

java.io.IOException: Steam closed

OutputStreamWriter字符流

FileOutputStream -> OutputStreamWriter

FileWriter和FileReader都是有默认的字符集编码,如GBK

字符流通过字节流的桥梁类是
OutputStreamWriter类 -> java.io

可以用charset将写入流中的字符编码为字节
OutputStreamWriter默认的字符集可以给定,否则为平台默认

java.lang.Object-> java.io.Writer-> java.io.OutputStreamWriterpublic class OutputStreamWriter extends Writer

效率:OutputStreamWriter -> BufferedWriter

Writer out = new BufferedWriter(new OutputStream(System.out));

OutputStreamWriter方法:

OutputStreamWriter(OutputStream out)为使用默认的字符编码
OutputStreamWriter(OutputStream out, Charset cs)为使用给定的字符集编码

OutputStreamWriter例子

// GBK UTF-8
public class Demo{public static void main(String[] args) throws UnsupportedEncodingException, IOException {// 有的人用的却是UTF-8OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("dashu\\dashu.txt"), "utf-8" );osw.write("简书作者:达叔小生");osw.close();}
}

升级:

// 导致乱码
public static void read() throws IOException{FileReader fr = new FileReader("dashu\\dashu.txt");// int ch = (char)fr.read();char[] buff = new char[1024];int len = fr.read(buff);System.out.println(new String(buff,0,len);fr.close();
}

字符流 InputStreamReader

java.io类 InputStreamReaderjava.lang.Object-> java.io.Reader-> java.io.InputStreamReaderpublic class InputStreamReader extends Reader

InputStreamReader是用来指定编码读取中文的,是字节流通向字符流的桥梁,可以用charset读取字节并解码为字符.

为了提高效率,可以BufferedReader内包装InputSteamReader

BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

InputStreamReader例子:

构造方法:

InputStreamReader(InputStream in)
InputStreamReader(InputStream in, Charset cs)
InputStreamReader(InputStream in, CharsetDecoder dec)
InputStreamReader(InputStream in, String charsetName)

InputStreamReader方法:

// 简书作者：达叔小生
close()
getEncoding()
read()
read(char[] cbuf, int offset, int length)
ready()

public static void read() throws IOException {// 创建InputStreamReader对象InputStreamReader isr = new InputStreamReader(new FileInputStream("dashu\\dashu.txt"), "utf-8");char[] buff = new char[1024];int len = isr.read(buff);System.out.println(new String(buff,0,len));isr.close();
}
// InputStreamReader  Console输出

IO流-InputStreamReader和OutputStreamWriter 转换流

// 简书作者：达叔小生InputStreamReader isr = new InputStreamReader(new FileInputStream("dashu\\dashu.txt"), "GBK");char[] buff = new char[1024];int len = isr.read(buff);System.out.println(new String(buff,0,len));isr.close();

类 InputStreamReader的子类为FileReader
类 OutputStreamWriter的子类为FileWriter

在上面有写到字符流和字节的桥梁为OutputStreamWriter和InputStreamReader,所以称为字符转换流

其字符转换流原理为字节流和编码表

字符流通过字节流的桥梁类是
OutputStreamWriter类 -> java.io
可以用charset将写入流中的字符编码为字节

InputStreamReader 是用来指定编码读取中文的,是字节流通向字符流的桥梁

FileWriter和FileReader是OutputStreamWriter和InputStreamReader的子类,只是用来操作字符文件的便捷类,使用的是默认的编码表.

如果要使用其他编码时,要使用字符转换流,反之操作的是文件,且用默认的编码时,就使用FileWriter和FileReader.

不转换:

FileReader fr = new FileReader("dashu.txt");

转换流:

InputStreamReader isr = new InputStreamReader(new FileInputStream("dashu.txt"), "GBK");

要点

字节到字符, 输入流, 为InputStreamReader, 是需要读的,
读的是要给人懂的得,才能读,从看不懂的到看得懂的.

字符到字节, 输出流, 为OutputStreamWriter, 是需要写的,
写的是从看懂的到看不懂.

用字符流复制文本文件

public class CopyTextFileTest{public static void main(String[] args) throws IOException {copyTextFile();}public static void copyTextFile() throws IOException {// 明确目标FileReader fr = new FileReader("dashu.java");// 明确目的FileWriter fw = new FileWriter("hello\\hello.txt");// 循环,读字符// int ch = 0;// while((ch=fr.read()) != -1){// fw.write(ch);// }// 效率高的char[] buff = new char[1024];int len = 0;while((len=fr.read(buff) != -1){fw.write(buff,0,len);}// 关闭资源fw.close();fr.close();}
}

字符流缓冲区对象复制文本文件

java.io类 Readerjava.lang.Object-> java.io.Readerpublic abstract class Reader extends Objectimplements Readable, Closeable

Reader是用来读取字符流的抽象类

// 简书作者：达叔小生
BufferedReader
BufferedWriter

字符输入流中读取文本-BufferedReader

缓冲区是给流的

java.io类 BufferedReaderjava.lang.Object-> java.io.Reader-> java.io.BufferedReader从字符输入流中读取文本,用来缓冲各个字符

public class BufferedReader extends Reader

FileReader和InputStreamReader

BufferedReader in = new BufferedReader(new FileReader("dashu.txt"));

BufferedReader 的构造方法:

// 简书作者：达叔小生
BufferedReader(Reader in)为默认大小
BufferedReader(Reader in, int sz)使用指定的大小

BufferedReader的方法

方法	说明
`close()`	返回类型为`void`,是用来关闭资源的
`mark(int readAheadLimit)`	返回类型为`void`, 是用来标记流中的当前位置
`markSupported()`	返回类型为`boolean`, 判断此流是否支持`mark()`操作
`read()`	返回类型为`int`,是用来读取单个字符的
`read(char[] cbuf, int off, int len)`	返回类型为`Int`,是将字符数组一部分读入
`readLine()`	返回类型为`String`, 是用来读取一个文本的
`ready()`	返回类型为`boolean`, 是用来判断此流是否已经准备好
`reset()`	返回为`void`, 是将流重置到最新的标记
`skip(long n)`	返回类型为`long`, 是用来跳过字符的

将文本写入到字符输出流-BufferedWriter

java.io类 BufferedWriterjava.lang.Object-> java.io.Writer-> java.io.BufferedWriterpublic class BufferedWriter extends Writer将文本写入字符输出流

FileWriter 和 OutputStreamWriter

PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("dashu.txt"));

BufferedWriter 的方法

方法	说明
`close()`	返回类型为`void`,是用来关闭资源的
`flush()`	返回类型为`void`,是用来刷新该流的缓冲
`newLine()`	返回类型为`void`,是用来写入一个行分隔符
`write(char[] cbuf, int off, int len)`	返回类型为`void`, 是用来写入字符数组的一部分
`write(int c)`	返回类型为`void`,是用来写入单个字符
`write(String s, int off, int len)`	返回类型为`void`, 写入字符串的一部分

字符流的缓冲区

// 简书作者：达叔小生public class CharStreamBufferedDemo{public static void main(String[] args) throws IOException {// BufferedReader和BufferedWriter 字符流缓冲区// BufferedReader// 从字符输入流中读取文本,用来缓冲各个字符// BufferedWriter // 将文本写入到字符输出流copyTextByBuffer();readText();writeText();}public static void writeText()  throws IOException {BufferedWriter b = new BufferedWriter(new FileWriter("hello.java");for(int x=1, x<=4; x++){b.write(x);b.newLine();b.flush();}b.close();}public static void readText() throws IOException {BufferedReader buffer = new BufferedReader(new FileReader("dashu.java");// String line = buffer.readLine();// System.out.println(line);String line = null;while((line=buffer.readLine()) != null){System.out.println(line);}buffer.close();}public static void copyTextByBuffer(){BufferedReader bufr = new BufferedRead(new FileReader("hello.txt"));BufferedWriter bufw = new BufferedWriter(new FileWriter("hello\\dashu.txt"));// 循环String line = null;while((lline = bufr.readLine() != null){bufr.write(line);bufr.newLine();bufr.flush();}bufw.close();bufr.close();}
}

流是一连流串的字符，是信息的通道，分输出流和输入流。

IO的分类

第一种分：输入流和输出流。
第二种分：字节流和字符流。
第三种分：节点流和处理流。

Java中流的分类：

流的运动方向，可分为输入流和输出流两种。

流的数据类型，可以分为字节流和字符流。

输入流类都是抽象类
InputStream（字节输入流）或抽象类Reader类（字符输入流）的子类。

输出流类都是抽象类
OutputStream（字节输出流）或抽象类Writer类（字符输出流）的子类。

输入流从文件输入为读取，输出流从文件输出为写入数据。

输入流
输入流用于读取数据，用户可以从输入流中读取数据，但不能写入数据。

输入流读取数据过程如下：
（1）打开一个流。
如：FileInputStream inputFile=new FileInputStream("数据源");
（2）从信息源读取信息。
如：inputFile.read();
（3）关闭流。
如：inputFile.close();

输出流
输出流用于写入数据。只能写，不能读。

写数据到输出流过程如下：
（1）打开一个流。
如：FileOutputStream outFile=new FileOutputStream("数据源");
（2）写入信息到目的地。
如：outFile.write(inputFile.read()):
（3）关闭流。
如：outFile.close();

字符流Reader和Writer

字节字符转换流:

// 简书作者：达叔小生
InputStreamReader
OutputStreamWriter

往后余生，唯独有你
简书作者：达叔小生
90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通
简书博客： https://www.jianshu.com/u/c785ece603d1

结语

下面我将继续对其他知识深入讲解，有兴趣可以继续关注
小礼物走一走 or 点赞