黑马程序员-IO流（核心IO流）

最新推荐文章于 2022-02-20 23:23:01 发布

dadaduzidengdai

最新推荐文章于 2022-02-20 23:23:01 发布

阅读量718

点赞数

分类专栏： java 文章标签： Java

本文链接：https://blog.csdn.net/dadaduzidengdai/article/details/9767283

版权

java 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一、操作基本数据类型的流对象

1、概述：

（1）操作基本数据类型的流对象：DataInputStream和DataOutputStream
（2）这两个读写对象，可用于操作基本数据类型的流对象，包含读写各种基本数据类型的方法

2、特有方法：

读写

int型 writeInt(int n) int readInt()

boolean型 writeBoolean(boolean b) boolean readBoolean()

double型 writeDouble(double d) double readDouble()

3、代码示例：

import java.io.*;

class DataStreamDemo {
	public static void main(String[] args) throws IOException {
		writeData();
		readData();

	}

	public static void writeUTFDemo() throws IOException {
		DataOutputStream dos = new DataOutputStream(new FileOutputStream(
				"utfdate.txt"));

		dos.writeUTF("你好");

		dos.close();
	}

	public static void readData() throws IOException {
		DataInputStream dis = new DataInputStream(new FileInputStream(
				"data.txt"));

		int num = dis.readInt();
		boolean b = dis.readBoolean();
		double d = dis.readDouble();
		// 读取基本数据类型。
		System.out.println("num=" + num);
		System.out.println("b=" + b);
		System.out.println("d=" + d);

		dis.close();
	}

	public static void writeData() throws IOException {
		DataOutputStream dos = new DataOutputStream(new FileOutputStream(
				"data.txt"));

		dos.writeInt(234);
		dos.writeBoolean(true);
		dos.writeDouble(9887.543);// 写入基本数据类型。
		dos.close();

	}
}

/*output:
num=234
b=true
d=9887.543
*/

二、操作数组和字符串

1、操作字节数组的对象：ByteArrayInputStream和ByteArrayOutputStream

（1）这个对象并没有调用底层资源，所以不用关闭流资源
（2）存入的是缓冲区，并未用到键盘和硬盘，所以不需要抛任何IO异常
（3）对象中封装了数组
（4）构造函数：
1）ByteArrayInputStream：在构造函数的时候，需要接受数据源，而且数据源是一个字节数据。
2）ByteArrayOutputStream：在构造函数的时候，不用定义数据目的，因为该对象中已经在内部封装了可变长度的字节数组，这就是数据的目的地
（5）因为两个流对象都是操作的是数据，并没有使用系统资源，所以不用进行close关闭。
（6）其实就是用流的思想操作数组
（7）特有方法：writeTo(OutputStream out) 这个方法用到了字节输出流，有异常存在，需要抛IO异常

代码示例1：

/*
 * ByteArrayOutputStream把内存中的数据写到字节数组中,
 * 而ByteArrayInputStream又把字节数组中的字节以流的形式读出,
 * 从而实现了对同一个字节数组的操作
 */
import java.io.*;

public class Test {
	public static void main(String[] args) {
		int a = 0;
		int b = 1;
		int c = 2;
		ByteArrayOutputStream bout = new ByteArrayOutputStream();
		// 将数据写入输出流的内存缓冲区
		bout.write(a);
		bout.write(b);
		bout.write(c);//利用ByteArrayOutputStream把所有的变量收集到一起，然后一次性把数据发送出去。

		// 创建字节数组，并把ByteArrayOutputStream内存缓冲区中的数据以 byte 数组的形式写入字节数组
		byte[] shuZu = bout.toByteArray();
		for (int i = 0; i < shuZu.length; i++)
			System.out.println(shuZu[i]);
		System.out.println("***********************");

		//ByteArrayInputStream把字节数组shuZu作为其缓冲区数组，并把shuZu中的字节以输入流的形式读出
		ByteArrayInputStream bin = new ByteArrayInputStream(shuZu);
		while ((b = bin.read()) != -1) {
			System.out.println(b);
		}
	}
}

/*output:
0
1
2
***********************
0
1
2
*/

代码示例2：

import java.io.*;

class ArrayStreamDemo {
	public static void main(String[] args) {
		// 数据源
		ByteArrayInputStream bais = new ByteArrayInputStream(
				"ABCDEFF".getBytes());
		// 数据目的
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		int by = 0;
		// 读取和写入数据
		while ((by = bais.read()) != -1) {
			baos.write(by);
		}
		System.out.println(baos.size());

		System.out.println(baos.toString());

		try {
			// 方法，此处抛异常，所以上面需要抛出去
			baos.writeTo(new FileOutputStream("a.txt"));
		} catch (IOException e) {
			throw new RuntimeException("写入文件失败");
		}

	}
}

/*output:
7
ABCDEFF
*/

2、对应的操作字符数组和字符串的对象：

字符数组流对象：CharArrayReader和CharArrayWriter
字符串流对象： StringReader和StringWriter

三、字节流常见需求：

需求1：在硬盘上创建一个文件并写入信息(字节流写入时没有刷新)

import java.io.*;

public class ByteDemo {

	public static void main(String[] args) throws Exception {

		FileOutputStream fos = new FileOutputStream("g:\\filestream.txt");
		fos.write(97);// 写入一个字节,int：97代表写入char：a
		fos.write("也可以写入字节数组".getBytes());// 通常使用此种方式写入，直观！
		fos.close();

	}
}

需求2：在硬盘已有文件上续写数据(字节流写入时没有刷新)

import java.io.*;

public class ByteDemo {

	public static void main(String[] args) throws Exception {

		FileOutputStream fos = new FileOutputStream("g:\\filestream.txt", true);
		fos.write("创建字节写入流时，传进去一个true参数就可以继续写入信息".getBytes());
		fos.close();

	}
}

需求3：读取硬盘上的文件

import java.io.*;

public class ByteDemo {

	public static void main(String[] args) throws Exception {

		FileInputStream fis = new FileInputStream("g:\\filestream.txt");
		// 第一种读法：一个字节一个字节的读(此种读法慢)
		int ch = 0;
		while ((ch = fis.read()) != -1) {
			System.out.print((char) ch);
		}
		System.out.println("over");

		// 第二种读法：利用字节数组读(此种读法效率有一定提高)
		byte[] buf = new byte[1024];
		int len = 0;
		while ((len = fis.read()) != -1) {
			System.out.print(new String(buf, 0, len));
		}
		System.out.println("over");
	}
}

需求4：拷贝字节文件，如图片或者MP3或者电影

import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class CopyPhotos {  
  
    /**  
     * 复制一个图片：  
     * 1.用字节读取流和图片关联  
     * 2.用字节写入流对象创建一个图片文件，用于存储获取到得图片数据  
     * 3.第一种拷贝：不带缓冲流，只用数组做缓冲(慢，还是效率问题)
     * 4.通过循环读写，完成数据的存储  
     */  
    public static void main(String[] args) {  
          
         FileOutputStream fos=null;  //定义字节流  
         FileInputStream  fis=null;  
           
         try {  
                 
             fis=new FileInputStream("g://a.jpg");  
             fos=new FileOutputStream("h://b.jpg");  
                 
                 
               //定义数组，作为两个字节流之间的中转站  
               byte[] buf=new byte[1024];   
               int len=0;  
               while((len=fis.read(buf))!=-1){  //循环读写，完成数据的存储  
                     
                    fos.write(buf,0,len);  
               }  
                 
                 
        } catch (FileNotFoundException e) {  
              
            e.printStackTrace();  
        } catch (IOException e) {  
              
            e.printStackTrace();  
        }finally{  
              
              //释放流资源  
             if(fis!=null){  
                   
                 try {  
                    fis.close();  
                } catch (IOException e) {  
              
                    e.printStackTrace();  
                }  
                   
             }  
               
             if(fos!=null){  
                 try {  
                    fos.close();  
                } catch (IOException e) {  
                      
                    e.printStackTrace();  
                }  
                   
             }  
               
        }  
          
    }  
  
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyMp3 {

	/**
	 * 复制一个MP3文件 1.用字节读取流和MP3文件关联 2.用字节写入流对象创建一个MP3文件，用于存储获取到得图片数据
	 * 3.第二种拷贝：带缓冲流，高效 4.通过循环读写，完成数据的存储
	 */
	public static void main(String[] args) {

		FileInputStream fis = null; // 操作数据不是纯文本定义字节流
		FileOutputStream fos = null;

		BufferedInputStream bufis = null; // 定义缓冲区
		BufferedOutputStream bufos = null;

		long start = System.currentTimeMillis(); // 复制文件开始时间

		try {
			fis = new FileInputStream("g://a.mp3"); // 读取，写入文件
			fos = new FileOutputStream("h://b.mp3");

			bufis = new BufferedInputStream(fis);
			bufos = new BufferedOutputStream(fos);

			int len = 0;
			while ((len = bufis.read()) != -1) {

				bufos.write(len);

			}

			long end = System.currentTimeMillis(); // 复制文件结束时间
			System.out.println(end - start + "毫秒"); // 复制文件花费上时间

		} catch (FileNotFoundException e) {

			e.printStackTrace();
		} catch (IOException e) {

			e.printStackTrace();
		} finally {

			// 关闭流资源
			if (bufis != null) {
				try {
					bufis.close();
				} catch (IOException e) {

					e.printStackTrace();
				}
			}

			if (bufos != null) {
				try {
					bufos.close();
				} catch (IOException e) {

					e.printStackTrace();
				}

			}

		}
	}

}

四、字符流常见需求（字符流写入时要刷新）

需求1：在硬盘上创建一个文件并写入信息

import java.io.*;

public class CharDemo {

	public static void main(String[] args) throws Exception {

		// 用字符写入流：FileWriter
		FileWriter fw = new FileWriter("g:\\filewriter.txt");
		fw.write("输入信息");
		fw.write("也可以写入字符数组".toCharArray());
		fw.flush();
		fw.close();

	}
}

需求2：在原有文件上续写数据

import java.io.*;

public class CharDemo {

	public static void main(String[] args) throws Exception {

		FileWriter fw = new FileWriter("g:\\filewriter.txt", true);
		fw.write("还可以续写信息");
		fw.write("也可以写入字符数组".toCharArray());
		fw.flush();
		fw.close();

	}
}

需求3：读取硬盘上的文本文件，并将数据打印在控制台

import java.io.*;

public class CharDemo {

	public static void main(String[] args) throws Exception {

		FileReader fr = new FileReader("g:\\filewriter.txt");
		// 第一种读取方法：一个一个字节的读
		int ch = 0;
		while ((ch = fr.read()) != -1)
			// ch = fr.read();
			System.out.print((char) ch);
		fr.close();

	}
}

需求4：拷贝文本文件

（1）用数组做缓冲区

import java.io.*;

public class CharDemo {

	/**
	 * 拷贝文件步骤： 1.创建一个文件B，用于存储读取A文件内数据 2.定义读取流和A文件关联 3.定义数组，作为读取流和写入流之间联系的桥梁
	 * 4.通过不断的读写完成数据存储 5.关闭流资源
	 */
	public static void main(String[] args) {

		FileWriter fw = null; // 定义写入流
		FileReader fr = null; // 定义读取流

		try {
			fw = new FileWriter("g://hello.txt"); // 创建写入流
			fr = new FileReader("h://demo.txt"); // 创建读取流

			char[] buf = new char[1024]; // 创建数组作为连接写入流与读取流之间的联系桥梁

			int len = 0; // 数组长度变量

			while ((len = fr.read(buf)) != -1) { // 将读取的元素存到数组中

				fw.write(buf, 0, len); // 将数组中的元素写入到写入流中
			}

		} catch (IOException e) {
			System.out.println("拷贝文件失败");
			e.printStackTrace();
		} finally {
			if (fw != null) {
				try {
					fw.close(); // 将写入流中的数据冲入到保存区域并关闭写入流
				} catch (IOException e) {
					System.out.println("关闭写入流失败。。。");
					e.printStackTrace();
				}
				if (fr != null) {
					try {
						fr.close();
					} catch (IOException e) {
						System.out.println("关闭读取流失败。。。");
						e.printStackTrace();
					}
				}

			}
		}

	}

}

（2）用装饰类缓冲区

import java.io.*;

public class CharDemo {

	public static void main(String[] args) throws Exception {

		/*
		 * 利用缓冲区提高数据读写效率 (无缓冲区就相当于一滴一滴的喝水，有缓冲区就相当于一杯一杯的喝水)
		 */
		BufferedReader bufr = new BufferedReader(new FileReader(
				"g:\\filewriter.txt"));
		BufferedWriter bufw = new BufferedWriter(new FileWriter(
				"h:\\copyfilewriter.txt"));
		String line = null;
		while ((line = bufr.readLine()) != null) {
			bufw.write(line);
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();

	}
}

五、转换流：

1、转换流的引入

键盘录入转成大写输出，并判断over结束的程序中使用了到对字节数据的存储，并对回车符进行判断。

发现这个功能和readLine方法一致。
因为readLine是字符流BufferedReader对象中的方法。而键盘录入是字节流。
能不能将这个字节读取流转成字符流呢？因为BufferedReader只能对字符流进行装饰。
这就用到了转换流

2、分类：

|---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
|---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

3、代码示例：

步骤1：读取一个键盘录入

import java.io.*;

public class transform {

	public static void main(String[] args) throws IOException {
		InputStream in = System.in;// 创建一个键盘录入流，流不关则可以一直录入
		int by1 = in.read();// 一次读一个字节
		int by2 = in.read();// 一次读一个字节
		System.out.println((char) by1);// 假设键盘录入的是abcd,则打印a
		System.out.println((char) by2);// 假设键盘录入的是abcd,则打印b
		in.close();
	}

}

步骤2：键盘录入一行数据打印一行数据，如果录入的是over则结束录入

import java.io.*;

public class transform {

	public static void main(String[] args) throws IOException {
		InputStream in = System.in;
		StringBuilder sb = new StringBuilder();
		while (true) {
			int ch = in.read();
			if (ch == '\r')
				continue;
			if (ch == '\n') {
				String line = sb.toString();
				if ("over".equals(line))
					break;
				System.out.println(line.toUpperCase());// 输出大写
				sb.delete(0, sb.length());// 清除上一行录入的数据

			} else
				sb.append((char) ch);
		}
		in.close();

	}

}

步骤3：发现需求2中其实就是读一行的原理，故引入字节通向字符的桥梁：InputStreamReader

import java.io.*;

public class transform {

	public static void main(String[] args) throws IOException {
		// 为提高效率加入缓冲区：
		BufferedReader bufr = new BufferedReader(new InputStreamReader(
				System.in));
		String line = null;
		while ((line = bufr.readLine()) != null) {
			if ("over".equals(line))
				break;
			System.out.println(line.toUpperCase());// 输出大写
		}
		bufr.close();

	}

}

步骤4：键盘录入数据并打印到控制台

import java.io.*;

public class transform {

	public static void main(String[] args) throws IOException {
		BufferedReader bufr = new BufferedReader(new InputStreamReader(
				System.in));
		BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(
				System.out));
		String line = null;
		while ((line = bufr.readLine()) != null) {
			if ("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();

	}

}

步骤5：将键盘录入的数据存储到硬盘文件

/*则只需将(4)中的
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
改为：
BufferedWriter bufw = new BufferedWriter(new FileWriter("g:\\demo.txt"));
 */

import java.io.*;

public class transform {

	public static void main(String[] args) throws IOException {

		BufferedReader bufr = new BufferedReader(new InputStreamReader(
				System.in));
		BufferedWriter bufw = new BufferedWriter(new FileWriter("g:\\demo.txt"));
		String line = null;
		while ((line = bufr.readLine()) != null) {
			if ("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
	}

}

步骤6：将硬盘文件的数据打印到控制台

/*则只需将(4)中的
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
改为：
BufferedReader bufr = new BufferedReader(new FileReader("g:\\demo.txt"));
即：*/

import java.io.*;

public class transform {

	public static void main(String[] args) throws IOException {

		BufferedReader bufr = new BufferedReader(new FileReader("g:\\demo.txt"));
		BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(
				System.out));
		String line = null;
		while ((line = bufr.readLine()) != null) {
			if ("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();

	}

}

dadaduzidengdai

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-IO流（核心IO流）

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------一、操作基本数据类型的流对象1、概述：（1）操作基本数据类型的流对象：DataInputStream和DataOutputStream（2）这两个读写对象，可用于操作基本数据类型的流对象，包含读写各种基本数据类型的方法
复制链接

扫一扫