js333金沙线路真人平台

所以js333金沙线路真人平台在网上开业后发展也很稳定,js333金沙线路真人平台成为专业的体育形象招牌,js333金沙线路真人平台为互联网用户提供的在线交易和支付的整合服务,欢迎来到这里有多种线上娱乐游戏。

流是一连流串的字符,字符输入输出流

常常告诉我, 不能喜欢你;荆棘刺透脚心, 忘记没能, 锁在心底; 记忆将它记起, 呼唤屏住呼吸; 你,披散头发; 你,轻轻叹息。 因为爱上你, 后悔是自己; 雨雪埋没温柔。 独自千千彷徨, 落下血杜鹃的泪滴; 不只为她流, 也为你而流。

js333金沙线路真人平台 1标题图

根据功能分为节点流和包装流(处理流)

File 类的介绍:

流是一连流串的字符,是信息的通道,分输出流和输入流。

    节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.

Java IO 流的分类介绍:

IO的分类

    处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流的链接。

Java IO 字节输入输出流:

第一种分:输入流和输出流。第二种分:字节流和字符流。第三种分:节点流和处理流。

 

Java IO 字符输入输出流:

Java中流的分类:流的运动方向,可分为输入流和输出流两种。

1、前面讲的字符输入输出流,字节输入输出流都是字节流。那么什么是包装流呢?

 

流的数据类型,可以分为字节流和字符流。

  ①、包装流隐藏了底层节点流的差异,并对外提供了更方便的输入输出功能,让我们只关心这个高级流的操作

  我们在 Java IO 流的分类介绍  这篇博客中介绍知道:

输入流类都是抽象类InputStream或抽象类Reader类的子类。

  ②、使用包装流包装了节点流,程序直接操作包装流,而底层还是节点流和IO设备操作

  根据功能分为节点流和包装流(处理流)

输出流类都是抽象类OutputStream或抽象类Writer类的子类。

  ③、关闭包装流的时候,只需要关闭包装流即可

    节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.

输入流从文件输入为读取,输出流从文件输出为写入数据。

 

    处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流的链接。

字节输入流InputStrem和子节输出流OutputStream

 

 

InputStream:FileInputStream,ObjectInputStream,ByteArrayInputStream,StringBufferInputStream,BufferedInputStream,DataInputStream

 

1、前面讲的字符输入输出流,字节输入输出流都是字节流。那么什么是包装流呢?

OutputStream:FileOutputStream,ObjectOutputStream,ByteArrayOutputStream,BufferedOutputStream,DataOutputStream

2、缓冲流

  ①、包装流隐藏了底层节点流的差异,并对外提供了更方便的输入输出功能,让我们只关心这个高级流的操作

输入流输入流用于读取数据,用户可以从输入流中读取数据,但不能写入数据。

  js333金沙线路真人平台 2

  ②、使用包装流包装了节点流,程序直接操作包装流,而底层还是节点流和IO设备操作

输入流读取数据过程如下:打开一个流。如:FileInputStream inputFile=new FileInputStream;从信息源读取信息。如:inputFile.read();关闭流。如:inputFile.close();

  缓冲流:是一个包装流,目的是缓存作用,加快读取和写入数据的速度。

  ③、关闭包装流的时候,只需要关闭包装流即可

输出流输出流用于写入数据。只能写,不能读。

  字节缓冲流:BufferedInputStream、BufferedOutputStream

 

写数据到输出流过程如下:打开一个流。如:FileOutputStream outFile=new FileOutputStream;写入信息到目的地。如:outFile.write(inputFile.read:关闭流。如:outFile.close();

  字符缓冲流:BufferedReader、BufferedWriter

 

字符流ReaderWriter

案情回放:我们在将字符输入输出流、字节输入输出流的时候,读取操作,通常都会定义一个字节或字符数组,将读取/写入的数据先存放到这个数组里面,然后在取数组里面的数据。这比我们一个一个的读取/写入数据要快很多,而这也就是缓冲流的由来。只不过缓冲流里面定义了一个 数组用来存储我们读取/写入的数据,当内部定义的数组满了(注意:我们操作的时候外部还是会定义一个小的数组,小数组放入到内部数组中),就会进行下一步操作。 

 

字节字符转换流:InputStreamReader``OutputStreamWriter

      js333金沙线路真人平台 3

2、缓冲流

加入缓冲流可以加快输入和输出的速度。

下面是没有用缓冲流的操作:   

  js333金沙线路真人平台 4

FileInputStream fis = new FileInputStream("from.txt");InputStreamReader isr = new InputStreamReader;// 可以加快输入和输出的速度BufferedReader br = new BufferedReader;

FileInputStream fis = new FileInputStream("from.txt");InputStreamReader isr = new InputStreamReader;// 可以加快输入和输出的速度BufferedReader br = new BufferedReader;FileOutputStream fos = new FileOutputStream("from.txt");OutputStreamWriter osw = new OutputStreamWriter;// 可以加快输入和输出的速度BufferedWriter bw = new BufferedWriter;

import java.io.*;class Test{ public static void main(String[] args){ // 声明输入流 FileInputStream fis = null; // 声明输出流 FileOutputStream fos = nulll; try{ // 生成输入流对象 fis = new FileInputStream("e:/from.txt"); // 生成输出流的对象 fos = new FileOutputStream("e:/to.txt"); // 生成字节数组 byte[] buffer = new byte[1024]; while{ // 调用输入流对象的read方法 int temp = fis.read(buffer,0,buffer.length); if(temp == -1){ break; } fos.write(buffer,0,temp); } }catch(Exception e){ System.out.println; }finally{ try{ fis.close(); fos.close(); }catch(Exception e){ System.out.println; } }}}

?

  缓冲流:是一个包装流,目的是缓存作用,加快读取和写入数据的速度。

字节输入流和字节输出流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//1、创建目标对象,输入流表示那个文件的数据保存到程序中。不写盘符,默认该文件是在该项目的根目录下
            //a.txt 保存的文件内容为:AAaBCDEF
        File target = new File("io"+File.separator+"a.txt");
        //2、创建输入流对象
        InputStream in = new FileInputStream(target);
        //3、具体的 IO 操作(读取 a.txt 文件中的数据到程序中)
            /**
             * 注意:读取文件中的数据,读到最后没有数据时,返回-1
             *  int read():读取一个字节,返回读取的字节
             *  int read(byte[] b):读取多个字节,并保存到数组 b 中,从数组 b 的索引为 0 的位置开始存储,返回读取了几个字节
             *  int read(byte[] b,int off,int len):读取多个字节,并存储到数组 b 中,从数组b 的索引为 0 的位置开始,长度为len个字节
             */
        //int read():读取一个字节,返回读取的字节
        int data1 = in.read();//获取 a.txt 文件中的数据的第一个字节
        System.out.println((char)data1); //A
        //int read(byte[] b):读取多个字节保存到数组b 中
        byte[] buffer  = new byte[10];//这里我们定义了一个 长度为 10 的字节数组,用来存储读取的数据
        in.read(buffer);//获取 a.txt 文件中的前10 个字节,并存储到 buffer 数组中
        System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 67, 68, 69, 70, 0, 0, 0]
        System.out.println(new String(buffer)); //AaBCDEF[][][]
         
        //int read(byte[] b,int off,int len):读取多个字节,并存储到数组 b 中,从索引 off 开始到 len
        in.read(buffer, 0, 3);
        System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 0, 0, 0, 0, 0, 0, 0]
        System.out.println(new String(buffer)); //AaB[][][][][][][]
        //4、关闭流资源
        in.close();

  字节缓冲流:BufferedInputStream、BufferedOutputStream

Reader FileReaderWriter FileWriter

int read(char[] c, int off, int len)void write(char[] c, int off, int len)

import java.io.*;public class Demo{ public static void main(String args[]){ FileReader fr = null; // 字符输入流 FileWriter fw = null; try{ fr = new FileReader("e:/from.txt"); // 读取的文件路径 fw = new FileWriter("e:/to.txt"); char[] buffer = new char[100]; int temp = fr.read(buffer,0,buffer.length); fw.write(buffer,0,temp); // for(int i = 0; i<buffer.length; i++){ System.out.println(buffer[i]; } // }catch(Exception e){ System.out.println; }finally{ try{ fr.close(); fw.close(); }catch(Exception e){ System.out.println; } } }}

  我们查看 缓冲流的 JDK 底层源码,可以看到,程序中定义了这样的 缓存数组,大小为 8192

  字符缓冲流:BufferedReader、BufferedWriter

BufferedReader 处理流 字符流 输入流,字符输入处理流。

  BufferedInputStream:

案情回放:我们在将字符输入输出流、字节输入输出流的时候,读取操作,通常都会定义一个字节或字符数组,将读取/写入的数据先存放到这个数组里面,然后在取数组里面的数据。这比我们一个一个的读取/写入数据要快很多,而这也就是缓冲流的由来。只不过缓冲流里面定义了一个 数组用来存储我们读取/写入的数据,当内部定义的数组满了(注意:我们操作的时候外部还是会定义一个小的数组,小数组放入到内部数组中),就会进行下一步操作。 

方法readLine()

        js333金沙线路真人平台 5

      js333金沙线路真人平台 6

import java.io.*;class Test{ public static void main(String args[]){ FileReader fileReader = null; BufferedReader bufferedReader = null; tryl{ fileReader = new FileReader("e:/from.txt"); bufferedReader = new BufferedReader(fileReader); // readLine() 读取一行数据 String line = bufferedReader.readLine(); System.out.println; // String line = null; while{ line = bufferedReader.readLine(); if(line == null){ break; } System.out.println; } }catch(Exception e){ System.out.println; }finally{ try{ bufferedReader.close(); fileReader.close(); }catch(Exception e){ System.out.println; } }} 

 

下面是没有用缓冲流的操作:   

工厂模式

 

//1、创建目标对象,输入流表示那个文件的数据保存到程序中。不写盘符,默认该文件是在该项目的根目录下
            //a.txt 保存的文件内容为:AAaBCDEF
        File target = new File("io"+File.separator+"a.txt");
        //2、创建输入流对象
        InputStream in = new FileInputStream(target);
        //3、具体的 IO 操作(读取 a.txt 文件中的数据到程序中)
            /**
             * 注意:读取文件中的数据,读到最后没有数据时,返回-1
             *  int read():读取一个字节,返回读取的字节
             *  int read(byte[] b):读取多个字节,并保存到数组 b 中,从数组 b 的索引为 0 的位置开始存储,返回读取了几个字节
             *  int read(byte[] b,int off,int len):读取多个字节,并存储到数组 b 中,从数组b 的索引为 0 的位置开始,长度为len个字节
             */
        //int read():读取一个字节,返回读取的字节
        int data1 = in.read();//获取 a.txt 文件中的数据的第一个字节
        System.out.println((char)data1); //A
        //int read(byte[] b):读取多个字节保存到数组b 中
        byte[] buffer  = new byte[10];//这里我们定义了一个 长度为 10 的字节数组,用来存储读取的数据
        in.read(buffer);//获取 a.txt 文件中的前10 个字节,并存储到 buffer 数组中
        System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 67, 68, 69, 70, 0, 0, 0]
        System.out.println(new String(buffer)); //AaBCDEF[][][]

        //int read(byte[] b,int off,int len):读取多个字节,并存储到数组 b 中,从索引 off 开始到 len
        in.read(buffer, 0, 3);
        System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 0, 0, 0, 0, 0, 0, 0]
        System.out.println(new String(buffer)); //AaB[][][][][][][]
        //4、关闭流资源
        in.close();
interface Student{ public void doWork();}

class Demo1 implements Student{ public void doWork(){ System.out.println; }}

class Demo2 implements Student{ public void doWork(){ System.out.println; }}

class Dashu implements Student{ private Stuent student; public Dashu(Student student){ this.student = student; } public void doWork(){ System.out.println; student.doWork(); }}

class School{ public static void main(String[] args){ // Demo1 demo1 = new Demo1(); Dashu dashu = new Dashu; dashu.doWork(); }}

  BufferedOutputStream:

  我们查看 缓冲流的 JDK 底层源码,可以看到,程序中定义了这样的 缓存数组,大小为 8192

IO为输入输出的意思,从外面读取数据用InputStream,向外边写入数据用OutputStreamStream为流,在计算机中一切都是以二进制的字节构成的世界,InputStreamOutputStream来读取二进制,我们看起来会很麻烦,所以有了Reader/Writerjs333金沙线路真人平台,的接口,用来处理这些字符流。

      js333金沙线路真人平台 7

  BufferedInputStream:

FileReader fileReader = new FileReader("e:/from.txt");BufferedReader bufferedReader = new BufferedReader(fileReader);String line = bufferedReader.readLine();

try{FileReader fileReader = new FileReader("e:/from.txt");BufferedReader bufferedReader = new BufferedReader(fileReader);String line = null;while{ line = bufferedReader.readLine(); if(line == null){ break; } System.out.println;}}catch(Exception e){ System.out.println;}finally{ try{ bufferedReader.close(); fileReader.close();}catch(Exception e){ System.out.println;}

?

        js333金沙线路真人平台 8

增强API - NIO non-blocking IO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//字节缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("io"+File.separator+"a.txt"));
        //定义一个字节数组,用来存储数据
        byte[] buffer = new byte[1024];
        int len = -1;//定义一个整数,表示读取的字节数
        while((len=bis.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
        //关闭流资源
        bis.close();<br><br>
         
        //字节缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("io"+File.separator+"a.txt"));
        bos.write("ABCD".getBytes());
        bos.close();

 

Channel Buffer Selector 

 

 

nio新加的,对线程是非阻塞的作用。

?

  BufferedOutputStream:

往后余生,唯独有你简书作者:达叔小生90后帅气小伙,良好的开发习惯;独立思考的能力;主动并且善于沟通简书博客:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//字符缓冲输入流
        BufferedReader br = new BufferedReader(
                new FileReader("io"+File.separator+"a.txt"));
        char[] buffer = new char[10];
        int len = -1;
        while((len=br.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
        br.close();
         
        //字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(
                new FileWriter("io"+File.separator+"a.txt"));
        bw.write("ABCD");
        bw.close();

      js333金沙线路真人平台 9

  • 下面我将继续对 其他知识 深入讲解 ,有兴趣可以继续关注
  • 小礼物走一走 or 点赞

  

//字节缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("io"+File.separator+"a.txt"));
        //定义一个字节数组,用来存储数据
        byte[] buffer = new byte[1024];
        int len = -1;//定义一个整数,表示读取的字节数
        while((len=bis.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
        //关闭流资源
        bis.close();



        //字节缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("io"+File.separator+"a.txt"));
        bos.write("ABCD".getBytes());
        bos.close();

 

 

 

//字符缓冲输入流
        BufferedReader br = new BufferedReader(
                new FileReader("io"+File.separator+"a.txt"));
        char[] buffer = new char[10];
        int len = -1;
        while((len=br.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
        br.close();

        //字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(
                new FileWriter("io"+File.separator+"a.txt"));
        bw.write("ABCD");
        bw.close();

 3、转换流:把字节流转换为字符流

  

  InputStreamReader:把字节输入流转换为字符输入流

 

  OutputStreamWriter:把字节输出流转换为字符输出流

 

   js333金沙线路真人平台 10

 3、转换流:把字节流转换为字符流

 

  InputStreamReader:把字节输入流转换为字符输入流

 用转换流进行文件的复制:

  OutputStreamWriter:把字节输出流转换为字符输出流

?

   js333金沙线路真人平台 11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
         * 将 a.txt 文件 复制到 b.txt 中
         */
        //1、创建源和目标
        File srcFile = new File("io"+File.separator+"a.txt");
        File descFile = new File("io"+File.separator+"b.txt");
        //2、创建字节输入输出流对象
        InputStream in = new FileInputStream(srcFile);
        OutputStream out = new FileOutputStream(descFile);
        //3、创建转换输入输出对象
        Reader rd = new InputStreamReader(in);
        Writer wt = new OutputStreamWriter(out);
        //3、读取和写入操作
        char[] buffer = new char[10];//创建一个容量为 10 的字符数组,存储已经读取的数据
        int len = -1;//表示已经读取了多少个字符,如果是 -1,表示已经读取到文件的末尾
        while((len=rd.read(buffer))!=-1){
            wt.write(buffer, 0, len);
        }
        //4、关闭流资源
        rd.close();
        wt.close();

 

  

 用转换流进行文件的复制:

 

/**
         * 将 a.txt 文件 复制到 b.txt 中
         */
        //1、创建源和目标
        File srcFile = new File("io"+File.separator+"a.txt");
        File descFile = new File("io"+File.separator+"b.txt");
        //2、创建字节输入输出流对象
        InputStream in = new FileInputStream(srcFile);
        OutputStream out = new FileOutputStream(descFile);
        //3、创建转换输入输出对象
        Reader rd = new InputStreamReader(in);
        Writer wt = new OutputStreamWriter(out);
        //3、读取和写入操作
        char[] buffer = new char[10];//创建一个容量为 10 的字符数组,存储已经读取的数据
        int len = -1;//表示已经读取了多少个字符,如果是 -1,表示已经读取到文件的末尾
        while((len=rd.read(buffer))!=-1){
            wt.write(buffer, 0, len);
        }
        //4、关闭流资源
        rd.close();
        wt.close();

 4、内存流(数组流):

  

  把数据先临时存在数组中,也就是内存中。所以关闭 内存流是无效的,关闭后还是可以调用这个类的方法。底层源码的 close()是一个空方法

 

        js333金沙线路真人平台 12

 4、内存流(数组流):

 

  把数据先临时存在数组中,也就是内存中。所以关闭 内存流是无效的,关闭后还是可以调用这个类的方法。底层源码的 close()是一个空方法

  ①、字节内存流:ByteArrayOutputStream 、ByteArrayInputStream

        js333金沙线路真人平台 13

?

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//字节数组输出流:程序---》内存
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        //将数据写入到内存中
        bos.write("ABCD".getBytes());
        //创建一个新分配的字节数组。 其大小是此输出流的当前大小,缓冲区的有效内容已被复制到其中。
        byte[] temp = bos.toByteArray();
        System.out.println(new String(temp,0,temp.length));
         
        byte[] buffer = new byte[10];
        ///字节数组输入流:内存---》程序
        ByteArrayInputStream bis = new ByteArrayInputStream(temp);
        int len = -1;
        while((len=bis.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
         
        //这里不写也没事,因为源码中的 close()是一个空的方法体
        bos.close();
        bis.close();

  ①、字节内存流:ByteArrayOutputStream 、ByteArrayInputStream

  

//字节数组输出流:程序---》内存
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        //将数据写入到内存中
        bos.write("ABCD".getBytes());
        //创建一个新分配的字节数组。 其大小是此输出流的当前大小,缓冲区的有效内容已被复制到其中。 
        byte[] temp = bos.toByteArray();
        System.out.println(new String(temp,0,temp.length));

        byte[] buffer = new byte[10];
        ///字节数组输入流:内存---》程序
        ByteArrayInputStream bis = new ByteArrayInputStream(temp);
        int len = -1;
        while((len=bis.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }

        //这里不写也没事,因为源码中的 close()是一个空的方法体
        bos.close();
        bis.close();

  ②、字符内存流:CharArrayReader、CharArrayWriter

  

  

  ②、字符内存流:CharArrayReader、CharArrayWriter

?

  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//字符数组输出流
        CharArrayWriter caw = new CharArrayWriter();
        caw.write("ABCD");
        //返回内存数据的副本
        char[] temp = caw.toCharArray();
        System.out.println(new String(temp));
         
        //字符数组输入流
        CharArrayReader car = new CharArrayReader(temp);
        char[] buffer = new char[10];
        int len = -1;
        while((len=car.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
//字符数组输出流
        CharArrayWriter caw = new CharArrayWriter();
        caw.write("ABCD");
        //返回内存数据的副本
        char[] temp = caw.toCharArray();
        System.out.println(new String(temp));

        //字符数组输入流
        CharArrayReader car = new CharArrayReader(temp);
        char[] buffer = new char[10];
        int len = -1;
        while((len=car.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }

  

  

  ③、字符串流:StringReader,StringWriter(把数据临时存储到字符串中)

  ③、字符串流:StringReader,StringWriter(把数据临时存储到字符串中)

 

 

?

//字符串输出流,底层采用 StringBuffer 进行拼接
        StringWriter sw = new StringWriter();
        sw.write("ABCD");
        sw.write("帅锅");
        System.out.println(sw.toString());//ABCD帅锅

        //字符串输入流
        StringReader sr = new StringReader(sw.toString());
        char[] buffer = new char[10];
        int len = -1;
        while((len=sr.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));//ABCD帅锅
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
//字符串输出流,底层采用 StringBuffer 进行拼接
        StringWriter sw = new StringWriter();
        sw.write("ABCD");
        sw.write("帅锅");
        System.out.println(sw.toString());//ABCD帅锅
 
        //字符串输入流
        StringReader sr = new StringReader(sw.toString());
        char[] buffer = new char[10];
        int len = -1;
        while((len=sr.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));//ABCD帅锅
        }

  

  

 

 

 

 

5、合并流:把多个输入流合并为一个流,也叫顺序流,因为在读取的时候是先读第一个,读完了在读下面一个流。

5、合并流:把多个输入流合并为一个流,也叫顺序流,因为在读取的时候是先读第一个,读完了在读下面一个流。

 js333金沙线路真人平台 14

 js333金沙线路真人平台 15

//定义字节输入合并流
        SequenceInputStream seinput = new SequenceInputStream(
                new FileInputStream("io/a.txt"), new FileInputStream("io/b.txt"));
        byte[] buffer = new byte[10];
        int len = -1;
        while((len=seinput.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }

        seinput.close();

?

  

1
2
3
4
5
6
7
8
9
10
//定义字节输入合并流
        SequenceInputStream seinput = new SequenceInputStream(
                new FileInputStream("io/a.txt"), new FileInputStream("io/b.txt"));
        byte[] buffer = new byte[10];
        int len = -1;
        while((len=seinput.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
         
        seinput.close();

 

本文由js333金沙线路真人平台发布于古典文学,转载请注明出处:流是一连流串的字符,字符输入输出流