Day35---学习Java第二弹
2021-08-16
Java输入输出流
九. FileWriter类(字符输出流类)
构造方法：FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话，并创建。
如： FileWriter fw = new FileWriter("C:\\1.txt");
FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。
如：FileWriter fw = new FileWriter("C:\\1.txt",ture); //表示在fw对文件再次写入时，会在该文件的结尾续写，并不会覆盖掉。
主要方法：
void write(String str) //写入字符串。当执行完此方法后，字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。
viod flush() //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。
viod close() //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后，再写入或者刷新的话，会抛IOException异常。
十. 如何选择IO流
1、确定是数据源和数据目的（输入还是输出）
源:输入流 InputStream Reader
目的:输出流 OutputStream Writer
2、明确操作的数据对象是否是纯文本
是:字符流Reader，Writer
否:字节流InputStream，OutputStream
3、明确具体的设备。
是硬盘文件：File++：
读取：FileInputStream,, FileReader,
写入：FileOutputStream，FileWriter
是内存用数组
是byte[]：ByteArrayInputStream, ByteArrayOutputStream
是char[]：CharArrayReader, CharArrayWriter
是String：StringBufferInputStream(已过时，因为其只能用于String的每个字符都是8位的字符串), StringReader, StringWriter
是网络用Socket流： 输入socket.getOutputStream() 输出socket.getInputStream()
是键盘：用System.in（是一个InputStream对象）读取，用System.out（是一个OutoutStream对象）打印
4、是否需要转换流
是，就使用转换流，从Stream转化为Reader，Writer：InputStreamReader，OutputStreamWriter
5、是否需要缓冲提高效率
是就加上Buffered：BufferedInputStream, BufferedOuputStream, BuffereaReader, BufferedWriter
6、是否需要格式化输出
例如：将一个文件中数据存储到另一个文件中。JAVA的文件读取主要有字节流读取和字符流读取两种方式，字节流可以既可以操作文本文件，也可以操作非文本文件，如一些二进制数据（图片，视频，对象），而字符流只能操作文本。
将一个文件中数据存储到另一个文件中：
1） 数据源和数据目的：读取流，InputStream/Reader 输出：OutputStream/Writer
2）是否纯文本：是！可以选择Reader Writer和InputStream/OutputStream。
3）设备：是硬盘文件。Reader体系中可以操作文件的对象是 FileReader FileWriter。
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");
4）是否需要提高效率：是，加Buffer
BufferedReader bfr = new BufferedReader(new FileReader("a.txt"); );
BufferedWriter bfw = new BufferedWriter(new FileWriter("b.txt"); );
package com.javademo.demo.io;
import java.io.*;
public class IoFileDemo {
private static int BUFFER_SIZE = 1024;
public static void main(String[] args) throws Exception {
IoFileDemo ioFileDemo = new IoFileDemo();
String fileA = "/Users/huangguisu/a.txt";
String fileB = "/Users/huangguisu/b.txt";
ioFileDemo.copyFileWithBufferStream(fileA, fileB);
}
/**
* 字符流读取：只能操作文本文件
* @param srcFile
* @throws IOException
*/
public String readFile(String srcFile) throws IOException {
FileReader fr = new FileReader(srcFile);//读取流
//不要直接用String直接拼接文本。。效率太低，每次要new新对象，用StringBuilder，StringBuffer都可以
StringBuffer sb = new StringBuffer();
char[] buf = new char[10];
int len;
//读取文件并把它存入buf中，用len返回读到字符的个数，一直读到结尾
while ((len = fr.read(buf)) != -1) {
//buf字符数组里仍有空白没有读入的位置，所以不要直接new String(buf);
String str = new String(buf,0,len);
sb.append(str);
}
fr.close();
return sb.toString();
}
/**
* 字符流读取和写入：只能操作文本
* @param srcFile
* @param dstFile
* @throws IOException
*/
public void copyFileWithString(String srcFile, String dstFile) throws IOException {
FileReader fr = new FileReader(srcFile);//读取流
FileWriter fw = new FileWriter(dstFile);//输出流
char[] buf = new char[10];
int len;
//读取文件并把它存入buf中，用len返回读到字符的个数，一直读到结尾
while ((len = fr.read(buf)) != -1) {
//buf字符数组里仍有空白没有读入的位置，所以不要直接fw.write(buf);可以直接使用fw.write(buf, 0, len);
String str = new String(buf,0,len);
fw.write(str);
}
fr.close();
fw.close();
}
/**
* 使用buffer读取和写入字符流：：只能操作文本
* @param srcFile
* @param dstFile
* @throws IOException
*/
public void copyFileWithBufferedString(String srcFile, String dstFile) throws IOException {
FileReader fr = new FileReader(srcFile);//读取流
FileWriter fw = new FileWriter(dstFile);//输出流
//使用Buffer提高效率
BufferedReader bfr = new BufferedReader(fr);
BufferedWriter bfw = new BufferedWriter(fw);
String str = null;
int j = 1;
while ((str = bfr.readLine()) != null) {
System.out.println("第" + j + "行内容：" + str);
bfw.write(str);
bfw.newLine();//跨平台的换行符
j++;
}
bfr.close();
bfw.close();
fr.close();
fw.close();
}
/**
* 例:将一个二进制数据（图片，视频，对象）文件中数据存储到另一个文件中，只能用xxxStream.
* 当然也可以读取文本文件。
* 字节输入流和输出流
* @param srcFile
* @param dstFile
* @throws IOException
*/
public void copyFileWithStream(String srcFile, String dstFile) throws IOException {
FileInputStream finS = new FileInputStream(srcFile);
FileOutputStream foutS = new FileOutputStream(dstFile);
int c;
while ((c = finS.read()) != -1) {
foutS.write(c);
}
//或者
/*
byte[] buffer = new byte[1024];
int len;
while ((len = finS.read(buffer)) > 0){
foutS.write(buffer, 0, len);
len.flush();
}
*/
finS.close();
foutS.close();
}
/**
* 使用Buffer
* @param srcFile
* @param dstFile
* @throws IOException
*/
public void copyFileWithBufferStream(String srcFile, String dstFile) throws IOException{
FileInputStream finS = new FileInputStream(srcFile);
FileOutputStream foutS = new FileOutputStream(dstFile);
BufferedInputStream bufferedInput = new BufferedInputStream(finS);
BufferedOutputStream bufferedOutput = new BufferedOutputStream(foutS);
byte[] buffer = new byte[BUFFER_SIZE];
int len;
while ((len = bufferedInput.read(buffer)) > 0){
bufferedOutput.write(buffer, 0, len);
bufferedOutput.flush();
}
bufferedInput.close();
bufferedOutput.close();
finS.close();
foutS.close();
}
/**
* BufferedReader则是比InputStreamReader更高级,它封裝了StreamReader类,一次读取取一行的字符
* @param srcFile
* @param dstFile
* @throws IOException
*/
public void copyFileWithBufferStream2(String srcFile, String dstFile) throws IOException {
FileInputStream finS = new FileInputStream(srcFile);
FileOutputStream foutS = new FileOutputStream(dstFile);
InputStreamReader inputStreamReader = new InputStreamReader(finS,"utf8");
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(foutS, "utf8");
BufferedReader brRead = new BufferedReader(inputStreamReader);
BufferedWriter brWriter = new BufferedWriter(outputStreamWriter);
String line = null;
while((line= brRead.readLine()) != null){
System.out.println(line);
brWriter.write(line);
brWriter.newLine();//跨平台的换行符
brWriter.flush();//刷新流
}
brRead.close();
brWriter.close();
finS.close();
foutS.close();
}
}
7、网络（socket）数据交互：
package com.javademo.demo.socket;
import java.io.*;
import java.net.Socket;
public class SocketClient {
public static void main(String args[]) throws Exception{
//1、创建客户端Socket，指定服务器地址和端口
Socket socket = new Socket("127.0.0.1",10000);
//2、获取输出流，向服务器端发送信息：由Socket对象得到输出流
OutputStream output = socket.getOutputStream();//字节输出流
//构造PrintWriter对象：将输出流包装成打印流
PrintWriter printWriter = new PrintWriter(output);
printWriter.write("{'user':'hgs'}");
printWriter.flush();
//3、获取输入流，并读取服务器端的响应信息：由Socket对象得到输入流
InputStream inputStream = socket.getInputStream();
//构造相应的BufferedReader对象
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String info = null;
while((info = bufferedReader.readLine()) != null){
System.out.println("Hello,我是客户端，服务器说："+info);
}
//4、由系统标准输入设备构造BufferedReader对象
BufferedReader stdIn = new BufferedReader( new InputStreamReader(System.in));
String readline;
readline= stdIn.readLine(); //从系统标准输入读入一字符串
//若从标准输入读入的字符串为 "ok"则停止循环
while(!readline.equals("ok")){
//将从系统标准输入读入的字符串输出到Server
printWriter.println(readline);
//刷新输出流，使Server马上收到该字符串
printWriter.flush();
//在系统标准输出上打印读入的字符串
System.out.println("Client:"+readline);
//从Server读入一字符串，并打印到标准输出上
System.out.println("Server:"+bufferedReader.readLine());
readline = stdIn.readLine(); //从系统标准输入读入一字符串
}
}
}
11. IOException异常类的子类
1.public class EOFException ：
非正常到达文件尾或输入流尾时，抛出这种类型的异常。
2.public class FileNotFoundException：
当文件找不到时，抛出的异常。
3.public class InterruptedIOException：
当I/O操作被中断时，抛出这种类型的异常。
