IO流
/**
* 硬盘:永久存储
* 内存:临时存储
* io流:
* i:input输入(读取),把硬盘中的数据读取到内存中
* o:output输出(写入),把内存中的数据写入到硬盘
* 流:数据(字节/字符)1个字符=2个字节
* 1个字节=8个二进制位
* 根据数据不同分为字节流和字符流
* 字节流:InputStream(输入流) OutputStream(输出流)
* 字符流: Reader(输入流) Writer(输出流)
*
* @author ann
*
*/
字节流
字节输出流OutputStream,文件字节输出流FileOutputStream
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
/**
* 一切皆字节:
* 一切文件数据(文本、图片、视频等)在存储时,都以二进制数字的形式保持,都一个一个的字节,那么在传输时也是如此
* 所以,字节流可以传输任意文件数据。
* 在操作流的时候,我们需要明确,无论使用什么样的流对象,底层传输的始终是二进制数据
* @author ann
*
*/
/**
* 字节流
* 字节输入流 InputStream
* 字节输出流 java.io.OutputStream
*所有字节输出流的超类,输出流接受输出字节,并将这些字节发送到某个接收器
*该类定义了一些子类的共性方法
*public void close()关闭此输出流对象并释放与流有关的所有系统资源
*public void write(int b)将指定的字节写入此输出流
*public void write(byte[] b)将b.length个字节从指定的byte数组写入此输出流
*public void write(byte[] b,int off,int len) 将指定的byte数组从偏移量off开始的len个字节写入此输出流
*
* @author ann
*
*/
public class IO_OutputStream {
public static void main(String[] args) throws IOException {
/**
* java.io.FileOutputStream extends OutputStream
* FileOutputStream :文件字节输出流
* 作用:将内存中的数据写入到硬盘的文件中
*
* 构造方法:
* FileOutputStream(String name):创建一个向具有指定名称(路径:相对路径,完整路径)的文件中写入数据的文件输出流
* FileOutputStream(File file):创建一个向指定File对象表示的文件中写入数据的文件输出流
* 参数:写入数据的目的地:
* String name :目的地是一个文件的路径
* File file :目的地是一个文件,实际上也是给出文件的路径
*
* 构造方法的作用:
* 1.创建一个FileOutputStream对象
* 2.会根据构造方法中传递的文件/路径创建一个空的文件
* 3.会把FileOutputStream流对象指向创建好的文件
*
* 写入数据的原理(内存-->硬盘):
* java程序-->JVM-->OS(操作系统)-->操作系统调用写数据的方法-->把数据写入到文件中
*
*
*输出流的使用步骤:
*1.创建一个FileOutputStream对象,构造方法传递写入数据的目的地
*2.调用FileOutputStream对象中的write,把数据写入到文件中
*3.释放资源
*/
//1.创建一个FileOutputStream对象,构造方法传递写入数据的目的地
FileOutputStream fos=new FileOutputStream("KY.txt");
//2.调用FileOutputStream对象中的write,把数据写入到文件中
/**
*写数据的时候回将十进制转换为二进制,任意文本编辑器(记事本等)在打开文件时,都会查询编码表,将字节转化为字符表示
*0-127 查询ASCII表,其他查询系统默认表(GBK)
*/
fos.write(68); //写入一个字节
fos.write("\r\n".getBytes());
fos.write(321); //int类型,取低八位,321-256=65-->A
fos.write("\r\n".getBytes());
// 写100要写3个字节 ASCII码值 49 48 48
fos.write(49);
fos.write(48);
fos.write(48);
fos.write("\r\n".getBytes());
/**一次写多个字节的方法
* public void write(byte[] b):将b.length字节从指定的字节数组写入输出流
* public void write(byte[] b,int off,int len):将指定的字节数组从偏移量off开始将len个字节写入输出流
*如果写的第一个字符是正数(0-127),那么显示时会查询ASCII
*如果写的第一个字节是负数,那么第一个字节和第二个字节组成一个中文显示,查询默认系统显示
*
*/
byte[] b= {65,66,67,68,69};
fos.write(b);
fos.write("\r\n".getBytes());
fos.write(b,2,3);
fos.write("\r\n".getBytes());
/**
* 写入字符串时,可以使用String类中的方法把字符串转换为字节数组
* byte[] getBytes()
*/
fos.write("syqczmcs".getBytes());
System.out.println(Arrays.toString("syqczmcs".getBytes()));
//15个字节,因为编码UTF-8三个字节一个中文[-25, -114, -117, -28, -65, -118, -27, -121, -81, -25, -114, -117, -26, -70, -112]
//10个字节 GBK两个字节一个中文[-51, -11, -65, -95, -65, -83, -51, -11, -44, -76]
//3.释放资源
fos.close();
/**
* 每次重新运行上述代码都会重新创建一个文件,将之前的文件覆盖
*/
/**没有下面这段代码,文件中的内容为:
*
*但是由于根据路径重新创建了文件,并写入b数组,而之前的文件被覆盖了,所以内容变成了:
*ABCDE
*/
FileOutputStream f=new FileOutputStream("KY.txt");
f.write(b);
f.write("\r\n".getBytes());
f.close();
/**
* 数据的追加写/续写:使用两个参数的构造方法
* FileOutputStream(String name,boolean append)
* 创建一个向指定name的文件中写入数据的文件输出流
* FileOutputStream(File file,boolean append)
* 创建一个向指定file对象表示的文件中写入数据的文件输出流
* String name/File file :写入数据的目的地
* boolean append:追加开关
* true:创建流对象,不会覆盖原文件,继续在文件的末尾追加写数据
* false:创建一个新文件,覆盖原文件
*/
/**覆盖,内容为:
* 你好
*
*/
FileOutputStream f_f=new FileOutputStream("KY.txt",false);
f_f.write("你好".getBytes());
f_f.write("\r\n".getBytes());
f_f.close();
/**追加续写,内容为:
你好
你好
*/
FileOutputStream f_t=new FileOutputStream("KY.txt",true);
f_t.write("你好".getBytes());
f_t.write("\r\n".getBytes());
f_t.close();
}
}
字节输入流InputStream,文件字节输入流FileInputStream
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
/**
* InputStream字节输入流,此抽象类表示字节输入流的所有类的超类
* 定义了所有子类共性的方法:
* int read()从输入流中读取一个字节
* int read(byte[] b)从输入流中读取一定数量的字节,并将其存储在缓冲区数组b中
* public void close()关闭此输入流与流关联的所有资源
* @author ann
*
*java.io.FileInputStream extends InputStream
*文件字节输入流
*作用:把硬盘文件中的数据读取到内存中使用
*
*构造方法:
*FileInputStream(String name)
*FileInputStream(File file)
*参数:读取文件的数据源
*构造方法作用:
*1.会创建一个FileInputStream对象
*2.会把FileInputStream对象指向构造方法中要读取的文件
*
*读取数据的原理(硬盘-->内存):
*java程序--->JVM-->OS--->OS读取数据的方法--->读取文件
*
*字节输入流的使用步骤:
*1.创建FileInputStream对象,构造方法中绑定要读取的数据源
*2.使用FileInputStream对象中的read方法,读取文件
*3.释放资源
*
*
*
*/
public class IO_InputStream {
public static void main(String[] args) throws IOException {
//1.创建FileInputStream对象,构造方法中绑定要读取的数据源
FileInputStream fis=new FileInputStream("szd.txt");
//2.使用FileInputStream对象中的read方法,读取文件
// int len=fis.read();//读取文件中的一个字节并返回,读取到文件末尾返回-1
// System.out.println(len);//A-->65
// System.out.println(fis.read());//-1
//
//利用循环优化,注意读取的数据会自动后移
int len=0;
while((len=fis.read())!=-1) { //注意不要直接写成fis.read(),这样返回的数据没有记录下来,而下次读则是下一个字节数据
System.out.println((char)len);
}
//3.释放资源
fis.close();
System.out.println("----------------");
/**
* 一次读入多个字节的方法
* int read(byte[] b)
* 返回的是读取的有效个数
* 数组起到缓存作用
* 数组的长度一般定义为1024(1kb)或者1024的整数倍
*/
FileInputStream f=new FileInputStream("szd.txt");
byte[] b=new byte[2];
len=f.read(b);
System.out.println(len);
System.out.println(new String(b));
len=f.read(b);
System.out.println(len);
System.out.println(new String(b));
len=f.read(b);
System.out.println(len);
System.out.println(new String(b));
len=f.read(b);
System.out.println(len);
System.out.println(new String(b));
len=f.read(b);
System.out.println(len);
System.out.println(new String(b));
len=f.read(b);
System.out.println(len);
System.out.println(new String(b));
len=f.read(b);
System.out.println(len);
System.out.println(new String(b));
/**内容:
2
He
2
ll
2
o
2
Wo
2
rl
1
dl
-1
dl
*/
f.close();
System.out.println("----------------");
FileInputStream f1=new FileInputStream("szd.txt");
byte[] d=new byte[2];
while((len=f1.read(d))!=-1) {
System.out.println(len);
System.out.println(new String(d));
}
/**内容
2
He
2
ll
2
o
2
Wo
2
rl
1
dl
*/
f1.close();
System.out.println("----------------");
}
}
字符流
/**
* 字符流:
* 当使用字节流读取文本文件时,遇见中文字符时,可能不会显示完整的字符,因为一个中文字符占用多个字节存储。
* 所以java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件
* 字符输入流 Reader
* 字符输出流Writer
* @author ann
*
*/
字符输出流Writer,文件字符输出流FileWriter
import java.io.FileWriter;
import java.io.IOException;
/**
* 字符输出流Writer
* 字符输出流的抽象类,具有子类的一些共性方法
* void write(int c)写入单个字符
* void write(char[] c)写入字符数组
* abstract void write(char[],int off,int len)写入字符数组的一部分,从索引off开始的len个字符
* void write(String s)写入字符串
* void write(String,int off,int len)
* void flush刷新该流的缓存
* void close
*
* java.io.FileWriter extends OutputStreamWriter extends Writer
* FileWriter 文件输出流
* 作用:将文件中的字符数据写入文件中
* 构造方法:
* FileWriter(File file)
* FileWriter(String filename)
* 参数:写入数据的目的地
* 构造方法的作用:
* 1.创建一个FileWriter对象
* 2.根据构造方法的参数创建一个文件
* 3.将FileWriter对象指向创建的文件
* @author ann
*
*/
public class IO_Writer {
public static void main(String[] args) throws IOException {
/**
* FileWriter的使用步骤:
* 1.创建FileWriter对象,创建文件,绑定目的地
* 2.利用FileWriter的方法write,把数据写入到内存缓冲区中(将字符转换为字节的过程)
* 3.使用FileWriter的方法flush,把内存缓冲区中的数据刷新带目的地文件中
* 4.释放资源(会先把内存缓冲区中的数据刷新到目的地中,所以flush可以略)
*/
FileWriter f=new FileWriter("W&W.txt");
f.write(66);
f.flush();//刷新缓存区,流对象还可以继续使用,而close方法先刷新缓冲区,然后通知系统释放资源,流对象不可以再使用
f.close();//如果没有使用flush方法也没有使用close方法则数据不会被刷新到目的地文件中
/**
* 一次写多个字符
* void write(char[] c)写入字符数组
*/
FileWriter f1=new FileWriter("W&W.txt");
char[] c= {'w','&','w'};
f1.write(c);
f1.write("\r\nyyds");//\r\n表示换行
f1.close();
/**
* 续写和字节输出流一样,使用两个参数的构造方法,这里略
*/
}
}
字符输入流Reader,文件字符输入流FileReader
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
/**
* 字符输入流
* java.io.Reader抽象类是表示用于读取所有类的超类,可以读取字符信息到内存中,它定义了字符输入流的基本共性方法
* int read()读取单个字符并返回
* int read(char[] c)一次读取多个字符并将字符读入数组
* void close()关闭并释放与输入流对象有关的所有资源
*
* java.io.FileReader extends InputStreamReader extends Reader
* FileReader 文件字符输入流
* 作用:将硬盘文件中的数据以字符的方式读取到内存中
* 构造方法:
* FileReader(String filename)
* FileReader(File file)
* 参数:读取文件的数据源
* 构造方法的作用:
* 1.创建一个FileReader对象
* 2.会把FileReader对象指向要读取的文件
* @author ann
*
*/
public class IO_Reader {
public static void main(String[] args) throws IOException {
/**
* 文件字符输入流的使用步骤:
* 1.创建FileReader对象,绑定数据源
* 2.使用FileReader的方法read读取数据
* 3.释放资源
*/
FileReader f=new FileReader("KY.txt");
int len=0;
while((len=f.read())!=-1) {
System.out.print((char)len);
}
/**读取内容:
你好
bilibili
你好
*/
f.close();
System.out.println("---------------");
/**
* int read(char[] c)
* 一次读取多个字符,将字符写入数组,返回每次读取的有效字符个数
*/
FileReader f1=new FileReader("KY.txt");
char[] c=new char[1024];
while((len=f1.read(c))!=-1) {
System.out.println(len);
System.out.println(new String(c));
}
System.out.println("---------------");
}
}