IO流总结

最新推荐文章于 2024-01-06 21:46:05 发布

yuan_dailin

最新推荐文章于 2024-01-06 21:46:05 发布

阅读量428

点赞数

本文链接：https://blog.csdn.net/yuan_dailin/article/details/39827307

版权

一：IO流概念：

1、IO流：即InputOutput的缩写。

2、特点：

1）IO流用来处理设备间的数据传输。

2）Java对数据的操作是通过流的方式。

3）Java用于操作流的对象都在IO包中。

4）流按操作数据分为两种：字节流和字符流。

5）流按流向分为：输入流和输出流。

注意：流只能操作数据，而不能操作文件。

3、IO流的常用基类：

1）字节流的抽象基流：InputStream和OutputStream

2）字符流的抽象基流：Reader和Writer

二、IO流中重要概念

1、根据处理的数据不同；分为：字节流和字符流。

所有的数据都是以字节体现的；后期产生了字符流。因为字符数据涉及到了编码问题；所以在字符流对象中加入了编码机制。

字符流体系中：有两个基类。

Reader

Writer

2、字符流的缓冲区：是为了提高效率而存在。

BufferedWriter、BufferedReader缓冲区提供了比以前流对象功能更强的函数。

3、装饰设计模式

装饰设计模式是一种解决某一类问题的思想；该类问题的有效解决方案。解决给类提供增强型功能的问题。

示例：

class Person{
       void chi(){
              System.out.println("chifan");
       }
}
class NewPerson //装饰Person对象的类。称为装饰类，只为增强Person的功能而出现。
{
       private Person p;
       NewPerson(Person p){
              this.p = p;
       }
       void newChi(){
              System.out.println("来一杯");
              p.chi();
              System.out.println("甜点");
              System.out.println("来一根");
       }
}
class  PersonDemo{
       public static void main(String[] args) {
              Person p = new Person();
              p.chi();
//           NewPerson np = new NewPerson(p);
//           np.newChi();
       }
}

当对类的功能进行增强时，可称之为对该类的装饰。同时它的出现具备灵活性。

Writer

|--TextWriter

|--MediaWirter

该体系的出现已经可以完成对文本数据和媒体数据的写操作。

但是发现。效率较低。为了提高效率，就加入了缓冲技术。

|--文本写入需要缓冲

|--媒体写入需要缓冲

按照面向对象的思想，为了提高扩展，通过继承的方式完成。

Writer

|--TextWriter

|--BufferedTextWriter

|--MediaWirter

|--BufferedMedieWriter

这就完成了文本和媒体数据写操作效率提高。

当该体系加入一个子类 BaseWriter,而且该子类也许要效率提高。

Writer

|--TextWriter

|--BufferedTextWriter

|--MediaWirter

|--BufferedMedieWriter

|--BaseWriter

|--BufferedBaseWriter

如果体系扩展，都需要定义一个该子类具备高效缓冲功能的子类。

这样做体系扩展很麻烦；解决办法及优化如下：

我们发现，这些子类使用的缓冲技术都是一样的；缓冲区其实就是定义了临时存储容器将数据进行临时缓冲，

至于具体的写操作，还是Writer的子类对象完成的，比如 TextWriter. MediaWriter等。

所以：我们将缓冲技术单独封装成一个对象，要对哪个具体对象进行缓冲技术的使用，只要将该对象传递给缓冲区对象即可。

/对缓冲区对象进行单独描述。
classBufferedWriter extends Writer{
       BufferedWriter(Writer w){
       }
//    BufferedWriter(TextWriter tw)
//    {}
//    BufferedWriter(MediaWriter dw)
//    {}
}

当缓冲技术单独封装成了对象后，它具备的还是写功能，只不过可以其他对象的写功能进行高效。

所以它还是Writer类中的一员。

所以这时体系变成了

Writer

|--TextWriter

|--MediaWirter

|--BufferedWriter:这是一个提供增强功能的类。就把这种优化方式，定义成一种最终的解决该问题的解决方案并起个名字：装饰设计模式。

和原来的体系，变的很清爽。

Writer

|--TextWriter

|--BufferedTextWriter

|--MediaWirter

|--BufferedMedieWriter

装饰设计模式的出现可以对一组类进行功能的增强；而且装饰类本也是该体系中的一个子类。

代码体现：通常情况下，装饰类一般不单独存在，都是通过构造函数接收被装饰的对象，基于被装饰的对象的功能，并对外提供增强行的功能。

装饰设计模式和继承的区别：

继承会让体系变得臃肿，装饰更为灵活。

在IO中装饰设计模式用的很多。

比如：

BufferedWriter

BufferedReader

明确了BufferedReader是一个装饰类后，发现它有一个增强的功能，readLine。

而且readLine的原理是：调用基础流对象的read方法，一次读一个字符，并把该字符进行了临时存储。直到读到回车换行符为止，将存储的数据作为字符串返回。

定义一个装饰类实现一次读一行的功能如下代码：（供参考）

import java.io.*;
classMyBufferedReader //extends Reader//自定义装饰类，模拟BufferedReader{
       private Reader r;
       MyBufferedReader(Reader r){
              this.r = r;
       }
       //读一行的方法。
       public String myReadLine()throwsIOException{
              StringBuilder sb = new StringBuilder();
              int ch = 0;
              while((ch=r.read())!=-1){
                     if(ch=='\r')
                            continue;
                     if(ch=='\n')
                            returnsb.toString();
                     else
                            sb.append((char)ch);
              }
              if(sb.length()!=0)
                     return sb.toString();
              return null;
       }
       public void myClose()throws IOException{
              r.close();
       }
}

4、字节流

InputStream

OutputStream

通过一个字节流示例记住

class  FileOutputStreamDemo{
       public static void main(String[] args)throws IOException{
              FileOutputStream fos = newFileOutputStream("fos.txt");
              byte[] buf ="abcedf".getBytes();
              fos.write(buf);//字节流的写入方法，直接将数据写到了目的地。因为该对象中不存在缓冲区。
              fos.close();//关闭资源。
       }
}

5、字符流和字节流的关系：

字符流：

FileReader

FileWriter

BufferedReader

BufferedWriter

字节流：

FileInputStream

FileOutputStream

BufferedInputStream

BufferedOutoutStream

通过转换流将两个流进行关联起来的：

InputStreamReader:字节流通向字符流的桥梁

OutputStreamWriter:字符流通向字节流的桥梁

流的操作规律：因为io包中的对象很多，最重要的是要知道完成数据处理是，要使用哪个对象最合适。

如何判断要使用哪些对象呢？

通过几个明确来判断对象的使用：

1，明确数据源，和数据目的(数据汇)

数据源：InputStream Reader

数据目的：OutputStream Writer

2，明确数据的内容是否是纯文本。只要是纯文本数据，就使用字符流。

数据源：是： Reader。

数据目的：是：Writer

如果不是，就使用InputStream或者OutputStream

如果数据不能明确，只有使用字节流。

这样就可以将四个基类，进行确定，要使用哪一个。

3，明确具体设备。

数据源：键盘(System.in) ，内存(数组)，硬盘(File开头的流对象)。

数据目的：控制台(System.out)，内存(数组)，硬盘(File开头的流对象)。

4，明确是否需要提高效率？

是：使用带Buffer对象。

5，是否需要一些特殊场景的操作，来完成数据的特殊处理。

举例1:复制一个文本文件。

1，数据源：InputStream,Reader

数据目的：OutputStream ,Writer

2，是否是纯文本。

是。

数据源：Reader

数据目的:Writer

3，明确设备：

数据源：是一个文件，硬盘设备。 FileReader

数据目的：是一个文件。硬盘设备。 FileWriter.

代码就已经出来了。

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

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

4，需要高效吗？

需要。

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

BufferedReader bufr = new BufferedReader(fr);

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

BufferedWriter bufw = newBufferedWriter(fw);

举例2：将键盘录入的数据存储到一个文件中。

1,数据源：InputStrea,Reader

数据目的：OutputStream ,Writer

2,是否是纯文本？

是。

数据源：Reader

数据目的：Writer.

3,设备：

数据源：System.in;为了方便于操作数据源的字节数据，对其进行转换。使用转换流。

数据目的：硬盘文件。FileWriter.

发现一个问题，就是数据源是一个字节流。

因为纯文本使用字符流操作最方便，

所以，将数据源设备对应的字节流转成字符流。

InputStreamReader isr = newInputStreamReader(System.in);

FileWriter fw = newFileWriter("a.txt");

4，需要高效吗？需要。

BufferedReader bufr = newBufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw = newBufferedWriter(new FileWriter("a.txt"));

举例3：将一个文本文件打印到控制台

1,数据源：InputStrea,Reader

数据目的：OutputStream ,Writer

2,是否是纯文本？

是。

数据源：Reader

数据目的：Writer.

3,数据源:硬盘文件 FileReader

数据目的：控制台 System.out.因为目的是字节流，而操作的是字符流，所以要将字符流转成字节流到目的中。

使用到了转换流。 OutoutStreamWriter

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

PrintStream ps = System.out;

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

OutputStreamWriter osw = newOutputStreamWriter(System.out);

需要缓冲高效吗？需要。

BufferedReader bufr = newBufferedReader(new FileReader("a.txt"));

BufferedWriter bufw = newBufferedWriter(new OutputStreamWriter(System.out));

6、关于编码转换问题的应用举例：

举例1:复制一个文本文件。将一个GBK编码的文件，复制到另一个用UTF-8编码的文件中。

1,数据源：InputStream,Reader

数据目的：OutputStream ,Writer

2,是否是纯文本？

是。

数据源：Reader

数据目的：Writer.

3,设备：

数据源：硬盘文件

数据目的：硬盘文件。

涉及到编码数据。

源：是gbk FileReader

目的：因为是UTF-8,所以只能使用转换流。转换流中需要明确具体的字节流和编码。

编码是UTF-8,字节流就是对应硬盘设备的FileOutputStream。

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

OutputStreamWriter osw = new OutputStreamWriter(newFileOutputStream("b.txt"),"utf-8");

需要高效就加上buffer

Writer

|--OutputStreamWriter

|--FileWriter

Reader

|--InputStreamReader

|--FileReader

转换流其实就是将字节流和编码表相结合。将字节流中的字节数据，去查了具体的编码表。所以转换流才可以获取一个中文字符。

那么转换流的子类用于操作文件的对象FileReader 就直接使用父类的具有转换功能的read方法。就可以一次读一个字符。

FileReader fr =new FileReader("a.txt");//该对象中已经内置了本机默认的字符编码表，对于简体中文版的机器默认编码表是GBK.

//通过字节读取流读取a.txt中中文数据，按照GBK编码表的来获取中文字符。

InputStreamReaderisr = new InputStreamReader(newFileInputStream("a.txt"),"GBK");

InputStreamReader isr= new InputStreamReader(newFileInputStream("a.txt"),"GBK");

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

这两个句代码的功能是一样一样一样的。

区别：

第一句可以指定编码表。

第二句，固定本机默认编码表。

如果操作中文数据，仅使用本机默认码表，那么第二句书写简单。

如果操作中文数据，使用指定码表，必须使用第一句。而且要将指定码表作为字符串传递到构造函数中。

7、数据存放的形式最常见就是文件：

那么文件的属性较多，如文件名称，路径，大小等属性。

为了方便与操作java就将其视为对象；通过File类对其描述。

提供了多个属性和行为；便于我们的对文件的使用。

而流对象只能用于操作文件中的数据。

对于文件的属性，都通过File对象来完成。

File类是可以是文件对象，也可以是文件夹对象。

常见功能：

1）创建:

booleancreateNewFile();

boolean mkdir()

boolean mkdirs()

2）删除：

boolean delete():

void deleteOnExit()

void show(){

创建一个文件。

deleteOnExit();//告诉jvm，程序退出，一定要把该文件删除。

操作这个文件。

//删除这个文件。

}

3）判断。

boolean isFile();

booleanisDirectory();

booleanisAbsolute();

boolean exists();判断file对象封装的内容是否存在。

booleancanExecute():判断文件是否可以执行。

File f = newFile(path);

Runtime r =Runtime.getRuntime();

if(f.canExecute())

r.exec(path);

booleanisHidden():判文件是否是隐藏文件。

4）获取。

String getAbsolutePath();

String getPath();

String getParent();

String getName();

5）重命名。

boolean removeTo(File)

6）文件列表：

static File[] listRoots():获取有效盘符。

String[] list():获取的是当前目录下文件或者文件夹的名称。

File[] listFiles():获取的是当前目录下文件或者文件夹对应的对象。

如果仅获取文件名称，就用list方法。如果还要获取文件的其他信息，最好使用listFiles。因为它可以获取到文件对象。

这样就可以通过文件对象的方法，获取其他的内容。比如；文件大小，文件名称。修改时间等信息。

class  FileDemo{
       public static void main(String[] args)throws IOException{
//method_1();    
              method_9();
       }
       public static void method_9(){
              File dir = newFile("c:\\");
              String[] names = dir.list();//获取当前目录下的文件夹和文件的名称包含隐藏文件。如果File中封装的是一个文件，那么返回的数组为null。所以此处最好为了安全性做一个判断。
//           System.out.println(names);
              for(String name : names){
                     System.out.println(name);
              }
       }
       //获取文件列表
       public static void method_8(){
              File[] roots = File.listRoots();//获取到系统中可以用的盘符。
              for(File root : roots){
                     System.out.println(root);
              }
       }
       //重命名
       public static void method_7(){
              File f= new File("qq.txt");
              File f1 = newFile("c:\\ww.txt");
              f.renameTo(f1);//将f的文件名改成f1的文件名,可以进行文件的移动(剪切+重命名)。
       }
       public static void method_6(){
              File f = newFile("a.txt");
              long time = f.lastModified();
              Date d = new Date(time);
DateFormatdf=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
              String s = df.format(d);
              System.out.println("lastModified():"+s);
              System.out.println("exists:"+f.exists());
              System.out.println("length:"+f.length());//返回的是该文件的字节数。//该方法针对文件而言，文件夹没有大小。
              System.out.println("getName:"+f.getName());
              System.out.println("getParent:"+f.getParent());
              System.out.println("getAbsolutePath:"+f.getAbsolutePath());//获取的封装内容的绝对路径，也就是完整路径。
              System.out.println("getPath:"+f.getPath());//获取file内封装的路径内容。
       }
       //判断
       public static void method_5()throwsIOException{
              File f = newFile("xx.txt");
              f.mkdir();
              //f.createNewFile();
              System.out.println("exists:"+f.exists());
              //不需要想当然的认为xx.txt一定是文件。
              //想要判断file是封装的是文件还是目录，必须要确定该内容是存在的。才可以判断。
              System.out.println("isFile:"+f.isFile());
              System.out.println("isDirector:"+f.isDirectory());
              System.out.println("isAbsolute:"+f.isAbsolute());
       }
       //删除文件或者文件夹。
       public static void method_4(){
              File f = newFile("f.txt");
              boolean b1 = f.delete();//java中的删除不走回收站 。
              System.out.println("b1="+b1);
              File dir = newFile("abc");
              File dir1 = newFile("abc1");
              boolean b2 = dir.delete();
              boolean b3 = dir1.delete();//注意大家：删除目录时，如果目录中有内容，应该先将内部内容删除，在删该目录。                                        
              //windows删除就是从里往外删。
              System.out.println("b2="+b2);
              System.out.println("b3="+b3);
       }
       //创建文件夹。
       public static void method_3(){
              File f = newFile("abc\\mm\\nn\\xx\\aa\\qq\\ll\\pp");
//boolean b = f.mkdir();//只能创建单个目录。如果已存在不创建。
              boolean b = f.mkdirs();//可以创建多级目录。可以在已存在目录继续创建目录。
              System.out.println("b="+b);
       }
       //创建文件。
       public static void method_2()throwsIOException{
              File f = newFile("f.txt");
              boolean b = f.createNewFile();//如果f这个文件不存在，该方法会对其进行创建。如果f已经存在，该方法不会创建。而输出流创建文件，如果该文件存在，会覆盖。但是，如果输出流的构造函数传入参数为true。不覆盖文件 ,可以完成续写
              System.out.println("b="+b);
       }
       public static void method_1(){
              File ff = newFile("abc"+File.pathSeparator+"kkk");
              System.out.println(ff.toString());
              //将指定文件封装成File对象。
              File f = newFile("c:"+File.separator+"2.bmp");
              //System.out.println(f);
              File f5 = newFile("c:\\abc\\a.txt");
              File f1 = newFile("c:\\","a.txt");
              File dir = newFile("c:\\");
              File f2 = newFile(dir,"a.txt");
Filef3=newFile("c:"+File.separator+"abc"+File.separator+"kkk"+File.separator+"aa"+File.separator+"a.txt");
       }
}

8、递归作为一种编程手法。

当一个功能在被重复使用时，该功能的参数在随着功能变化。这时可以使用递归完成.

需要注意：

1，需要控制递归次数，不要过大。

2，递归必须要有条件。

否则，会出现栈内存溢出。

class DiGuiDemo {
       public static void main(String[] args) {
              toBin(6);
              int num = getSum(9000);
              System.out.println("num="+num);
       }
       public static int getSum(int num){
              if(num==1)
                     return 1;
              return num+getSum(num-1);
       }
       public static void toBin(int num){
              if(num>0){
                     toBin(num/2);
                     System.out.println(num%2);
              }
       }
}

9、IO中的其它流：

PrintStream:字节流中的打印流，可以直接操作设备的流对象。

构造函数的参数特点：

1，字符串路径。

2，File对象。

3，字节输出流。

PrintWriter:字符流中的打印流。

构造函数的参数特点：

1，字符串路径。

2，File对象，

3，字节输出流。

4，字符输出流。

打印流可以直接操作文件。算是较为常用流对象。

注意打印的特点在于提供了N多的print方法。

可以打印任意数据类型。

import java.io.*;
class  PrintWriterDemo{
       public static void main(String[] args)throws IOException{
              BufferedReader bufr = newBufferedReader(new InputStreamReader(System.in));
              PrintWriter pw = newPrintWriter(new FileWriter("pw.txt"),true);//目的是一个文件，还想要自动刷新。
              String line  = null;
              while((line=bufr.readLine())!=null){
                     if("over".equals(line))
                            break;
                     pw.println(line.toUpperCase());
                     //pw.flush();
              }
              pw.close();
              bufr.close();
       }
}

管道流：

读取流和写入流可以进行连接。

但是需要被多线程操作。

因为read方法是阻塞式方法。

容易引发死锁。

Map

|--Hashtable

|--Properties

Properties:该集合中存储的键和值都是字符串类型的数据，通常用配置文件的定义。

将硬盘上的数据进行集合的存储，希望在运算后，将改变后的结果，重新存回配置文件中。

其实load方法很简单，就是通过流对象，读取文本中一行数据。

在将该行数据通过=进行切割。左边作为键，右边作为值。

存入到Properties集合中。

使用集合的特有方法load，将流的特定规则信息存储到集合中，注意：流中的信息必须有规则是键值对。用=分隔

演示SequenceInputStream将多个读取流变成一个读取流；多个源对应一个目的。

可是实现数据的合并。

特点：

1)即可以读，又可以写。

2)内部封装了一个大的byte类型的数组，这就说明

该对象操作的数据是字节数据。

说名其中封装了字节的读取流和写入流。

而且可以使用内部的指针对这个数组进行数据的操作。

3)提供了getFilePointer方法获取指针的位置，

还提供了seek方法设置指针的位置。

4)通过该对象的构造函数可以得知，该对象只能操作文件。

也就说源和目的都是一个文件。

并通过构造函数的另一个参数来确定，访问方式。

该变量只能接收四个值。

r：只读，rw：读写。rws。rwd。

5)该对象中的方法可以操作基本数据类型。

6)注意被操作的文件数据，希望有规律。这样可以通过数据的整数倍来控制指针的偏移；对数据进行操作，达到，随机访问的效果。

可以应用于多线程对大数据的写入。同时写入，只要给每一个线程分配

起始索引位，就可以完成多线程随机写入；提高了写入效率。

使用的前提：

1，必须是文件。

2，数据有规律。比如等长数据。

classRandomAccessFileDemo {
       public static void main(String[] args)throws IOException{
              writeDemo3();
//           readDemo2();
       }
       //对已有数据进行修改。
       public static void writeDemo3()throwsIOException{
              RandomAccessFile raf = newRandomAccessFile("info.txt","rw");
              raf.seek(8*3);//从指针索引位8开始进行写入。
              raf.write("赵六".getBytes());
              raf.writeInt(72);
              raf.close();
       }
       既然能写，那么读也应该没有问题。
       通过指针的操作，完成读取的随机效果。
       public static void readDemo2()throwsIOException{
              RandomAccessFile raf = newRandomAccessFile("info.txt","r");
              raf.seek(8*1);
              byte[] buf = new byte[4];
              int len = raf.read(buf);
              String s= new String(buf,0,len);
              System.out.println("name="+s);
              int age = raf.readInt();//一次读四个字节并转成int数值。
              System.out.println("age="+age);
              raf.close();
       }
       //通过seek方法指定指针的位置，进行数据写入。
       发现RandomAccessFile操作的文件如果已经存在，不会再次创建，直接操作已有文件。
       发现通过seek的指针定位，就可以完成数据的随机写入；它可以完成已有数据的修改。
       public static void writeDemo2()throwsIOException{
              RandomAccessFile raf = newRandomAccessFile("info.txt","rw");
              raf.seek(8*2);//从指针索引位8开始进行写入。
//           raf.write("李四".getBytes());
//           raf.writeInt(67);
              raf.write("王武".getBytes());
              raf.writeInt(68);
              raf.close();
       }
       通过该对象写点数据；数据： 人员信息： 姓名，年龄
       public static void writeDemo()throwsIOException{
              RandomAccessFile raf = newRandomAccessFile("info.txt","rw");  
              raf.write("张三".getBytes());
              //raf.writeBytes("张三");//解析出了问题。
              //raf.writeChars("张三");//解析出了问题。
              //raf.write(65);//write:只将一个int整数的最低字节写出。
              raf.writeInt(65);
              raf.close();
       }
       public static void readDemo()throwsIOException{
              RandomAccessFile raf = newRandomAccessFile("info.txt","r");
              byte[] buf = new byte[4];
              int len = raf.read(buf);
              String s= new String(buf,0,len);
              System.out.println("name="+s);
              int age = raf.readInt();//一次读四个字节并转成int数值。
              System.out.println("age="+age);
              raf.close();
       }
}

对象的持久化存储。

也就是将对象中封装数据保存到持久化的设备上比如硬盘。

那么其他应用程序都需要建立该对象，直接读取设备上的对象即可

ObjectInputStream

ObjectOutputStream

专门用于操作对象的流；肯定封装了直接操作对象的方法。

注意：

对象中的静态数据是不会被持久化的。

那么非静态数据，也有不想被持久化的，怎么办？

只要将不需要被持久化的非静态数据进行transient关键字修饰即可

Serializable：

用于给类文件加一个UID。就是一个序列号。

该序列通过类中的成员的数字签名完成运算得来的。

当类中的成员发生大的改动时类会重新编译，生成带有新的UID的序列号。

这样就和曾存储的原来的类生成的对象的序列号不匹配。

这样就可以让使用者必须重新对新类产生的对象进行存储。

避免新类接收老对象出现安全隐患，这就是序列号的功能所在。

如果是类中没有成员大的改动，只是只是有个别的修改和已存储的对象没有太大影响。

就需要重新进行存储。希望可以用新的类接收读到的老对象。

这时可以在定义类时指定序列化，而不让jvm自动算该序列化。

classObjectStreamDemo {
       public static void main(String[] args)throws Exception{
//           writeObj();
              readObj();
       }
       //读取对象。
       public static void readObj()throws Exception{
              ObjectInputStream ois =
                     new ObjectInputStream(newFileInputStream("obj.txt"));
              Person p =(Person)ois.readObject();//ClassNotFoundException
              System.out.println(p.toString());
              ois.close();
       }
       //写入对象。
       public static void writeObj()throwsIOException{
       ObjectOutputStreamoos=newObjectOutputStream(newFileOutputStream("obj.txt"));
            oos.writeObject(newPerson("lisi",20));//如果一个对象要被写入，必须具备序列化功能，也就是说必须要实现Serializable接口
              oos.close();
       }
}

ByteArrayInputStream与ByteArrayOutputStream

操作数组流对象。它对应的设备就是内存。

ByteArrayOutputStream:内部封装了一个可变长度的字节数组。

关闭它是无效。因为该对象根本就没有调用过底层资源。

可以通过toByteArray()或者toString获取数组中的数据。

ByteArrayInputStream负责数据源：在初始化的时候，必须要有一个数据源内容。

因为操作的是数组，所以源就是一个字节数组。

注意：该对象中不会有异常发生，因为没有调用过底层资源。

直接操作byte[]不就的了吗？

干嘛还要使用流对象来完成呢？

因为数组的操作，无非就是数组中的元素进行设置和获取。

这个操作正好符合了读和写的操作。

使用流的操作思想在操作数组。

import java.io.*;
class  ByteStreamDemo{
       public static void main(String[] args) {
              ByteArrayInputStream bis = newByteArrayInputStream("abcde".getBytes());
              ByteArrayOutputStream bos = newByteArrayOutputStream();
              int ch = 0;
              while((ch=bis.read())!=-1){
                     bos.write(ch);
              }
              String s = bos.toString();
              System.out.println(s);
       }
}

字符流 = 字节流+编码表;能指定编码表的是转换流。

内部默认了编码表的是转换流的子类FileReader，FileWriter。默认的是本机码表。

OutputStreamWriter osw = new OutputStreamWriter(newFileOutputStream("gbk.txt"));

OutputStreamWriterosw1=newOutputStreamWriter(newFileOutputStream("gbk.txt"),"GBK");

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

以上三句都是一回事，都是在使用默认的GBK表，在操作gbk.txt文件。

将数据按照指定的编码表GBK将数据存储到目的中。