Java基础-知识点总结-Java IO(三)字节流

Java IO(三)-字节流

【字节流】

 

      【字节流继承体系简图】

    【FileOutputStream】

 

 

 

		FileOutputStream fos = new FileOutputStream("fos.txt");
		fos.write("hello java".getBytes());
		fos.close();

 

 

 

 

             FileOutputStream-write：

 

                    public voidwrite(byte[] b)throwsIOException：

 

                           将b.length个字节从指定的 byte数组写入此输出流。write(b)的常规协

 

                           定是：应该与调用write(b, 0, b.length) 的效果完全相同。

 

                    publicvoidwrite(byte[] b,int off, int len)throwsIOException：

 

                           将指定 byte数组中从偏移量off开始的len个字节写入此输出流。

 

                           write(b,off, len)的常规协定是：将数组b中的某些字节按顺序写入输出

 

                           流；元素b[off]是此操作写入的第一个字节，b[off+len-1]是此操作写入

 

                           的最后一个字节。

 

                    publicabstract voidwrite(int b)throwsIOException：

 

                           将指定的字节写入此输出流。write的常规协定是：向输出流写入一个字

 

                           节。要写入的字节是参数 b的八个低位。b的 24个高位将被忽略。

 

                           OutputStream的子类必须提供此方法的实现。

 

             FileOutputStream-close：

 

                    publicvoidclose()throwsIOException：

 

                           关闭此输出流并释放与此流有关的所有系统资源。close的常规协定是：

 

                           该方法将关闭输出流。关闭的流不能执行输出操作，也不能重新打开。

 

                           OutputStream的 close方法不执行任何操作。

 

             FileOutputStream-flush：

 

                    publicvoidflush()throwsIOException：

 

                           刷新此输出流并强制写出所有缓冲的输出字节。flush的常规协定是：如果

 

                           此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将

 

                           这些字节立即写入它们预期的目标。

 

      【FileInputStream】

 

		FileInputStream fis = new FileInputStream("fos.txt");
		int ch = 0;
		while ((ch = fis.read()) != -1)
			System.out.println((char) ch);

		FileInputStream fis1 = new FileInputStream("fos.txt");
		byte[] b = new byte[1024];
		int line = 0;
		while ((line = fis1.read(b)) != -1)
			System.out.println(new String(b, 0, line));

		FileInputStream fis2 = new FileInputStream("fos.txt");
		int num = fis2.available();
		System.out.println("num = " + num);
		byte[] b1 = new byte[num];
		fis.read(b1);

 

 

 

 

	       System.out.println(new String(b1));

 

 

 

 

 

 

 

             注意：如果数据不大，则第三种方式最优；如果数据太大，则第二种方式最优

 

             FileInputStream-read：

 

                    public abstract intread()throwsIOException：

 

                           从输入流中读取数据的下一个字节。返回0到255范围内的 int字节

 

                           值。如果因为已经到达流末尾而没有可用的字节，则返回值-1。

 

                    publicintread(byte[] b)throwsIOException：

 

                           从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。以整

 

                          数形式(取到的流中的数据长度)返回实际读取的字节数。

 

                    publicintread(byte[] b, int off, int len)throwsIOException：

 

                           将输入流中最多len个数据字节读入 byte数组。尝试读取len个字节，

 

                           但读取的字节也可能小于该值。以整数形式(取到的流中的数据长度)返回

 

                           实际读取的字节数。

 

             FileInputStream-close：

 

                    public voidclose()throwsIOException：

 

                           关闭此输入流并释放与该流关联的所有系统资源。

 

             FileInputStream-available：

 

                    public intavailable()throwsIOException：

 

                           返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）

 

                           的估计字节数。下一个调用可能是同一个线程，也可能是另一个线程。一

 

                           次读取或跳过此估计数个字节不会受阻塞，但读取或跳过的字节数可能小

 

                           于该数。(返回流中数据的长度)

 

      【字节流缓冲区】

 

             功能和字符流缓冲区一样

 

             对应类：

 

                    -BufferedInputStream

 

                    -BufferedOutputStream

 

             例：拷贝MP3文件

 

		BufferedInputStream bfis = new BufferedInputStream(
				new FileInputStream("我们好像在哪见过.mp3"));
		BufferedOutputStream bfos = new BufferedOutputStream(
				new FileOutputStream("我们好像在哪见过(2).mp3"));
		int bt = 0;
		while ((bt = bfis.read()) != -1)
			bfos.write(bt);
		System.out.println("拷贝完成！");
		bfos.close();
		bfis.close();

 

 

 

 

      【InputStream-read和OutputStream-write】

 

             InputStream-read：

 

1. read():

   返回int ，且范围为0到255间int值，从输入流读取下一个数据字节，

                               它是以字节为单位来读的，即每次只读取一个字节内容，读取后面三前面

                               补三个字节的0，这样读取出来的结果就永远为正，且为0到255间的数。

                               相当于将读取到的数据字节先提升为int型数据，然后在与上255如果因

   已到达流末尾而没有可用的字节，则返回值-1。

2. read(byte[] b) read(byte[]b,int off,int len):

   不会有byte到int提升的过程，byte数组b里存储的就是真实的编码。

    

                 OutputStream-write：

                        Write(int b):

                               向输出流写入一个字节。要写入的字节是参数b的八个低位。b的24个高

                               位将被忽略。相当于将int型数据强制转换为字节数据，保留有效数据。

   【读取键盘录入】

 

import java.io.*;

/*
 需求：
 读取键盘录入信息，按回车键打印录入数据，输入over按回车
 */
class ReadIn {
	public static void main(String[] args) {
		InputStream in = null;
		// 定义缓冲区
		StringBuilder sb = new StringBuilder();
		try {
			// 读取键盘录入
			in = System.in;
			while (true) {
				int ch = in.read();
				if (ch == '\r')
					continue;
				if (ch == '\n') {
					String s = sb.toString();
					// 判断输入数据是否为over，是则推出循环，结束程序
					if ("over".equalsIgnoreCase(s))
						break;
					// 打印一次清空一次sb容器
					sb.delete(0, sb.length());
					System.out.println(s);
				} else
					sb.append((char) ch);
			}
		} catch (IOException e) {
			System.out.println(e.toString());
		} finally {
			try {
				if (in != null)
					in.close();
			} catch (IOException e) {
				System.out.println(e.toString());
			}
		}
	}
}