Java基础-19-IO流

最新推荐文章于 2022-09-08 14:55:41 发布

faith_yee

最新推荐文章于 2022-09-08 14:55:41 发布

阅读量403

点赞数

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

本文链接：https://blog.csdn.net/faith_yee/article/details/44754445

版权

Java入门专栏收录该内容

30 篇文章 0 订阅

订阅专栏

Java基础-IO流

IO流进阶

1、IO流（BufferedWriter）

字符流的缓冲区。

*缓冲区的出现提高了对数据的读写效率。
*对应类：BufferedWriter、BufferedReader
*缓冲区要结合流才可以使用。
*在流的基础上对流的功能进行了增强。

该平台（缓冲区中提供了一个跨平台的换行符：newline();）缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须要现有流对象。

测试代码：

import java.io.*;
class BufferedWriterDemo
{
    public static void main(String []   args)throws IOException
    {
        //创建一个字符写入流对象。
        FileWriter fw = new FileWriter("d:\\JAVADEMO\\day15.buf.txt");

        //为了提高字符写入流效率，加入了缓冲技术。
        //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
        BufferedWriter bufw = new BufferedWriter(fw);
        for(int x = 1 ; x<5;x++)
        {
            bufw.write("abcad"+x);
            bufw.newLine();
            bufw.flush();
        }
        //记住，只要用到缓冲区，就要记得刷新。
        //bufw.flush();
        //其实关闭缓冲区，就是在关闭缓冲区中的流对象。
        bufw.close();
        //fw.close();
    }
}

输出：

2、IO流（BufferedReader）

java.io.Reader :BufferedReader类该缓冲区提供了一个一次读一行的方法readLine()，方便于对文本数据的获取，当返回null时，表示读到本行末尾。字符读取流缓冲区：

测试代码：

import java.io.*;
class BufferedReaderDemo
{
    public static void main(String [] args)throws IOException
    {
        //创建一个读取流对象和文件相关联
        FileReader fr = new FileReader("d:\\JAVADEMO\\day15.buf.txt");

        //为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数。
        BufferedReader bufr = new BufferedReader(fr);

        String line = null ; 
        while((line = bufr.readLine())!=null)
        {
            System.out.println(line);
        }
        bufr.close();
    }
}

输出结果：

3、IO流（通过缓冲区复制文本文件）

通过缓冲区复制一个.java文件 readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。

测试代码：

import java.io.*;
class CopyTestByBuf
{
    public static void main(String [] args)
    {
        BufferedReader bufr = null;
        BufferedWriter bufw = null;
        try
        {
            bufr = new BufferedReader(new FileReader("C:\\myDoc.txt"));
            bufw = new BufferedWriter(new FileWriter("D:\\JAVADEMO\\day15\\buf.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("读取关闭失败");
            }
            try
            {
                if(bufw!=null)
                {
                    bufw.close();
                }
            }
            catch (IOException e)
            {
                throw new  RuntimeException("写入关闭失败");
            }
        }
    }
}

输出：

4、IO流（readLine的原理图示）

readLine方法的原理：无论是读一行，获取读取多个字符。其实最终都是在硬盘上一个一个读取，所以最终使用的还是read方法：一次读一个的方法。

5、IO流（MyBufferedReader-仿readLine功能）

明白了BufferedReader类中特有方法ReadLine原理后，可以定义一个类中包含一个功能和readLine一致的方法，来模拟一下BufferedReader。

测试代码：

import java.io.*;
class MyBufferedReaderDemo
{
    public static void main(String[]args)
    {
        FileReader fr = new FileReader("D:\\JAVADEMO\\day15\\buf.txt");
        MyBufferedReader mybuf = new MyBufferedReader(fr);
        String line = null;
        while ((line = mybuf.myReadLine())!=null)
        {
            System.out.println(line);
        }
        mybuf.myClose();
    }
}
class MyBufferedReader
{
    private FileReader r;
    MyBufferedReader(FileReader r)
    {
        this.r  = r;
    }
    //可以一次读一行数据的方法
    public String myReadLine()throws IOException
    {
        //定义一个临时容器，原BufferedReader封装的是
        //字符数组，为了演示方便，定义了一个StringBuilder
        //容器，因为最终还是要将数据变成字符串。
        StringBuilder sb =  new StringBuilder();
        int ch = 0;
        while((ch = r.read())!=-1)
        {
            if(ch == '\r')
                continue;
            if(ch == '\n')
                return sb.toString();
            else sb.append((char)ch);
        }
        if(sb.length()!=0)
        {
            return sb.toString();
        }
        return null;
    }
    public void myClose() throws IOException
    {
        r.close();
    }
}

6、IO流（装饰设计模式）

装饰设计模式：

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强，那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被修饰的对象，并基于被装饰的对象功能，提供更强的功能。

class Person 
{
    public void 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("甜点");
        System.out.println("来一根");
    }
}
class PersonDemo
{
    public static void main(String [] args)
    {
        Perosn p = new Person();
        //p.chifan();
        SuperPerson sp = new SuperPerson(p);
        sp.superChiFan();
    }
}

7、IO流（装饰和继承的区别）

MyReader//专门用于读取数据的类。
          |--MyTextReader
               |--MyBufferTextReader
          |--MyMediaReader
               |--MyBufferMediaReader
          |--MyDataReader
               |--MyBufferDataReader

Demo

class MyBufferReader
{
    MyBufferReader(MyTextReader text)
    {
    }
    MyBufferReader(MyMediaReader media)
    {
    }
}

上面这个类扩展性很差，找到其参数的共同类型。通过多态的形式，可以提高扩展性。

class MyBufferReader extends MyReader
{
    private MyReader r ;
    MyBufferReader(MyReader r)
    {
    }
}

MyReader

//专门用于读取数据的类
            |---MyTextReader
            |---MyDataReader
            |---MyMediaReader
            |---MyBuferReader

装饰模式比继承要灵活，避免了继承体系臃肿，而且降低了类与类之间的关系。装饰类因为增强了已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类和被装饰类通常是属于同一体系当中。

8、IO流（自定义装饰类）

Demo

import java.io.*;
class MyBufferedReaderDemo extends Reader
{
    public static void main(String[]args)
    {
        FileReader fr = new FileReader("D:\\JAVADEMO\\day15\\buf.txt");
        MyBufferedReader mybuf = new MyBufferedReader(fr);
        String line = null;
        while ((line = mybuf.myReadLine())!=null)
        {
            System.out.println(line);
        }
        mybuf.myClose();
    }
}
class MyBufferedReader extends Reader
{
    private FileReader r;
    MyBufferedReader(FileReader r)
    {
        this.r  = r;
    }
    //可以一次读一行数据的方法
    public String myReadLine()throws IOException
    {
        //定义一个临时容器，原BufferedReader封装的是
        //字符数组，为了演示方便，定义了一个StringBuilder
        //容器，因为最终还是要将数据变成字符串。
        StringBuilder sb =  new StringBuilder();
        int ch = 0;
        while((ch = r.read())!=-1)
        {
            if(ch == '\r')
                continue;
            if(ch == '\n')
                return sb.toString();
            else sb.append((char)ch);
        }
        if(sb.length()!=0)
        {
            return sb.toString();
        }
        return null;
    }
    public void myClose() throws IOException
    {
        r.close();
    }

    //覆盖Reader类中的抽象方法
    public int read(char [] cbuf , int off , int len )throws IOException
    {
        return r.read(cbuf,off,len);
    }
    public void close()throws IOException
    {
        r.close();
    }
}

9、IO流（LineNumberReader）

体系：

java.lang.Object
    |---java.io.Reader
           |--java.io.BufferedReader

在类BufferedReader中有一个直接继承的子类LineNumberReader类以下是该类中的方法：

int getLineNumber();//获取当前行号，即输出时带行号。
void setLineNumber(int lineNumber);//设置当前行号。即输出时从多少行开始。

测试代码：

import java.io.*;
class LineNumberReaderDemo
{
    public static void main(String [] args)throws IOException
    {
        FileReader fr = new FileReader("D:\\JAVADEMO\\day15\\myNewBufferReader.java");
        LineNumberReader lnr = new LineNumberReader (fr);
        String line = null;

        //输出的文本带行号，并从100数起
        lnr.setLineNumber(50);
        while((line = lnr.readLine())!=null)
        {
            System.out.println(lnr.getLineNumber()+":"+line);
        }
        lnr.close();
    }
}

输出结果：

10、IO流（MyLineNumberReader）

Demo

import java.io.*;
class MyBufferedReader
{
    private FileReader r;
    MyBufferedReader(FileReader r)
    {
        this.r  = r;
    }
    //可以一次读一行数据的方法
    public String myReadLine()throws IOException
    {
        //定义一个临时容器，原BufferedReader封装的是字符数组，为了演示方便，定义了一个StringBuilder容器，因为最终还是要将数据变成字符串。
        StringBuilder sb =  new StringBuilder();
        int ch = 0;
        while((ch = r.read())!=-1)
        {
            if(ch == '\r')
                continue;
            if(ch == '\n')
                return sb.toString();
            else sb.append((char)ch);
        }
        if(sb.length()!=0)
        {
            return sb.toString();
        }
        return null;
    }
    public void myClose() throws IOException
    {
        r.close();
    }
}
class MyLineNumberReader extends MyBufferedReader
{
    private int lineNumber;
    MyLineNumberReader(FileReader r )
    {
        super(r);
    }
    public String myReadLine() throws IOException
    {
        lineNumber++;
        return super.myReadLine();
    }
    public void setLineNumber(int lineNumber)
    {
        this.lineNumber = lineNumber;
    }
    public int getLineNumber()
    {
        return lineNumber;
    }
}
class MyLineNumberReaderDemo
{
    public static void main(String [] args)throws IOException
    {
        FileReader fr = new FileReader("D:\\JAVADEMO\\day15\\myNewBufferReader.java");
        MyLineNumberReader mylnr = new MyLineNumberReader(fr);
        String line = null;
        mylnr.setLineNumber(100);
        while((line = mylnr.myReadLine())!=null)
        {
            System.out.println(mylnr.getLineNumber()+":"+line);
        }
        mylnr.myClose();
    }
}

输出：

11、IO流（字节流File读写操作）

字符流（操作文本）：

FileReader、FileWriter、BufferedReader、BufferedWriter

字节流（操作图片等）：

InputStream、OutputStream

需求：如果想要操作图片数据，这时就要用到字节流

java.io.InputStream
  |---FileInputStream

int available();//返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。

java.io.OutputStream
  |--FileOutputStream

测试代码：

import java.io.*;
class FileStream
{
    public static void readFile_1()throws IOException
    {
        FileInputStream fis = new FileInputStream("D:\\JAVADEMO\\day15\\myNewBufferReader.java");
        int ch = 0;
        while((ch=fis.read())!=-1)
        {
            System.out.print((char)ch);
        }
        fis.close();
    }
    public static void readFile_2()throws IOException
    {
        FileInputStream fis = new FileInputStream("D:\\JAVADEMO\\day15\\myNewBufferReader.java");
        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("D:\\JAVADEMO\\day15\\myNewBufferReader.java");
        //int num = fis.available(); //返回文件里所存的字符数，该方法应用在下面的代码中。

        /*
        定义一个刚刚好的缓冲区，不用向readFile_2那样再循环了，可是该方法要慎用，因为
        如果new的是一部电影，数据容量太大，内存支撑不住，会奔溃的。
        */
        byte[]buf = new byte[fis.available()];
        fis.read(buf);
        System.out.println(new String (buf));
        fis.close();
    }
    public static void main(String [] args)throws IOException
    {   
        readFile_1();
        readFile_2();
        readFile_3();
    }
}

输出结果：

12、IO流（拷贝文件）

复制一个图片

思路：

（1）、用字节读取流对象和图片关联
（2）、用字节写入流对象创建一个图片文件，用于存储获取到的图片数据。
（3）、通过循环续写，完成数据的存储。
（4）、关闭资源

测试代码：

import java.io.*;
class CopyPic
{
    public static void main(String [] args)throws IOException
    {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try
        {
            fos = new FileOutputStream("c:\\2.bmp");
            fis = new FileInputStream("c:\\1.bmp");
            byte [] buf = new byte[1024];
            int len = 0;
            while((len = fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("复制文件失败");
        }
        finally
        {
            try
            {
                if(fis!=null)
                {
                    fis.close();
                }
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(fos!=null)
                {
                    fos.close();
                }
            }
            catch (IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}

输出结果:

13、IO流（字节流的缓冲区）

演示Mp3的复制，通过缓冲区

BufferedOutputStream BufferedInputStream

测试代码：

import java.io.*;
class CopyMp3
{
    public static void main(String [] args)throws IOException
    {
        long start = System.currentTimeMillis();
        copy_1();
        long end = System.currentTimeMillis();
        System.out.println((end-start)+"毫秒");
    }
    //通过字节流的缓冲区完成复制
    public static void copy_1()throws IOException
    {
        BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\1.mp3"));
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\2.mp3"));
        int by = 0;
        while((by = bufis.read())!=-1)
        {
            bufos.write(by);
        }
        bufos.close();
        bufis.close();
    }
}

输出结果：

14、IO流（自定义字节流的缓冲区read和write的特点）

自定义一个自己的字节流的缓冲区。

测试代码：

import java.io.*;
class CopyMp3
{
    public static void main(String [] args)throws IOException
    {
        long start = System.currentTimeMillis();
        copy_1();
        long end = System.currentTimeMillis();
        System.out.println((end-start)+"毫秒");
    }

    //通过字节流的缓冲区完成复制
    public static void copy_1()throws IOException
    {
        MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("c:\\1.mp3"));
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\2.mp3"));

        int by = 0;
        while((by = bufis.myRead())!=-1)
        {
            bufos.write(by);
        }
        bufos.close();
        bufis.myClose();
    }
}
class MyBufferedInputStream
{
    private InputStream in;
    private byte [] buf = new byte[1024*4];
    private int pos = 0,count = 0;

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

    //一次读一个字节，从缓冲区（字节数组）获取
    public int myRead()throws IOException
    {
        //通过in对象读取硬盘上的数据，并存储buf中，
        if(count == 0)
        {
            count = in.read(buf);
            if(count < 0)
            {
                return -1;
            }
            pos = 0;
            byte b = buf[pos];
            count --;
            pos++;
            return b&255;//如果是return b;将会出错，下面讲解为什么。
        }
        else if(count>0)
        {
            byte b = buf[pos];

            count --;
            pos++;
            return b&255;//如果是return b;将会出错，下面讲解为什么。
        }
        return -1;
    }
    public void myClose()throws IOException
    {
        in.close();
    }
}

输出：

接下来讲解代码中的语句return b&255;

通过测试,我们可以发现从myRead()传回到main()中的数据是-1（int），而由mian()当中接收到-1时就退出while循环，赋值结束，为什么呢？

因为在缓冲中存储的数据是byte[]，当返回到in对象时是int的，类型被提升了，即由（-1）byte转成了（-1）int，而实际是

00000000 00000000 00000000 11111111（-1（byte））强转成了
11111111   11111111   11111111   11111111（-1（int）），并返回，所以我们就在强转后的数中与上255，再返回，而BufferedOutputStream中的write方法会把int的信息强转回文件中，使文件保持原来的类型，不会失真。

为了保持数据不会失真，我们要把强转后的int类型数据与上255.即：
        11111111   11111111   11111111   11111111
&       00000000   00000000   00000000   11111111 （255）
---------------------------------------------------------------------------------------
        00000000   00000000   00000000   11111111

15、IO流（读取键盘录入）

读取键盘录入

System.out：对应的是标准输出装备，控制台。 System.in：对应的是标准输出设备，键盘。

需求：通过键盘录入数据，当录入一行数据后，就将该行数据进行打印，如果录入的数据是over，那么停止录入。

测试代码：

import java.io.*;
class ReadIn
{
    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 s = sb.toString();
                if("over".equals(s))
                {
                    break;
                }
                System.out.println(s.toUpperCase());
                sb.delete(0,sb.length());//清空缓冲。
            }
            else sb.append((char)ch);
        }
    }
}

输出结果：

16、IO流（读取转换流）

通过刚才的键盘录入一行数据并打印其大写，发现就是一行数据的原理，也就是readLine方法。能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？ readLine方法是字符流BufferedReader类中的方法，而键盘录入的read方法是字节流InputStream的方法。那么能不能将字节流转成字符流再使用字节流缓冲区的readLine方法呢？然后发现了一个类InputStreamReader(extends Reader)，它是字节流通向字符流的桥梁。

测试代码：

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

        //将字节流对像转成字符流对象，使用转换流:InputStreamReader
        InputStreamReader isr = new InputStreamReader(in);
        //为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader
        BufferedReader bufr = new BufferedReader (isr);
        String line  = null;
        while((line = bufr.readLine())!=null)
        {
            if("over".equals(line))
            {
                break;
            }
            System.out.println(line.toUpperCase());
        }
        bufr.close();
    }
}

输出结果:

17、IO流（写入转换流）

类OutputStreamWriter(extends Writer)是字符流通向字节流的桥梁

测试代码：

import java.io.*;
class TransStreamDemo_1
{
    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();
    }
}

输出结果：

18、IO流（流操作规律）

（1）、源：键盘录入

目的：控制台

（2）、需求：想把键盘录入的数据存储到一个文件中：源：键盘录入目的：文件

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

最痛苦的就是流对象很多，不知道用哪一个。

总结：流操作的基本规律：通过3个明确来完成

（1）、明确源和目的：

源：输入流：InputStream 、Reader
目的：输出流：OutputStream 、 Writer

（2）、操作的数据是否是纯文本

是：字符流
不是：字节流

（3）、当体系明确后，再明确要使用哪个具体的对象。

通过设备来区分：
源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台。

需求：

（1）、将一个文本文件中的数据存储到另一个文件中，复制文件。

源：因为是源，所以使用读取流，InputStream、Reader 是不是操作文本文件？是！这时就可以选择Reader 这样体系就明确了

接下来明确要使用该体系中的哪个对象明确设备：硬盘上一个文件。 Reader体系中可以操作文件的对象时FileReader

是否需要提高效率：是！加入Reader体系中的缓冲区BufferedReader

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

目的：OutputStream、Writer 是否是纯文本？是！writer 设备：硬盘上一个文件。 Writer体系可以操作文件的对象FileWriter 是否需要提高效率：是！加入Writer体系中的缓冲区BufferedWriter

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

19、IO流（流操作规律2）

需求：将键盘录入的数据保存到一个文件中。这个需求中有源和目的都存在那么分别分析源：InputStream、Reader 是不是纯文本？是！Reader 设备：键盘，对象的对象时System.in 不是选择Reader吗？System.in对应的不是字节流吗？为了操作键盘的文本数据方便，转成字符流按照字符串操作是最方便的。所以既然明确了Reader，那么就将System.in转换成Reader，用了Reader体系中转换流：InputStreamReader

InputStreamReader isr = new InputStreamReader(System.in);

需要提高效率吗？需要！BufferedReader BufferedReader bufr = new BufferedReader (isr);

目的：OutputStream 、Writer 是否是存文本？是！Writer 设备：硬盘。一个文件，使用FileWriter FileWriter fw = new FileWriter("c.txt");

需要提高效率吗？需要！ BufferedWriter bufw = new BufferedWriter(fw);

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

上面的目的改一下：目的：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); 所以，记住。转换流什么时候使用，字符和字节之间的桥梁，通常，涉及到字符编码转换时，需要用到转换流。

20、IO流（改变标准输入输出设备）

在之前的例子中前头加入 System.setIn(new FileInputStream("PersonDemo.java"));//表示不管下面源怎么设置，源头已经被指定好了，是PersonDemo.java文件。

System.setOut(new PrintStream("zzz.txt"));//输出被指定了

21、IO流（异常的日志信息）

Demo

import java.io.*;
import java.util.*;
import java.text.*;
import java.lang.*;
class ExceptionInfo
{
    public static void main(String []   args)throws IOException
    {
        try
        {
            int b=1,a=0;
            System.out.println(b/a);
        }
        catch (Exception e)
        {
            try
            {
                Date d = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");
                String s = sdf.format(d);

                PrintStream ps = new PrintStream("d:\\Exception.log");
                System.setOut(ps);
                ps.println(s);

            }
            catch (IOException ex)
            {
                throw new RuntimeException("日志文件创建失败");
            }
            e.printStackTrace(System.out);

        }       
    }

}

输出结果：

22、IO流（系统信息）

Demo

import java.util.*;
import java.io.*;
class SystemInfo
{
    public static void main(String [] args)throws IOException
    {
        Properties prop = System.getProperties();
        prop.list(new PrintStream("d:\\SystemInfo.txt"));
    }
}

输出结果：