Java缓冲字符流

PrintWriter的自动行刷新功能

如果实例化PW时第一个参数传入的是一个流，则此时可以再传入一个boolean型的参数，此值为true时就打开了自动行刷新功能。 即: 每当我们用PW的println方法写出一行字符串后会自动flush.

package io;
?
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
?
/**
 * 练习PrintWriter的流连接操作
 */
public class PWDemo2 {
 ? ?public static void main(String[] args) throws FileNotFoundException {
 ? ? ? ?//文件输出流(低级流，字节流) 作用:向文件中写出字节
 ? ? ? ?FileOutputStream fos = new FileOutputStream("pw2.txt");
 ? ? ? ?//转换输出流(高级流，字符流) 作用:1衔接字符与字节流的 2:将写出的字符转换为字节
 ? ? ? ?OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
 ? ? ? ?//缓冲字符输出流(高级流，字符流) 作用:块写文本数据加速的(内部有一个8k的char数组)
 ? ? ? ?BufferedWriter bw = new BufferedWriter(osw);
 ? ? ? ?//具有自动行刷新功能(高级流，字符流) 作用:1按行写出字符串(println) 2:自动行刷新
 ? ? ? ?/*
 ? ? ? ? ? ?当我们创建PrintWriter时，构造方法里第一个参数为一个流，那么就支持再传入
 ? ? ? ? ? ?一个boolean值参数表示是否打开自动行刷新功能，传入true则打开。
 ? ? ? ? ? ?此时每当我们调用它的println方法写出一行字符串后就会自动flush()一次。
 ? ? ? ? ? ?注意:print方法和write方法写出字符串时并不会自动flush()!!!!
 ? ? ? ? */
 ? ? ? ?PrintWriter pw = new PrintWriter(bw,true);
?
 ? ? ? ?/*
 ? ? ? ? ? ?完成一个简易记事本工具
 ? ? ? ? ? ?将控制台上输入的每一行字符串按行写入到该文件中
 ? ? ? ? ? ?如果单独输入exit,则程序退出。
 ? ? ? ? ? ?思路:
 ? ? ? ? ? ?用一个死循环，重复做下面的工作
 ? ? ? ? ? ?1:在控制台上输入一行字符串
 ? ? ? ? ? ?2:判断输入的字符串是否为"exit"
 ? ? ? ? ? ? ?若是:则break掉循环退出程序
 ? ? ? ? ? ? ?若不是:则将输入的字符串通过println方法写入文件
 ? ? ? ? */
 ? ? ? ?Scanner scanner = new Scanner(System.in);
 ? ? ? ?while(true) {
 ? ? ? ? ? String line = scanner.nextLine();
 ? ? ? ? ? if("exit".equals(line)){
 ? ? ? ? ? ? ? ?break;
 ? ? ? ? ? }
 ? ? ? ? ? pw.println(line);
// ? ? ? ? ? pw.print("");//不会自动flush
// ? ? ? ? ? pw.write("");//不会自动flush
 ? ? ?  }
 ? ? ? ?System.out.println("写出完毕!");
?
 ? ? ? ?pw.close();
 ?  }
}
?

缓冲字符流

缓冲字符输入流:java.io.BufferedReader

是一个高级的字符流，特点是块读文本数据，并且可以按行读取字符串。

package io;
?
import java.io.*;
?
/**
 * 使用缓冲字符输入流按行读取字符串
 * 该高级流的主要作用:
 * 1:块读文本数据加速(内部有一个默认8k的char数组)
 * 2:可以按行读取字符串
 */
public class BRDemo {
 ? ?public static void main(String[] args) throws IOException {
 ? ? ? ?//将当前源代码输出到控制台上
 ? ? ? ?/*
 ? ? ? ? ? ?思路:
 ? ? ? ? ? ?读取当前源代码文件，按行读取，并且将读取到的每一行字符串都输出到控制台上即可
 ? ? ? ? */
 ? ? ? ?//文件输入流(低级流，字节流) 作用:从文件中读取字节
 ? ? ? ?FileInputStream fis = new FileInputStream("./src/io/BRDemo.java");
 ? ? ? ?//转换输入流(字符流，高级流) 作用:1衔接字节与字符流 2将读取的字节转换为字符
 ? ? ? ?InputStreamReader isr = new InputStreamReader(fis);
 ? ? ? ?//缓冲字符输入流(字符流，高级流) 作用:1块读字符数据加速  2按行读取字符串
 ? ? ? ?BufferedReader br = new BufferedReader(isr);
 ? ? ? ?/*
 ? ? ? ? ? ?BufferedReader缓冲字符输入流
 ? ? ? ? ? ?提供了一个独有的方法:readLine()
 ? ? ? ? ? ?作用:读取一行字符串。连续读取若干字符直到遇到了换行符位置，并将换行符之前的
 ? ? ? ? ? ? ? ?内容返回。注意:返回的字符串里不包含最后的换行符。
 ? ? ? ? ? ? ? ?特殊情况:
 ? ? ? ? ? ? ? ?如果这一行只有一个换行符，那么返回值为空字符串:""
 ? ? ? ? ? ? ? ?如果读取到了流的末尾，那么返回值为null。
?
 ? ? ? ? ? ?实际运行时:
 ? ? ? ? ? ?当我们第一次调用readLine()方法时，缓冲字符输入流实际会一次性读取8k的char
 ? ? ? ? ? ?回来并存入内部的char数组中(块读文本操作)。readLine方法只将char数组中从头
 ? ? ? ? ? ?开始一直到第一个换行符位置的内容以一个字符串形式返回。
 ? ? ? ? */
 ? ? ? ?String line;
 ? ? ? ?while((line = br.readLine()) != null){
 ? ? ? ? ? ?System.out.println(line);
 ? ? ?  }
?
 ? ? ? ?br.close();
 ?  }
}
?
?
?
?

IO总结

异常处理

java异常处理机制

• java中所有错误的超类为:Throwable。其下有两个子类:Error和Exception

• Error的子类描述的都是系统错误，比如虚拟机内存溢出等。

• Exception的子类描述的都是程序错误，比如空指针，下表越界等。

• 通常我们程序中处理的异常都是Exception。

• 

异常处理机制中的try-catch

package exception;
?
/**
 * 异常处理机制中的try-catch
 * 语法:
 * try{
 * ? ? 代码片段...
 * }catch(XXXException e){
 * ? ? 出现错误后的补救措施(B计划)
 * }
 */
public class TryCatchDemo {
 ? ?public static void main(String[] args) {
 ? ? ? ?System.out.println("程序开始了...");
 ? ? ? ?/*
 ? ? ? ? ? ?try{}语句块不能单独写，后面要么跟catch语句块要么跟finally语句块
?
 ? ? ? ? ? ?异常处理机制关注的是:明知道程序可能出现某种错误，但是该错误无法通过修改逻辑
 ? ? ? ? ? ?完全规避掉时，我们会使用异常处理机制，在出现该错误是提供一种补救办法。
 ? ? ? ? ? ?凡是能通过逻辑避免的错误都属于bug！就应当通过逻辑去避免!
 ? ? ? ? */
 ? ? ? ?try {
// ? ? ? ? ?  String str = null;
// ? ? ? ? ?  String str = "";
 ? ? ? ? ? ?String str = "a";
 ? ? ? ?/*
 ? ? ? ? ? ?若str=null的情况
 ? ? ? ? ? ?当JVM执行到下面代码时:str.length()会出现空指针，此时虚拟机就会根据该情况
 ? ? ? ? ? ?实例化一个对应的异常实例出来，即:空指针异常实例 NullPointerException实例
 ? ? ? ? ? ?然后将程序从一开始执行到报错这句话的过程设置到该异常实例中，此时该异常通过
 ? ? ? ? ? ?类型名字可以表达出现了什么错误，并将来可以通过输出错误信息来得知错误出现在那里
 ? ? ? ? ? ?虚拟机会将该异常抛出
 ? ? ? ? ? ?当某句代码抛出了一个异常时，JVM会做如下操作:
 ? ? ? ? ? ?1:检查报错这句话是否有被异常处理机制控制(有没有try-catch)
 ? ? ? ? ? ? ?如果有，则执行对应的catch操作，如果没有catch可以捕获该异常则视为没有
 ? ? ? ? ? ? ?异常处理动作
 ? ? ? ? ? ?2:如果没有异常处理，则异常会被抛出当当前代码所在的方法之外由调用当前方法的
 ? ? ? ? ? ? ?代码片段处理该异常
 ? ? ? ? */
 ? ? ? ? ? ?System.out.println(str.length());//抛出空指针异常
 ? ? ? ? ? ?System.out.println(str.charAt(0));
 ? ? ? ? ? ?System.out.println(Integer.parseInt(str));
 ? ? ? ? ? ?/*
 ? ? ? ? ? ? ? ?当try中某句代码报错后，就会跳出try执行下面对应的catch块，执行后就会
 ? ? ? ? ? ? ? ?退出catch继续向后执行。因此try语句块中报错代码以下的内容都不会被执行
 ? ? ? ? ? ? */
 ? ? ? ? ? ?System.out.println("!!!!!!!!!!!!!!");
// ? ? ?  }catch(NullPointerException e){
// ? ? ? ? ?  //这里实际开发中是写补救措施的，通常也会将异常信息输出便于debug
// ? ? ? ? ?  System.out.println("出现了空指针，并解决了!");
// ? ? ?  }catch(StringIndexOutOfBoundsException e){
// ? ? ? ? ?  System.out.println("处理字符串下标越界问题!");
// ? ? ?  }
 ? ? ? ?/*
 ? ? ? ? ? ?当try语句块中可能出现的几种不同异常对应的处理办法相同时，可以采取合并
 ? ? ? ? ? ?catch的做法，用同一个catch来捕获这几种可能出现的异常，而执行措施使用
 ? ? ? ? ? ?同一个。
 ? ? ? ? */
 ? ? ?  }catch(NullPointerException|StringIndexOutOfBoundsException e){
 ? ? ? ? ? ?System.out.println("处理空指针或下标越界!");
 ? ? ? ?/*
 ? ? ? ? ? ?当catch捕获某个超类型异常时，那么try语句块中出现它类型异常时都可以被这个
 ? ? ? ? ? ?catch块捕获并处理。
?
 ? ? ? ? ? ?如果多个catch捕获的异常之间存在继承关系时，一定是子类异常在上超类异常在下
 ? ? ? ? */
 ? ? ?  }catch(Exception e){
 ? ? ? ? ? ?System.out.println("反正就是出了个错!");
 ? ? ?  }
 ? ? ? ?System.out.println("程序结束了...");
 ?  }
}
?

异常处理机制中的finally

• finally块定义在异常处理机制中的最后一块。它可以直接跟在try之后，或者最后一个catch之后。

• finally可以保证只要程序执行到了try语句块中，无论try语句块中的代码是否出现异常，最终finally都必定执行。

• finally通常用来做释放资源这类操作。

package exception;
?
/**
 * finally块
 * finally块是异常处理机制中的最后一块，它可以直接跟在try语句块之后或者最后一个catch块
 * 之后。
 * finally可以保证只要程序执行到try语句块中，无论try语句块中的代码是否出现异常，finally
 * 都【必定执行】!
 * 通常finally块用于做释放资源这类操作，比如IO操作后的关闭流动作就非常适合在finally中进行
 */
public class FinallyDemo {
 ? ?public static void main(String[] args) {
 ? ? ? ?System.out.println("程序开始了...");
 ? ? ? ?try{
 ? ? ? ? ? ?String str = "abc";
 ? ? ? ? ? ?System.out.println(str.length());
 ? ? ? ? ? ?return;
 ? ? ?  }catch(Exception e){
 ? ? ? ? ? ?System.out.println("出错了，并处理了");
 ? ? ?  }finally{
 ? ? ? ? ? ?System.out.println("finally中的代码执行了!");
 ? ? ?  }
 ? ? ? ?System.out.println("程序结束了");
 ?  }
}
?

IO操作时的异常处理机制应用

package exception;
?
import java.io.FileOutputStream;
import java.io.IOException;
?
/**
 *  异常处理机制在IO中的实际应用
 */
public class FinallyDemo2 {
 ? ?public static void main(String[] args) {
 ? ? ? ?FileOutputStream fos = null;
 ? ? ? ?try {
 ? ? ? ? ? ?fos = new FileOutputStream("fos.dat");
 ? ? ? ? ? ?fos.write(1);
 ? ? ?  } catch (IOException e) {
 ? ? ? ? ? ?e.printStackTrace();
 ? ? ?  } finally {
 ? ? ? ? ? ?try {
 ? ? ? ? ? ? ? ?if(fos!=null) {
 ? ? ? ? ? ? ? ? ? ?fos.close();
 ? ? ? ? ? ? ?  }
 ? ? ? ? ?  } catch (IOException e) {
 ? ? ? ? ? ? ? ?e.printStackTrace();
 ? ? ? ? ?  }
 ? ? ?  }
 ?  }
}
?

自动关闭特性

JDK7之后，java提供了一个新的特性:自动关闭。旨在IO操作中可以更简洁的使用异常处理机制完成最后的close操作。

语法:
try(
 ?  定义需要在finally中调用close()方法关闭的对象.
){
 ? ?IO操作
}catch(XXXException e){
 ?  ...
}

上述语法中可在try的"()"中定义的并初始化的对象必须实现了java.io.AutoCloseable接口,否则编译不通过.

package exception;
?
import java.io.FileOutputStream;
import java.io.IOException;
?
/**
 * JDK7之后java推出了一个特性:自动关闭特性
 * 旨在让我们用更简洁的语法完成IO操作的异常处理机制(主要就是简化了finally关闭流的操作)
 */
public class AutoCloseableDemo {
 ?  public static void main(String[] args) {
 ? ? ?  /*
 ? ? ? ? ?  该特性是编译器认可的，并非虚拟机。实际上编译器编译完毕后的样子可参考FinallyDemo2
 ? ? ? ? */
 ? ? ?  try(
 ? ? ? ? ? ? ?  //只有实现了AutoCloseable接口的类才可以在这里定义!编译器最终会补充代码在finally中调用其close关闭
 ? ? ? ? ? ? ?  FileOutputStream fos = new FileOutputStream("fos.dat");
 ? ? ?  ){
 ? ? ? ? ?  fos.write(1);
 ? ? ?  } catch (IOException e) {
 ? ? ? ? ?  e.printStackTrace();
 ? ? ?  }
?
 ?  }
}
?

上述代码是编译器认可的，而不是虚拟机。编译器在编译上述代码后会在编译后的class文件中改回成FinallyDemo2案例的代码样子(上次课最后的案例)。

throw关键字

throw用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常:

• 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。

• 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。

package exception;
?
/**
 * 测试异常的抛出
 */
public class Person {
 ? ?private int age;
?
 ? ?public int getAge() {
 ? ? ? ?return age;
 ?  }
?
 ? ?public void setAge(int age) throws Exception {
 ? ? ? ?if(age<0||age>100){
 ? ? ? ? ? ?//使用throw对外抛出一个异常
 ? ? ? ? ? ?throw new RuntimeException("年龄不合法!");
 ? ? ?  }
 ? ? ? ?this.age = age;
 ?  }
}
package exception;
?
/**
 * throw关键字，用来对外主动抛出一个异常。
 * 通常下面两种情况我们主动对外抛出异常:
 * 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
 * 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
 */
public class ThrowDemo {
 ? ?public static void main(String[] args) {
 ? ? ? ?Person p = new Person();
 ? ? ? ?p.setAge(10000);//符合语法，但是不符合业务逻辑要求。
 ? ? ? ?System.out.println("此人年龄:"+p.getAge());
 ?  }
}

throws关键字

当一个方法中使用throw抛出一个非RuntimeException的异常时，就要在该方法上使用throws声明这个异常的抛出。此时调用该方法的代码就必须处理这个异常，否则编译不通过。

package exception;
?
/**
 * 测试异常的抛出
 */
public class Person {
 ? ?private int age;
?
 ? ?public int getAge() {
 ? ? ? ?return age;
 ?  }
?
 ? ?/**
 ? ? * 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
 ? ? */
 ? ?public void setAge(int age) throws Exception {
 ? ? ? ?if(age<0||age>100){
 ? ? ? ? ? ?//使用throw对外抛出一个异常
// ? ? ? ? ?  throw new RuntimeException("年龄不合法!");
 ? ? ? ? ? ?//除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
 ? ? ? ? ? ?throw new Exception("年龄不合法!");
 ? ? ?  }
 ? ? ? ?this.age = age;
 ?  }
}

当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通过。 处理手段有两种:

• 使用try-catch捕获并处理这个异常

• 在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。 具体选取那种取决于异常处理的责任问题。

package exception;
?
/**
 * throw关键字，用于主动对外抛出一个异常
 */
public class ThrowDemo {
 ? ?public static void main(String[] args){
 ? ? ? ?System.out.println("程序开始了...");
 ? ? ? ?try {
 ? ? ? ? ? ?Person p = new Person();
 ? ? ? ? ? ?/*
 ? ? ? ? ? ? ? ?当我们调用一个含有throws声明异常抛出的方法时,编译器要求
 ? ? ? ? ? ? ? ?我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
 ? ? ? ? ? ? ? ?1:使用try-catch捕获并处理异常
 ? ? ? ? ? ? ? ?2:在当前方法上继续使用throws声明该异常的抛出
 ? ? ? ? ? ? ? ?具体用哪种取决于异常处理的责任问题
 ? ? ? ? ? ? */
 ? ? ? ? ? ?p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
 ? ? ? ? ? ?System.out.println("此人年龄:"+p.getAge()+"岁");
 ? ? ?  } catch (Exception e) {
 ? ? ? ? ? ?e.printStackTrace();
 ? ? ?  }
?
 ? ? ? ?System.out.println("程序结束了...");
 ?  }
}

注意，永远不应当在main方法上使用throws!!

####

总结

缓冲字符输出流

缓冲字符输出流需要记住的是PrintWriter和BufferedReader

作用:

1:块写或块读文本数据加速

2:可以按行写或读字符串

java.io.PrintWriter 具有自动行刷新的缓冲字符输出流

常用构造器

PrintWriter(String filename) :可以直接对给定路径的文件进行写操作

PrintWriter(File file):可以直接对File表示的文件进行写操作

上述两种构造器内部会自动完成流连接操作。

PrintWriter(OutputStream out):将PW链接在给定的字节流上(构造方法内部会自行完成转换流等流连接)

PrintWriter(Writer writer):将PW链接在其它字符流上

PrintWriter(OutputStream out,boolean autoflush)

PrintWriter(Writer writer,boolean autoflush)

上述两个构造器可以在链接到流上的同时传入第二个参数，如果该值为true则开启了自动行刷新功能。

常用方法

void println(String line)：按行写出一行字符串

特点

自动行刷新，当打开了该功能后，每当使用println方法写出一行字符串后就会自动flush一次

java异常处理机制:

• 异常处理机制是用来处理那些可能存在的异常，但是无法通过修改逻辑完全规避的场景。

• 而如果通过修改逻辑可以规避的异常是bug，不应当用异常处理机制在运行期间解决！应当在编码时及时修正

try语句块用来包含可能出错的代码片段

catch用来捕获并处理对应的异常，可以定义多个，也可以合并多个异常在一个catch中。

finally是异常的最后一块，只要程序执行到try中则必走。一般用于释放资源这类操作。

throw用于主动对外抛出异常。要么是满足语法不满足业务主动抛出异常，要么就是实际发生了异常但是不应当在当前代码片段被解决是抛出。具体情况要结合实际业务分析。

throws用于在方法声明时声明该异常的抛出，使得调用者必须处理该异常。