I/O流
1.流的概念
流是一个抽象 动态的概念 是一连串连续动态的数据集合。
输入流:通过流将数据源中的数据输送到程序
输出流:通过流将程序中的数据输送到目的数据源
- 输入流
- InputStream
- FileInputStream
- BufferedInputStream
- ObjectInputStream
- Reader
- FileReader
- BufferedReader
- InputStreamReader
- InputStream
- 输出流
- OutputStream
- FileOutStream
- BufferedOutputStream
- ObjectOutPutStream
- Writer
- FileWriter
- BufferedWriter
- OutputStreamWriter
- OutputStream
文件创建
public static void main(String[] args) throws IOException {
//方式1
String location = "d:\\news.txt";
File file = new File(location);
System.out.println(file.createNewFile());
//方式2
String location2 = "d:\\";
File file1 = new File(location2,"news2.txt");
file1.createNewFile();
}
2.java中四大IO抽象类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8vnn6J7z-1665627225066)(2022-07-22-14-04-32.png)]
流的分类
按操作单位:字节流(8 bit) 字符流(字符)
按数据流向:输入流 输出流
按流的角色:节点流 处理流/包装流
该四个类都是抽象类 需要创建子类实现
2.1 字节流(stream结尾)
-
InputStram
- InputStream是一个抽象 类,不可实例化。数据的读取需要由它的子类来实现。根据节点的不同,它派生了不同的节点流子类
- 继承自InputStream的流都是用于向程序中输入程序,且数据的单位为字节(8bit)
- 常用方法:
- int read():读取一个字节的数据,并将字节的值作为int类型返回(0~255之间的一个值)。如果未读出字节则返回-1(返回值-1表示读取结束)
- long skip(long n) 跳过并从输入流中丢弃n个字节的数据
- int read(byte[] b) 从该输入流服务区最多b.length个字节的数据为字节数组
- int read(byte[] b, int off, int len) 从该输入流读取最多,len字节的数据为字节数组。
- void close():关闭输入流对象,释放相关系统资源
-
OutputStream
- 此抽象类是表示字节输出流的所有类的父类,输出流接受输出字节并将这些字节发送到某个目的地。
- 常用方法:
- void write(int n):向目的地中写入一个字节
- void write(byte[] b) 将b.length个字节从指定的字节数组写入此文件输出流。
- void write(byte[] b, int off, int len)将len字节从位于偏移量off的指定字节数组写入此文件
- void close():关闭输出流对象,释放相关系统资源
2.2 字符流(reader或writer结尾)
-
Reader
- Reader用于读取的字符流抽象类,数据单位为字符
- 常用方法:
- int read():读取一个字符的数据,并将字符的值作为int类型返回(0-65535之间的一个值,即Unicode值)。如果未读出字符则返回-1(返回-1表示读取结束)。
- int read(char[] b) 从该输入流服务区最多b.length个字节的数据为字节数组
- int read(char[] b, int off, int len) 从该输入流读取最多,len字节的数据为字节数组。
- void close():关闭流对象,释放相关系统资源。
-
Writer
- Writer用于写入的字符流抽象类,数据单位为字符
- 常用方法:
- void write(int n):向输出流中写入一个字符
- write(char[] cbuf) 写入一个字符数组。
- write(char[] cbuf, int off, int len)` 写入字符数组的一部分。
- void close():关闭输出流对象,释放相关系统资源
2.3 节点流
节点流也被成为低级流,是可以从/向一个特定的IO设备(如磁盘、网络)读/写数据的流。
2.4 处理流
处理流也被称为高级流,处理流是对一个已存在的流进行连接或封装,通过封装后的流来实现数据读/写功能。
3.入门IO流程序
3.1字节流读取
public class IO_Demo {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
int s1 = fis.read();
int s2 = fis.read();
int s3 = fis.read();
int s4 = fis.read();
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
} catch (Exception e) {
e.printStackTrace();
}finally {
if (fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3.2 流的构建
public class IO_Demo2 {
public static void main(String[] args) {
FileInputStream fis = null;
try{
fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
StringBuilder sb = new StringBuilder();
int temp = 0;
while((temp = fis.read()) != -1){
System.out.println(temp);
sb.append((char)temp);
}
System.out.println(sb.toString());
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if (fis != null){
fis.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
4.文件字节流
4.1 文件读取
public class FileDemo {
public static void main(String[] args) throws IOException {
File file = new File("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
System.out.println(file.delete());
System.out.println(file.createNewFile());
System.out.println(file.exists());
System.out.println(file.getName());
}
}
4.2 文件读取与上传Demo
- 一个一个字节读取上传(效率较低)
public class FileDemo { public static void main(String[] args) throws Exception { FileInputStream fis = null; fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32.png"); //创建文件自洁输出流对象 FileOutputStream fos = new FileOutputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png"); File file = new File("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png"); if (fos!=null){ file.delete(); } int temp=0; while((temp=fis.read())!=-1){ fos.write(temp); } if (fis!=null){ fis.close(); }if (fos!=null){ fos.close(); } } }
4.3 利用缓冲区读取上传文件
4.3.1 方法1. 推荐使用
public class FileDemo {
public static void main(String[] args) throws Exception {
FileInputStream fis = null;
fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32.png");
//创建文件自洁输出流对象
FileOutputStream fos = new FileOutputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png");
//创建一个缓冲区
byte[] buff = new byte[1024];
int temp=0;
while((temp=fis.read(buff))!=-1){
fos.write(buff,0,temp);
}
fos.flush();
if (fis!=null){
fis.close();
}if (fos!=null){
fos.close();
}
}
}
```
方法2.
一口气将文件保存在缓冲区相当于一次性读取完全部字节
public class FileDemo {
public static void main(String[] args) throws Exception {
FileInputStream fis = null;
fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32.png");
//创建文件自洁输出流对象
FileOutputStream fos = new FileOutputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png");
//创建一个缓冲区
byte[] buff = new byte[fis.available()];
fis.read(buff);
fos.write(buff);
fos.flush();
if (fis!=null){
fis.close();
}if (fos!=null){
fos.close();
}
}
}
4.4 利用缓冲流提高读写效率
BufferedInputStream 和 BufferedOutputStream
public class FileStreamBuffer {
public static void main(String[] args) throws Exception{
FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
fis = new FileInputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32.png");
bis = new BufferedInputStream(fis);
fos = new FileOutputStream("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\2022-07-22-14-04-32_copy.png");
bos = new BufferedOutputStream(fos);
//缓冲区中,byte数组长度默认是8192
int temp=0;
while((temp = bis.read())!=-1){
bos.write(temp);
}
//关闭顺序:后开先关
if (bis != null){
bis.close();
}if (fis != null){
fis.close();
}if (bos != null){
bos.close();
}if (fos != null){
fos.close();
}
}
}
5.文件字符流
5.1 文件字符输入流
public class FileReaderDemo {
public static void main(String[] args) {
FileReader fr = null;
try{
fr = new FileReader("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
int temp = 0;
while ((temp = fr.read())!=-1){
System.out.println(temp);
System.out.println((char)temp);
}
}catch (Exception e){
e.printStackTrace();
}finally {
try{
if (fr != null){
fr.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
5.2 文件字符输出流
public class FileWriterDemo {
public static void main(String[] args) {
FileWriter fw = null;
FileWriter fw2 = null;
try {
fw = new FileWriter("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
fw.write("文件字符流的输出文件\r\n");
fw.write("文件字符流的输出文件222\r\n");
fw.flush();
fw2 = new FileWriter("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt",true);
fw2.write("fw2");
fw2.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if (fw!=null){
fw.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
5.3 使用字符流实现文本文件的拷贝
public class FileCopy {
public static void main(String[] args) {
FileReader fr = null;
FileWriter fw = null;
try {
fr=new FileReader("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
fw = new FileWriter("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
char[] buffer = new char[1024];//文件字符流没有available方法创建缓冲流大小
int temp = 0;
while((temp=fr.read(buffer))!=-1){
fw.write(buffer,0,temp);
}
fw.flush();
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if (fr!=null){
fr.close();
}
if (fw!=null){
fw.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
5.4 字符输入缓冲流
字符输入缓冲流 BufferedReader
字符输出缓冲流 BufferedWriter
public class BufferedReaderDemo {
public static void main(String[] args) {
FileReader fr = null;
BufferedReader br = null;
try{
fr = new FileReader("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt");
br = new BufferedReader(fr);
String temp = "";
while((temp=br.readLine())!=null){
System.out.println(temp);
}
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if (br!=null){
br.close();
}if (fr!=null){
fr.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
5.5 字符输出缓冲流
BufferedWriter 在自己饿输出缓冲流中可以使用newLine()方法实现换行处理
public class BufferedWriterDemo {
public static void main(String[] args) {
FileWriter fw = null;
BufferedWriter bw = null;
try{
fw = new FileWriter("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
bw = new BufferedWriter(fw);
bw.write("BufferedWriterDemo");
bw.newLine();
bw.write("换行后第二段");
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if (bw!=null){
bw.close();
}if (fw!=null){
fw.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
5.6 使用字符缓冲流实现文件的拷贝
public class FileCopyTools {
public static void main(String[] args) {
copyFile("D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a.txt","D:\\Programs\\java\\idea_workplace\\java基础学习\\Thread\\src\\com\\kk\\demo01\\a2.txt");
}
public static void copyFile(String src,String des){
FileReader fr = null;
BufferedReader br = null;
FileWriter fw = null;
BufferedWriter bw = null;
try{
br = new BufferedReader(new FileReader(src));
bw = new BufferedWriter(new FileWriter(des));
String temp="";
while((temp=br.readLine())!=null){
bw.write(temp);
bw.newLine();
}
bw.flush();
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if (br!=null){
br.close();
}if (fr!=null){
br.close();
}if (bw!=null){
br.close();
}if (fw!=null){
br.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
}
6. 字符流和字节流
文件字节流和文件字符流的区别
1、字节流 :字节读写, 字节流(ASCII)处理二进制文件。
可以传输音频,视频,图片,文本等,传输数据的基本单位为字节。
InputStream OutputStream
2、字符流:快读写 ,字符流(Unicode)处理文本文件。
只能传输纯文本, 传输数据的基本单位为字符 。
FileWriter FileReader 一个字符等于2个字节
IO流:
流向:
输入流 read 读
InputStream
FileInputStream
FileReader
输出流 write 写
OutputStream
FileOutputStream
FileWriter
类型
字节流(读写任意文件) 1 1 1 1 1
FileInputStream
FileOutputStream
字符流(只能读写纯文本文件)中文 4 2
FileReader
FileWriter
7.转换流
public class ConvertStrem {
public static void main(String[] args) throws IOException {
// InputStream is = System.in;
// int input = is.read();//read方法返回字节,接收到ascall码
BufferedReader br = null;
BufferedWriter bw = null;
br = new BufferedReader(new InputStreamReader(System.in));//将字节转化字符,BufferedReader存放字符
bw = new BufferedWriter(new OutputStreamWriter(System.out));
System.out.println(System.in);
while (true){
String input = br.readLine();
bw.write("您输入的是:");
bw.flush();
if ("exit".equals(input)){
break;
}
bw.write(input);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
}
## 标准流
public static void main(String[] args) {
//public final static InputStream in = null
//System.in 编译类型 InputStream 运行类型(通过getClass查看) BufferedInputStream
//表示标准输入 键盘
System.out.println(System.in.getClass());
//public final static PrintStream out = null;
//编译类型 和 运行类型 PrintStream
//表示标准输出 显示器
System.out.println(System.out.getClass());
}
Properties
properties 的父类就是 hashTable
public class Properties02 {
public static void main(String[] args) throws IOException {
//1.创建Properties类
Properties properties = new Properties();
//2.加载指定配置文件
properties.load(new FileReader("src\\com\\kk\\IO\\properties_\\pro.properties"));
properties.list(System.out);
String user = properties.getProperty("user");
System.out.println("用户名:"+user);
}
}