JAVA 基础IO流
java.io 包中定义了所有的"流"类
如何分类：
按数据流的方向不同可以分为输入流和输出流，读取文件的时候就是数据流
按处理数据单位不同可以分为字节流和字符流，字节（一个字节）010101读的时候，字符（UNCODE 两个字节）：一个字符一个字符读的时候
按功能不同的可以分为节点流和处理流：个人理解的话，节点流其实就是上面说的直接通过InputStream OutputStream Reader Writer 单类进行读取的，而处理流就是要在正常的读取上进行更一步的细化细分，比如 FileInputStream放到了BufferedInputStream中去这种进行包装之后的就叫做处理流
输入流和输出流：
举个例子，如果一个程序要从文件中读取数据，那么这个流是输入流和输出流？
这个应该是相对的，如果对于程序来说这个肯定是输入流，应该要把文件中的数据输入到自身中，但是对于文件来说，那就是输出流，因为自身的数据被读取出来
重点：以后我们都是站到程序的角度上去理解，所以读取文件就要用输入流！！！
凡事以Stream结尾的类都是字节类InputStream OutputStream，字符流的话一般都是Reader Writer（读取的是两个字节的）
需要注意的是：刚才Stream的话是相对于程序的，但是这里Reader就是相对于文件的，比如读取文件用的就是Reader，所以这样理解！
先看输入流输出流，这里用到的是FileInputStream 和 FileOutputStream，它们继承于InputStream 和 OutputStream类
FileInputStream的如下举例，这里实现了通过FileInputStream对象将文件的内容读取出来，并且通过ByteArrayOutputStream对象来将该流中的内容进行保存，所以如果不想要保存的话其实也可以直接输出，看你自己怎么用了
package com.zpchcbd.stream;
import java.io.*;
import java.util.Arrays;
public class MyFileInputStream {
public static void main(String[] args) throws IOException {
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\test.txt");
}catch (FileNotFoundException e){
System.out.println(e);
System.exit(-1);
}
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
byte[] bytes = new byte[1024];
int iReadSize = 0;
try {
while((iReadSize = fileInputStream.read(bytes)) != -1){
byteArrayOutputStream.write(bytes,0,iReadSize);
}
}catch (IOException e){
System.out.println(e);
}
fileInputStream.close();
byteArrayOutputStream.close();
System.out.println(bytes.toString());
}
}
通过，代码如下：
public class MyFileOutputStream {
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\wwww.txt");
String szBufferContent = "aaaaaaaaaaa";
fileOutputStream.write(szBufferContent.getBytes());
}
}
继续看FileReader类，跟流的功能一样，但是唯一的区别就是读取单位的大小不同，Reader、Writer这种一次读取是读两个字节的！！！
public class MyFileReader {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\test.txt");
char[] chars = new char[1024];
int iReadSize = 0;
while((iReadSize = fileReader.read(chars)) != -1){
System.out.println(chars);
}
fileReader.close();
}
}
那么类似的FileWriter类，实现的代码如下，就直接实现一个简单的通过FileReader和FileWriter实现读写的文件操作：
package com.zpchcbd.stream;
import javax.swing.*;
import java.io.*;
public class MyFileWriter {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\test.txt");
FileWriter fileWriter = new FileWriter("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\qqqq.txt");
char[] chars = new char[1024];
int iReadSize = 0;
while((iReadSize = fileReader.read(chars)) != -1){
fileWriter.write(chars);
}
fileReader.close();
fileWriter.close();
}
}
缓存流
继续讲，关于什么是缓冲流（其实是处理流中的一种，进行了封装） 比如BufferedInputStream类 和 BufferedOutputStream类，这种流就是对基本输入流和输出流的增强，提供了一些新的方法以便于更方便的处理
可以看下这些类的构造方法，如下可以看出它是需要一个普通的输入流和输出流作为支撑的，其实也好理解要不然怎么增强呢，一定是基于某种基础上继续加强
public BufferedInputStream(InputStream in) {
this(in, DEFAULT_BUFFER_SIZE);
}
实现方法如下，原本想试下，但是发现mark 和 reset函数不见效，那么这里BufferOutputStream其实也是类似的！
public class MyBufferInputStream{
public static void main(String[] args) throws IOException {
FileInputStream fileInputStream = new FileInputStream("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\wwww.txt");
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
int iReadSize = 0;
byte[] bytes = new byte[1024];
System.out.println(bufferedInputStream.read());
System.out.println(bufferedInputStream.read());
//bufferedInputStream.mark(100);
while((iReadSize = bufferedInputStream.read(bytes)) != -1){
byteArrayOutputStream.write(bytes, 0, iReadSize);
}
System.out.println(byteArrayOutputStream.toString());
//bufferedInputStream.reset();
// while((iReadSize = bufferedInputStream.read(bytes)) != -1){
// byteArrayOutputStream.write(bytes, 0, iReadSize);
// }
// System.out.println(byteArrayOutputStream.toString());
bufferedInputStream.close();
byteArrayOutputStream.close();
}
}
BufferWriter，不同点其实就是读取的字节单位大小，并且还提供了一写好使用的方法，实现的代码如下，这样实现了读取一个字符能够换行的代码！
小提醒：在BufferedReader还提供了一个readline的方法用来读取一行，这里自己就没写了
public class MyBufferedWriter {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\wwww.txt");
FileWriter fileWriter = new FileWriter("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\asdasd.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
int iReadSize = 0;
while((iReadSize = bufferedReader.read()) != -1){
bufferedWriter.write(iReadSize);
bufferedWriter.newLine();
}
bufferedWriter.flush();
bufferedReader.close();
bufferedWriter.close();
}
}
转换流
继续讲，什么是转换流？就是能够实现将字符流与字节流进行相互转换，OutputStreamWriter类 和 InputStreamReader类
OutputStreamWriter类的使用：
例如OutputStream 转换为 Writer来进行写入
public class MyOutputStreamWriter {
public static void main(String[] args) throws IOException {
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\qzczc.txt"));
outputStreamWriter.write("123123123");
System.out.println(outputStreamWriter.getEncoding());
// 扩展：还可以进行追加写入
outputStreamWriter = new OutputStreamWriter(new FileOutputStream("C:\\Users\\dell\\Desktop\\ALL\\javaidea\\MyFirstTestMaven\\javaApp2\\servlet1\\qzczc.txt", true), "ISO8859_1");
System.out.println(outputStreamWriter.getEncoding());
outputStreamWriter.write("321312321");
outputStreamWriter.close();
}
}
InputStreamReader类的使用：
public class MyInputStreamReader {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(System.in); // System.in默认是一个输入流，这个System.in输入流当进行接收的时候会堵塞
BufferedReader bufferedReader = new BufferedReader(inputStreamReader); //能够使用readline方法，更好的测试读取
String szBuffer;
szBuffer = bufferedReader.readLine();
while(szBuffer != null){
System.out.println(szBuffer);
szBuffer = bufferedReader.readLine();
}
bufferedReader.close();
}
}
数据流
DataInputStream 和 DataOutputStream 分别继承自 InputStream 和 OutputStream，它们属于处理流，是在InputStream 和 OutputStream类型的节点流是上。
通过它们这两个类可以实现存取与机器无关的Java原始类型数据的方法
唯一需要注意的就是读取的时候是谁先写入先读谁的，那么也就是dataOutputStream中的数据结构是队列！
public class MyDataOutputStream {
public static void main(String[] args) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
dataOutputStream.writeBoolean(true);
dataOutputStream.writeFloat((float) 0.1);
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
DataInputStream dataInputStream = new DataInputStream(byteArrayInputStream);
boolean bRet = dataInputStream.readBoolean();
System.out.println(bRet);
float fnum = dataInputStream.readFloat();
System.out.println(fnum);
}
}
Print流
PrintWriter PrintInputStream 都属于输出流，分别针对的是字符和字节
1、通过设置系统标准输出的位置，来通过System.out.println来进行写文件
public class MyPrinterStream {
public static void main(String[] args) throws FileNotFoundException {
FileOutputStream fileOutputStream = new FileOutputStream("./aaa.txt");
PrintStream printStream = new PrintStream(fileOutputStream);
System.setOut(printStream);
System.out.println("aaaaaaaaa");
}
}
2、通过命令行窗口中输入内容，将内容写入到指定文件中
public class MyPrinterWriter {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(System.in); //这里的System.in 是一个InputStream
String s = null;
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
FileWriter fileWriter = new FileWriter("./asd.txt");
PrintWriter printWriter = new PrintWriter(fileWriter);
while((s = bufferedReader.readLine()) != null){
if(s.toLowerCase().equals("exit"))break;
System.out.println(s);
printWriter.write(s);
bufferedReader.readLine();
}
printWriter.close();
bufferedReader.close();
}
}
Object流
接口为Serializable序列化和反序列化的实现：
public class MyObjectInputStreamAndOutputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileOutputStream fileOutputStream = new FileOutputStream("./object.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
T t1 = new T();
t1.a = 5555;
objectOutputStream.writeObject(t1);
FileInputStream fileInputStream = new FileInputStream("./object.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
T t2 = (T)objectInputStream.readObject();
System.out.println(t2.a);
}
}
class T implements Serializable{
public int a=1;
public float b = (float) 0.1;
public String c = "123";
}
