java基础_IO流

最新推荐文章于 2024-06-28 17:10:16 发布

伊人-博缘

最新推荐文章于 2024-06-28 17:10:16 发布

阅读量142

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/weixin_44209060/article/details/106376067

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1、 IO流：

输入、输出流,是将数据持久化保存到硬盘中，和数据库的作用一样

2、流的分类：

字节流、字符流、转换流、缓冲流、序列化流与反序列化流、打印流

3、流

3.1、字节流

3.1.1 、字节输出流OutPutStream

字节输出流：OutPutStream    抽象类
所有字节输出流的超类
作用：从java程序中写出文件
字节：这样的流每次只操作文件中的1个字节
写任意文件

方法都是写文件的方法

write(int b) 写入1个字节
write(byte[] b) 写入字节数组
write(byte[],int index,int length) 写入字节数组，index表示开始的索引，length表示个数
close()方法，关闭流对象，释放与流相关的资源。

注意：流对象操作文件时，自己不做，依赖于操作系统。

FileOutputStream类

子类构造方法：绑定输出的输出目的

FileOutputStream(File file) 
          创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(String name) 
          创建一个向具有指定名称的文件中写入数据的输出文件流。

写入数据到文件中

public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		//需求：将数据写入到文件中。
		//创建存储数据的文件。
		File file = new File("c:\\file.txt");
		//创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
		//输出流目的是文件，会自动创建。如果文件存在，则覆盖。
		FileOutputStream fos = new FileOutputStream(file);
		//调用父类中的write方法。
		byte[] data = "aaaa".getBytes();
		fos.write(data);
		//关闭流资源。
		fos.close();
	}
}

3.1.2 、字节输入流InputStream

读取任意文件，每次只读取1个字节

	int read():读取一个字节并返回，没有字节返回-1.
	int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。

3.1.2.1 、FileInputStream类

InputStream有很多子类，其中子类FileInputStream可用来读取文件内容。
FileInputStream 从文件系统中的某个文件中获得输入字节。

构造方法：为这个流对象绑定对象

FileInputStream(File file) 
          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String name) 
          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

public class FileInputStreamDemo {
  public static void main(String[] args) throws IOException {
  
		File file = new File("d:\\file.txt");
		// 创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
		FileInputStream fis = new FileInputStream(file);		
		//创建一个字节数组。
		byte[] buf = new byte[1024];//长度可以定义成1024的整数倍。		
		int len = 0;
		while((len=fis.read(buf))!=-1){
			System.out.println(new String(buf,0,len));
		}
		fis.close();
	}
}

** 1、read()方法**
read()方法执行一次，就会读取下一个字节；
返回值，返回的是读取到的字节，使用循环的方式读取文件，到达结尾后返回-1；

int ch = 0;
	while((ch=fis.read())!=-1){
		System.out.println("ch="+(char)ch);
}

** 2、int read(byte[] b)方法**
读取字节数组，缓冲作用，提高效率
read 中返回int:读取到多少个有效的字节数

3.2 、字符输出流

3.2.1、概念

在操作过程中字节流可以操作所有数据，可是当我们操作的文件中有中文字符，
就需要字符流来操作。
Writer是写入字符流的抽象类，写文件，文本文件

 void write(char[] cbuf) 
          写入字符数组。 
abstract  void write(char[] cbuf, int off, int len) 
          写入字符数组的某一部分。 
 void write(int c) 
          写入单个字符。 
 void write(String str) 
          写入字符串。 
 void write(String str, int off, int len) 
          写入字符串的某一部分。

3.2.2、write 类的子类对象FileWriter

构造方法摘要

FileWriter(File file) 
          根据给定的 File 对象构造一个 FileWriter 对象。 
FileWriter(File file, boolean append) 
          根据给定的 File 对象构造一个 FileWriter 对象。 
FileWriter(String fileName) 
          根据给定的文件名构造一个 FileWriter 对象。 
FileWriter(String fileName, boolean append) 
          根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

注意：写入字符到文件中，先进行流的刷新，再进行流的关闭。

public class FileWriterDemo {
	public static void main(String[] args) throws IOException {
		//FileWriter 用于操作文件。
		FileWriter fw = new FileWriter("d：\\text\\fw.txt");
		fw.write("这些文字都要先编码");//这些文字都要先编码,写入到了流的缓冲区中。
		fw.flush();
		fw.close();
	}
}

3.3 、字符输入流Reader

3.3.1、概念

只能读取文本文件。

read():读取单个字符并返回
read(char[]):将数据读取到数组中，并返回读取的个数。

3.3.2、 FileReader类

中英文可读，不乱码，默认GBK

FileReader(File file) 
          在给定从中读取数据的 File 的情况下创建一个新 FileReader。 
FileReader(String fileName) 
          在给定从中读取数据的文件名的情况下创建一个新 FileReader。

3.4、转换流

指定编码,操作文本文件

3.4.1、OutputStreamWriter类继承了Writer类

OutputStreamWriter 是字符流通向字节流的桥梁：
可使用指定的字符编码表，将要写入流中的字符编码成字节。

构造方法

OutputStreamWriter(OutputStream out) 
          创建使用默认字符编码的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName) 
          创建使用指定字符集的 OutputStreamWriter。

public  void writedemo() throws Exception {
	//创建与文件关联的字节输出流对象
	FileOutputStream fos = new FileOutputStream("c:\\writer.txt");
	//创建可以把字符转成字节的转换流对象，并指定编码
	OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
	//调用转换流，把文字写出去，其实是写到转换流的缓冲区中
	osw.write("你好");//写入缓冲区。
	osw.close();
	}

3.4.2、InputStreamReader类

InputStreamReader 是字节流通向字符流的桥梁：
它使用指定的字符编码表读取字节并将其解码为字符。

构造方法

InputStreamReader(InputStream in) 
          创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName) 
          创建使用指定字符集的 InputStreamReader。

  public class InputStreamReaderDemo {
	public static void main(String[] args) throws IOException {
		//调用方法
		readdemo();
	}
	public static void readdemo() throws IOException{
		//创建读取文件的字节流对象
		InputStream in = new FileInputStream("c:\\input.txt");
		//创建转换流对象 
		/*
		//创建对象，会用本地默认码表读取，将会发生错误解码的错误
		InputStreamReader isr = new InputStreamReader(in);
		*/
        InputStreamReader isr = new InputStreamReader(in,"UTF-8");
		//使用转换流去读字节流中的字节
		int ch = 0;
		while((ch = isr.read())!=-1){
			System.out.println((char)ch);
		}
		//关闭流
		isr.close();
	}
}

4、缓冲流

数据流大时，提高效率问题

4.1、字节缓冲流

字节缓冲流根据流的方向，共有2个
	写入数据到流中，字节缓冲输出流 BufferedOutputStream
	读取流中的数据，字节缓冲输入流 BufferedInputStream

它们的内部都包含了一个缓冲区，通过缓冲区读写，就可以提高了IO流的读写速度

4.1.1、字节输出流的缓冲流BufferedOutputStream

作用：提高原有输出流的写入效率
继承 outPutStream

构造方法
public BufferedOutputStream(OutputStream out)
可以传递任意字节输出流，传递的是哪个字节流，就对哪个字节流提高效率

public static void main(String[] args) throws IOException {
	private static void write(){
	//创建基本的字节输出流
	FileOutputStream fileOut = new FileOutputStream("test.txt");
	//使用高效的流，把基本的流进行封装，实现速度的提升
	BufferedOutputStream out = new BufferedOutputStream(fileOut);
	//2，写数据
	out.write("hello world".getBytes());
	//3，关闭流
	out.close();
	}
	}

4.1.2、字节输入流的缓冲流

继承InputStream

构造方法
public BufferedInputStream(InputStream in) 
可以传递字节输入流FileInputStream

public static void main(String[] args) throws IOException {
	private static void read() {
		//1,创建缓冲流对象
		FileInputStream fileIn = new FileInputStream("test.txt");
		//把基本的流包装成高效的流
		BufferedInputStream in = new BufferedInputStream(fileIn);
		//2，读数据
		int ch = -1;
		while ( (ch = in.read()) != -1 ) {
			//输出
			System.out.print((char)ch);
		}
		//3，关闭
		in.close();
	}

4.2、字符缓冲流

	字符缓冲输入流 BufferedReader
	字符缓冲输出流 BufferedWriter

完成文本数据高效的写入和读取操作

4.2.1、字符输出流的缓冲流BufferedWriter

继承Writer

构造方法
BufferedWriter(Writer w)传递任意字符输出流传递谁就高效谁
能传递的字符输出流FileWriter,OutputStreamWriter

方法：
void newLine() 文本中换行,\r\n也是换行，该方法具有平台无关性

public static void main(String[] args) throws IOException {
		//创建流
		//基本字符输出流
		FileWriter fileOut = new FileWriter("file.txt");
		//把基本的流进行包装
		BufferedWriter out = new BufferedWriter(fileOut);
		//2，写数据
		for (int i=0; i<5; i++) {
			out.write("hello world");
			out.newLine();
		}
		//3,关闭流
		out.close();
	}

4.2.2、字符输入流的缓冲流BufferedReader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
继承Reader

public static void main(String[] args) throws IOException {
		//1创建流
		BufferedReader in = new BufferedReader(new FileReader("test1.txt"));
		//2读数据
		//一次一个字符
		//一次一个字符数组
		//一次读取文本中一行的字符串内容
		String line = null;
		while( (line = in.readLine()) != null ){
			System.out.println(line);
		}
		
		//3关闭流
		in.close();
	}

5、Properties类

5.1、概念

	Properties 类表示了一个持久的属性集。
	Properties 可保存在流中或从流中加载。
	     属性列表中每个键及其对应值都是一个字符串。
特点：
	1、Hashtable的子类，map集合中的方法都可以用。
	2、该集合没有泛型。键值都是字符串。
	3、它是一个可以持久化的属性集。键值可以存储到集合中，
	   也可以存储到持久化的设备(硬盘、U盘、光盘)上，
	   键值的来源也可以是持久化的设备。

5.2、方法

  load(InputStream)把指定流所对应的文件中的数据，
       读取出来，保存到Propertie集合中
  store(OutputStream,commonts)把集合中的数据，
       保存到指定的流所对应的文件中，参数commonts代表对描述信息

	public static void main(String[] args) throws IOException {
		//1，创建Properties集合
		Properties prop = new Properties();
		//2，添加元素到集合
		prop.setProperty("周迅", "张学友");
		prop.setProperty("李小璐", "贾乃亮");
		prop.setProperty("杨幂", "刘恺威");
		
		//3，创建流
		FileWriter out = new FileWriter("prop.properties");
		//4，把集合中的数据存储到流所对应的文件中
		prop.store(out, "hello world");
		//5，关闭流
		out.close();
	}

	public static void main(String[] args) throws IOException {
		//1，创建集合
		Properties prop = new Properties();
		//2，创建流对象
		FileInputStream in = new FileInputStream("prop.properties");
       //FileReader in = new FileReader("prop.properties");
		//3,把流所对应文件中的数据 读取到集合中
		prop.load(in);
		//4,关闭流
		in.close();
		//5,显示集合中的数据
		System.out.println(prop);	
	}

6、序列化与序列化流

用于从流中读取对象的
操作流 ObjectInputStream称为反序列化流
用于向流中写入对象的操作流 ObjectOutputStream 称为序列化流
	特点：用于操作对象。可以将对象写入到文件中，也可以从文件中读取对象。

7、打印流

打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
打印流根据流的分类：
	字节打印流	PrintStream
	字符打印流	PrintWriter
	方法：
void print(String str): 输出任意类型的数据，
void println(String str): 输出任意类型的数据，自动写入换行操作

8、 commons-IO工具

8.1、FilenameUtils

  这个工具类是用来处理文件名，他可以轻松解决不同操作系统文件名称规范不同的问题
常用方法：
getExtension(String path)：获取文件的扩展名；
getName()：获取文件名；
isExtension(String fileName,String ext)：判断fileName是否是ext后缀名；

8.2、FileUtils

   提供文件操作（移动文件，读取文件，检查文件是否存在等等）的方法。
常用方法：
readFileToString(File file)：读取文件内容，并返回一个String；
writeStringToFile(File file，String content)：将内容content写入到file中；
copyDirectoryToDirectory(File srcDir,File destDir)：文件夹复制
copyFile(File srcFile,File destFile)：文件夹复制

9、总结

把IO流进行了规律的总结(四个明确)：

明确一：要操作的数据是数据源还是数据目的。
    源：InputStream    Reader
	目的：OutputStream Writer
先根据需求明确要读，还是要写。

明确二：要操作的数据是字节还是文本呢？
	源：
		字节：InputStream
		文本：Reader
	目的：
		字节：OutputStream
		文本：Writer

明确三：明确数据所在的具体设备。
	源设备：
		硬盘：文件  File开头。
		内存：数组，字符串。
		键盘：System.in;
		网络：Socket
	目的设备：
		硬盘：文件  File开头。
		内存：数组，字符串。
		屏幕：System.out
		网络：Socket
具体要使用哪个流对象。

明确四：是否需要额外功能呢？
	额外功能：
		转换吗？转换流。InputStreamReader OutputStreamWriter
		高效吗？缓冲区对象。BufferedXXX