第54节:Java当中的IO流(中)-原创手记-慕课网

webp

标题图

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
 @Override
 public int compareTo(Student o){  int temp = this.sum - o.sum;  
  return temp==0 ? this.name.compareTo(o.name):temp;
 } @Override
 public 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;
 } @Override
 public 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"); // 过滤器 创建类 FileFilterByJava
 FileFilter 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_SEPARATOR
  bufos.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;
 } @Override
 public 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

类 Writer

java.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-8public class Demo{ public static void main(String[] args) throws UnsupportedEncodingException, IOException {  // 有的人用的却是UTF-8
  OutputStreamWriter 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();

作者：达叔小生
链接：https://www.jianshu.com/p/f54599149a55