黑马程序员--IO（一）--概述、字符流、字节流、流操作规律

黑马程序员--IO（一）--概述、字符流、字节流、流操作规律

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、概述

1、IO流(Input Output)：用来处理设备之间的数据传输。java对数据的操作通过流的方式。java用于操作流的对象都在IO包中。

分类：

流按流分为：输入流和输出流。将外设中的数据读取到内存中：输入。将内存中数据写入到外设中：输出。

流按操作数据分为：字节流和字符流。

PS：

流只能操作数据，不能操作文件。

2、常用基类

字节流的抽象基类：InputStream OutputStream

字符流的抽象基类：Reader Writer

PS:

由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：Reader的子类FileReader。

二、字符流

1、简述

由于字节流是单字节处理方式，当处理汉字这样双字节字符时，它就显得不太方便，这时我们通过字节流+编码表的方式获取字符流。

即让字节流读取文字字节数据后，不直接操作而是先查指定的编码表，获取对应的文字。来便捷文字操作。

字符流的抽象基类：Reader Writer

2、字符流的读写

读取方式有两种：

read()：一次读一个字符。而且会自动往下读。

read(char[] cbuf):将字符读入数组。更优。

//字符流读取数据方式有两种
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args)throws IOException
{
//创建一个文件读取流对象和指定名称的文件相关联。
//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
FileReader fr = new FileReader("demo.txt");

int ch = 0;

//第一种方式：调用读取流对象的read()方法,它一次读一个字符。而且会自动往下读。
while((ch=fr.read())!=-1)
{
System.out.println("ch="+(char)ch);
}

FileReader fr2 = new FileReader("demo.txt");

//第二种方式：read(char[] cbuf):将字符读入数组。以数组形式读取，一次性输出。更优。
char[] buf = new char[1024];

int num = 0;
while((num=fr2.read(buf))!=-1)
{
System.out.println(new String(buf,0,num));
}

fr.close();
}
}

/*
字符流：写入、续写、异常处理。
需求：在硬盘上，创建一个文件并写入一些文字数据。处理文字数据首先要考虑字符流。

FileWriter:专门用于操作文件的Writer子类对象。后缀名是父类名；前缀名是流对象功能。
FileWriter会将文件创建到指定目录下，如果该目录下已有同名文件，将被覆盖。
flush()：用于对文件刷新。作用：将写入字符流输出到指定文件中。
close和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
*/
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
FileWriter fw = null;
try
{	//创建一个FileWriter对象。初始化时必须明确被操作文件。在构造函数中加入true，可实现对文件续写。
fw= new FileWriter("demo.txt",true);

//调用Write方法，字符串写入到流中。
fw.write("---www\r\neeeee");
}
//处理异常
catch(IOException e)
{
System.out.println("wrong:"+e.toString());
}
//用finally关闭流，可防止代码异常时流无法关闭的问题。
finally
{
try
{
if(fw!=null)
//关闭流资源，但是关闭前会刷新一次内部的缓冲的数据。
fw.close();
}
catch(IOException e)
{
System.out.println("wrong too:"+e.toString());
}
}
}
}

3、字符流的缓冲区-->BufferedWriter、BufferedReader

a 作用：在流的基础上对流的功能进行了增强。所以缓冲区创建之前，必须有对应的流对象。

b 原理：将数据以数组形式储存在内部，最后一次性取出。减少了数据的在内存上的读取频率，提高效率。

newLine()：写入换行，返回数据及回车符。属于BufferedWriter类。可以跨平台。

readLine()：读取一行数据。属于BufferedReader类。

原理：使用read方法，缓冲读取到的字符并判读换行标记，将标记前的缓冲数据变成字符串返回。

//缓冲区的应用：通过缓冲区复制一个java文件
import java.io.*;
class CopyByBuf
{
public static void main(String[] args)
{
//缓冲区要先初始化，不然作用域只在try{}范围内。
BufferedWriter bufw = null;
BufferedReader bufr = null;
try
{
//创建字符流缓冲区并加载字符流文件
bufr = new BufferedReader(new FileReader("helloworld.java"));
bufw = new BufferedWriter(new FileWriter("hello_copy.txt"));

String line = null;

//写入信息
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch(IOException e)
{
throw new RuntimeException("读写失败！");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch(IOException e)
{
throw new RuntimeException("读取关闭失败！");
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch(IOException e)
{
throw new RuntimeException("写入关闭失败！");
}
}
}
}
}

LineNumberReader：跟踪行号的缓冲字符输入流。LineNumberReader是BufferedReader的子类。

此类定义了方法setLineNumber(int)和getLineNumber(),它们可分别用于设置和获取当前行号。

import java.io.*;
class LineNumberReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("helloworld.java");

//读取标的文件
LineNumberReader lnr = new LineNumberReader(fr);

String line = null;

//设置行号起点
lnr.setLineNumber(100);

//获取行号
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);
}

lnr.close();
}
}

PS:

1 缓冲区要结合流才可以使用。

2 无论是读一行还是多个字符，最终在硬盘上仍是一个一个读取。

3 read()和readLine()区别：

read()：读取字符数据，它覆盖了父类的read方法。

readLine()：另外开辟一个缓冲区，存储的是原缓冲区一行的数据，不包含换行符。

4、装饰设计模式

装饰设计模式：对原有类进行功能的改变、增强。装饰类和被装饰类通常都属于一个体系中。

装饰和继承比较：

//装饰设计模式
class Person
{
public void chifan()
{
System.out.println("吃饭");
}
}
//继承方法-->覆盖
class NewPerson extends Person
{
public void chifan()
{
System.out.println("漱口");
super.chifan();
System.out.println("甜点");
}
}
//装饰类-->补充
class SuperPerson
{
private Person p;
SuperPerson(Person p)
{
this.p = p;
}
public void superChifan()
{
//基于原来方法并给予丰富
System.out.println("漱口");
p.chifan();
System.out.println("甜点");
}
}
class DecorateDemo
{
public static void main(String[] args)
{
Person p = new Person();

NewPerson np = new NewPerson();
np.chifan();
System.out.println("-------------------");
SuperPerson sp = new SuperPerson(p);
sp.superChifan();
}
}

继承的体系：

Reader 专门用于读取数据的类。

|--TextReader:用于读取文本

|--MediaReader:用于读取媒体

功能扩展：提高读取效率，加入缓冲技术

Reader

|--TextReader

|--BufferTextReader

|--MediaReader

|--BufferMediaReader

加入再进行功能扩展，就会发现这个体系会越来越臃肿，不够灵活。

装饰体系思路：

既然加入的都是同一种技术--缓冲。继承是让缓冲和自己的流对象相结合。根据劳动分工，提高效率的特点。

我们可以将缓冲（同一属性的扩展功能）进行单独封装，各司其职，当需要时再针对性调用。

1、将缓冲进行单独封装

class Buffer

{

Buffer(TextReader text){}

Buffer(MediaReader media){}

}

2、优化。用多态封装，提高扩展性。

class BufferReader extends Reader

{

private Reader r;

BufferReader(Reader r){}

}

3、装饰体系

Reader 专门用于读取数据的类。

|--TextReader

|--MediaReader

|--BufferReader

由上面可知装饰和继承的异同：

相同点：都是用于功能的扩展。

不同点：

a 装饰扩展性更强；b 装饰避免了继承臃肿的体系；c 装饰降低了类之间的关联性。

d 装饰是对原有类的补充，继承是覆盖或者说是替代。

三、字节流

1、简述

a 字节流：基本操作和字符流类相同。但它不仅可以操作字符，还可以操作其他媒体文件。

b 由于媒体文件数据都是以字节存储的，所以字节流对象可直接将媒体文件的数据写入到文件中，不用进行刷新动作。

c 字节流基类：InputStream（读）、OutputStream（写）

//读取字节流方式
import java.io.*;
class FileStream
{
public static void main(String[] args)throws IOException
{
writerFile();
readFile_1();
readFile_2();
readFile_3();
}
//方法一：单个字节获取
public static void readFile_1()throws IOException
{
//读取指定文件字节流
FileInputStream fis = new FileInputStream("fos.txt");

int ch = 0;

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

fis.close();
}
//方法二：固定数组容量获取。建议用这种方式。
public static void readFile_2()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");

byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1)//循环是为了获取数据的大小
{
System.out.println(new String(buf,0,len));
}
fis.close();
}
//方法三：以恰好容量数组读取。可能因为获取的数据太大造成内存溢出。
public static void readFile_3()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");

//int num = fis.available();

//定义一个恰好的缓冲区，不用循环操作。
byte[] buf = new byte[fis.available()];

fis.read(buf);

//System.out.println("num="+num);
System.out.println(new String(buf));

fis.close();
}
public static void writerFile()throws IOException
{
//输出字节流到指定文件
FileOutputStream fos = new FileOutputStream("fos.txt");

//不涉及任何转换，所以不用刷新。
fos.write("abcde".getBytes());

fos.close();
}
}

PS:

1 FileOutputStream、FileInputStream的flush方法内容为空，没有任何实现，调用没有意义。

2 int available()：获取对象的数据大小。它是InputStream的特有方法。因为字节流可以操作媒体文件，所以直接获取数据大小，

可能因为获取的数据太大造成内存溢出。虚拟机默认内存是64M。

2、字节流的缓冲区：提高字节流读写效率。

2.1 读写存在类型提升和强转现象

read():会将字节byte类型提升为int类型。原因：防止直接返回byte类型值，造成read误判为程序结束标记的情形。

write():会将int类型强转为byte类型。原因：有始有终，保障数据唯一性。

/*
自定义字节流的缓冲区：
1，定义数组
2，定义指针
3，定义计数器。
*/
import java.io.*;
//装饰类
class MyBufferedInputStream
{
private InputStream in;

private byte[] buf = new byte[1024];

private int pos = 0, count = 0;

MyBufferedInputStream(InputStream in)
{
this.in = in;
}

//返回数据类型是int类型不是byte类型，这样避免了值为-1，正常情形下程序的停止。
public int myRead() throws IOException
{
//每句第一次读取数据的情形。通过in对象读取硬盘上数据，并存储在buf中。并计数。
if(count==0)
{
count = in.read(buf);
if(count<0)
return -1;
pos = 0;

//数组以byte类型存储。
byte b = buf[pos];

count--;
pos++;
//b&255，此时的b已经是int类型，它&255会只获取一个8位，补充位补0，防止-1的出现。
return b&255;
}
//每句话第二次读取数据的情形
else if(count>0)
{
byte b = buf[pos];

count--;
pos++;
//0xff=255
return b&0xff;
}

return -1;
}
public void myClose() throws IOException
{
in.close();
}
}

PS:

它们的转变原理是：

因为数据的字节流形式是二进制：0，1；

该文件中，因为字节流中会存在一个字节全是1的情形：1111-1111

定理：负数的二进制等于整数二进制取反+1。

0000-0001 1的二进制

1111-1110 取反

0000-0001 +1

1111-1111 -1的二进制

因为返回指针值是byte类型，但是类的返回值是int类型，所以返回值存在类型提升问题。

这样定义其实是为了解决直接返回值为-1，造成read方法误判断为程序结束标记的情形。即：while((ch=fis.read())!=-1)

byte:-1 ----> int: -1;

00000000 00000000 00000000 11111111类型提升时，若补位为0，则值为 255

11111111 11111111 11111111 11111111 类型提升时，若补位为1，则值为 -1

当byte:-1提升到int类型，若补位为1，其值仍为-1。read方法以读到-1为停止标记，造成程序停

止，无法满足需求。

所以我们要在前面补0，这样就可以避免-1的出现。

补0方式：&255

11111111 11111111 11111111 11111111

& 00000000 00000000 00000000 11111111

------------------------------------------------------------

00000000 00000000 00000000 11111111

同时这也意味着，我们读取完后有4个字节需要写入，这样其实改变了原数据，

所以write实际执行时，会执行一个强转动作，只执行最后一个有效字节。

四、流操作规律

1、键盘录入

1.1 标准输入输出流

System.in:对应的标准输入设备：键盘。 它是InputStream类型。

System.out:对应的标准的输出设备，控制台。它是PrintStream类型。

1.2整行录入

当使用输入流进行键盘录入时，只能单字节录入。为了提高效率，可以自定义一个数组将一行字节进行储存。当一行录入完毕，

再放回本行录入内容。这种方式正是字符流的readLine方法的原理。

那我们为什么不直接使用readLine方法呢？但由于readLine方法是字符流BufferedReader类中方法。而键盘录入的read方法是字节流

InputStream的方法。这时我们必须将字节流转换成字符流再使用readLine方法。这样我们就用到了转换流。

1.3 转换流：InputStreamReader、OutputStreamWriter

作用：当字节流中数据都是字符时，将字节流转换成字符流。

1.3.1 InputStreamReader:将字节流转成字符流步骤：

a 获取键盘录入对象

InputStream in = System.in;

b 将字节流对象转成字符流对象，使用转换流。

InputStreamReader isr = new InputStreamReader(in);

c 为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

BufferedReader br = new BufferedReader(isr);

以上步骤可简化为：最常用方式

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

1.3.2 OutputStreamWriter：将字符流转成字节流。

以字符形式录入，以字节形式存储到硬盘。步骤和InputStreamReader相似。

//转换流演示
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象
//InputStream in = System.in;

//将字节流对象转成字符流对象，使用转换流--> InputStreamReader
//InputStreamReader isr = new InputStreamReader(in);

//加入缓冲区
//BufferedReader bufr = new BufferedReader(isr);

//键盘的最常见写法。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

//字符流转字节流。
//OutputStream out = System.out;
//OutputStreamWriter osw = new OutputStreamWriter(out);
//BufferedWriter bufw = new BufferedWriter(osw);
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();
}
}

2、流操作的基本规律：

2.1

源：键盘录入。

目的：控制台。

2.2 需求：想把键盘录入的数据存储到一个文件中。

源：键盘。

目的：文件。

文件是字符形式。使用InputStreamReader。

2.3 需求：想要将一个文件的数据打印在控制台上。

源:文件。

目的：控制台。

控制台获取的是字节形式。使用OutputStreamWriter。

2.4 如何选择流对象？

通过三个明确，确定流对象的使用：

a 源和目的。

源：读取流。InputStream Reader

目的：输出流。OutputStream Writer

b 明确体系:操作的数据是否是纯文本。

是：字符流

否：字节流

c 明确要使用的具体对象。通过设备来进行区分：

源设备：内存，硬盘，键盘。

目的设备：内存，硬盘，控制台。

2.5 事例分析：

2.5.1 需求：将一个文件中数据存储到另一个文件中。复制文件

1）源：读取流。InputStream Reader

明确体系:数据类型：纯文本：Reader

明确对象:硬盘上的一个文件。Reader体系中可以操作文件的对象是：FileReader。

FileReader fr = new FileReader("a.txt");

提高效率

BufferedReader bufr = new BufferedReader(fr);

2）目的：输出流：OutputStream Writer

明确体系:数据类型：纯文本：Writer

明确对象:硬盘上的一个文件。Writer体系中可以操作文件的对象FileWriter。

FileWriter fw = new FileWriter("b.txt");

提高效率

BufferedWriter bufw = new BufferedWriter(fw);

2.5.2 需求：将键盘录入的数据保存到一个文件中。

1）源：InputStream Reader

明确体系：数据类型：纯文本：Reader。

明确对象：键盘。对应的是System.in。

但Reader是字符流，System.in是字节流。为了操作键盘的文本数据，所以字符流最方便。

所以既然明确了Reader，那么就将System.in转换成Reader。用Reader体系中的转换流：InputStreamReader

InputStreamReader isr = new InputStreamReader(System.in);

提高效率

BufferedReader bufr = new BufferedReader(isr);

2）目的：OutputStream Writer

明确体系：数据类型：纯文本：Writer。

明确对象:硬盘上的一个文件：FileWriter。

FileWriter fw = new FileWriter("c.txt");

提高效率

BufferedWriter bufr = new BufferedWriter(fw);

扩展：想要把录入的数据按照指定的编码表（utf-8）存到文件中。

2）目的：OutputStream Writer

明确体系：数据类型：纯文本：Writer。

明确对象:硬盘上的一个文件：FileWriter。

但是FileWriter是使用的默认编码表：GBK。但存储时，需要加入指定编码表utf-8。

而指定的编码表只有转换流可以指定。所以要使用的对象是OutputStreamWriter。

而该转换流对象要接受一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream。

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

提高效率

BufferedWriter bufw = new BufferedWriter(osw);

/*
练习：将键盘录入的数据按照utf-8编码表存入文件中。
思路：
1）源：InputStream Reader
明确体系：数据类型：纯文本：Reader。
明确对象：键盘：System.in。因为是文本数据，Reader最好操作，
所以需要借助Reader体系中的转换流：InputStreamWriter。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
2）目的：OutputStream Writer
明确体系：数据类型：纯文本：Writer
明确对象：硬盘上的文件：FileWriter。但是FileWriter是使用的默认编码表：GBK。因为存储时需要加入
指定编码表utf-8。而指定的编码表只有转换流可以指定。所以要使用的对象是OutputStreamWriter。
而该转换流对象要接受一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream。
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(),"UTF-8"));
*/
import java.io.*;
class TransStreamDemo1
{
public static void main(String[] args) throws IOException
{
//键盘录入的最常见写法：
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw =
new BufferedWriter(new OutputStreamWriter(new FileOutputStream("lady.txt"),"UTF-8"));

String line = null;

while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}

运行结果：



PS:

1 转换流什么时候使用？

通常在涉及到字符编码转换时使用。它是字符和字节之间的桥梁。

2 异常日志信息

当程序在执行出现不希望直接给用户看的问题时，我们需要以异常日志的形式储存信息，方便程序员查看、调整。

//异常的日志信息独立反映。
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfoDemo
{
public static void main(String[] args)throws IOException
{
try
{
int[] arr = new int[2];
System.out.println(arr[3]);
}
catch(Exception e)
{
try
{
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//H:24小时制
String s = sdf.format(d);

PrintStream ps = new PrintStream("exeception.log");
ps.println(s);
System.setOut(ps);
}
catch(IOException ex)
{
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}
}

3 系统属性信息文本

Properties getProperties():获取系统信息。

void list(PrintStream out):将信息输出到指定输出流中。

new PrintStream("sysinfo.txt"):将输出流中数据存入指定文件中。

// getProperties():确定当前的系统属性。
import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args)throws IOException
{
Properties prop = System.getProperties();

prop.list(new PrintStream("sysinfo.txt"));
}
}

4 通过System类的setIn、setOut方法可以对默认设备进行改变。

System.setIn(new FileInputStream("1.txt"))：将源改成文件1.txt。

System.setOut(new FileOutputStream("2.txt"))：将目的改成文件2.txt。

5 体系图

字节流继承体系图：



字符流继承体系图：