IO流JAVA

最新推荐文章于 2024-08-18 21:36:31 发布

yun_gao_

最新推荐文章于 2024-08-18 21:36:31 发布

阅读量66

点赞数 1

分类专栏： Java基础（课内）文章标签： java windows

本文链接：https://blog.csdn.net/yun_gao_/article/details/117395166

版权

Java基础（课内）专栏收录该内容

16 篇文章 0 订阅

订阅专栏

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("---------------");
	}

}

在这里插入图片描述

yun_gao_

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
IO流JAVA

IO流/** * 硬盘：永久存储 * 内存：临时存储 * io流: * i:input输入（读取）,把硬盘中的数据读取到内存中 * o:output输出（写入）,把内存中的数据写入到硬盘 * 流:数据（字节/字符）1个字符=2个字节 * 1个字节=8个二进制位 * 根据数据不同分为字节流和字符流 * 字节流：InputStream(输入流) OutputStream(输出流) * 字符流： Reader(输入流) Writer(输出流) * * @author ann *
复制链接

扫一扫