Java_IO流

编程入门行业动态更新时间:2024-10-23 01:34:01

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

同步与异步，阻塞与非阻塞的区别
BIO、NIO、AIO的区别和应用场景
- BIO
- NIO
- AIO
- BIO和NIO、AIO的区别
- IO与NIO区别
Java中流类的超类主要有那些？
IO 流
- IO 流概述：
- IO 流的分类：
- IO 流的使用场景
- 字节流
- - 输出流
  - 输入流
  - 复制
  - 字节缓冲流
- 编码
- 字符流
- - 字符输入流
  - 字符输出流
  - 字符缓冲流
什么是比特(Bit),什么是字节(Byte),什么是字符(Char),它们长度是多少,各有什么区别
什么叫对象序列化，什么是反序列化，实现对象序列化需要做哪些工作
- 对象序列化流： ObjectOutputStream
- 对象反序列化流：ObjectInputStream
打印流
- 字节打印流
- 字符打印流
标准流
- 标准输出流
- 标准输入流

同步与异步，阻塞与非阻塞的区别

同步，一个任务的完成之前不能做其他操作，必须等待（等于在打电话）
异步，一个任务的完成之前，可以进行其他操作（等于在聊QQ）
阻塞，是相对于CPU来说的，挂起当前线程，不能做其他操作只能等待
非阻塞,，无须挂起当前线程，可以去执行其他操作

BIO、NIO、AIO的区别和应用场景

BIO

Blocking I/O，同步阻塞I/O模型，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
应用场景：适用于连接数目比较小且固定的架构，这种方式对服务端资源要求比较高，并发局限于应用中，在JDK 1.4以前是唯一的I/O实现，但程序直观简单易理解。
通俗理解为数据的读取写入必修阻塞在一个线程内，直到其完成。
例子：A拿着一支鱼竿在河边钓鱼，并且一直在鱼竿前等，在等的时候不做其他的事情，十分专心。只有鱼上钩的时，才结束掉等的动作，把鱼钓上来。

NIO

New I/O，同步非阻塞I/O模型，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
应用场景：NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK 1.4开始支持。
是传统I/O的升级版，客户端和服务端通过Channel(通道）通讯，实现了多路复用。
NIO采用的是一种多路复用的机制，利用单线程轮询事件，高效定位就绪的Channel来决定做什么，只是Select阶段是阻塞式的，能有效避免大量连接数时，频繁线程的切换带来的性能或各种问题。
例子：B也在河边钓鱼，但是B不想将自己的所有时间都花费在钓鱼上，在等鱼上钩这个时间段中，B也在做其他的事情（一会看看书，一会读读报纸，一会又去看其他人的钓鱼等），但B在做这些事情的时候，每隔一个固定的时间检查鱼是否上钩。一旦检查到有鱼上钩，就停下手中的事情，把鱼钓上来。 B在检查鱼竿是否有鱼，是一个轮询的过程。

AIO

Asynchronous I/O，异步非阻塞I/O模型，服务器实现模式为一个有效请求一个线程，客户端的 I/O 请求都是由 OS 先完成了再通知服务器应用启动线程进行处理。应用场景：适用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK 7 开始支持。
例子：C也想钓鱼，但C有事情，于是他雇来了D、E、F，让他们帮他等待鱼上钩，一旦有鱼上钩，就打电话给C，C就会将鱼钓上去。

BIO和NIO、AIO的区别

BIO是阻塞的，NIO是非阻塞的.
BIO是面向流的，只能单向读写，NIO是面向缓冲的, 可以双向读写
使用BIO做Socket连接时，由于单向读写，当没有数据时，会挂起当前线程，阻塞等待，为防止影响其它连接,，需要为每个连接新建线程处理.，然而系统资源是有限的,，不能过多的新建线程，线程过多带来线程上下文的切换，从来带来更大的性能损耗，因此需要使用NIO进行BIO多路复用，使用一个线程来监听所有Socket连接，使用本线程或者其他线程处理连接
AIO是非阻塞以异步方式发起 I/O 操作。当 I/O 操作进行时可以去做其他操作，由操作系统内核空间提醒IO操作已完成

IO与NIO区别

IO面向流，NIO面向缓冲区；IO的各种流是阻塞I/O模型，NIO是非阻塞I/O模型。
NIO的选择允许一个单独的线程来监视多个输入通道，可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入或选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

Java中流类的超类主要有那些？

超类代表顶端的父类（都是抽象类）
java.io.InputStream
java.io.OutputStream
java.io.Reader
java.io.Writer

IO 流

IO 流概述：

IO：输入/输出(Input/Output)
流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
IO流就是用来处理设备间数据传输问题的。
常见的应用：文件复制；文件上传；文件下载

IO 流的分类：

按照数据的流向
- 输入流：读数据
- 输出流：写数据
按照数据类型来分
- 字节流：以字节为单位，每次次读入或读出是8位数据。可以读任何类型数据。
  Java代码接收数据只能为byte数组
  - 字节输入流
  - 字节输出流
- 字符流：以字符为单位，每次次读入或读出是16位数据
  - 字符输入流
  - 字符输出流

IO 流的使用场景

如果操作的是纯文本文件，优先使用字符流
如果操作的是图片、视频、音频等二进制文件。优先使用字节流
如果不确定文件类型，优先使用字节流。字节流是万能的流

字节流

输出流

package IO流.字节流;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
    FileOutputStream：文件输出流用于将数据写入File
        FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件
 */
public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("D:\\IntelliJ IDEA 2021.1.1\\workspace\\study\\src\\IO流\\FileOutputStream.txt");

        //FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件
        //File file = new File("D:\\IntelliJ IDEA 2021.1.1\\workspace\\study\\src\\IO流\\FileOutputStream2.txt");
        //FileOutputStream fos2 = new FileOutputStream(file);
        //FileOutputStream fos2 = new FileOutputStream(new File("D:\\IntelliJ IDEA 2021.1.1\\workspace\\study\\src\\IO流\\FileOutputStream3.txt"));

        /**
            做了三件事情：
                A:调用系统功能创建了文件
                B:创建了字节输出流对象
                C:让字节输出流对象指向创建好的文件
         */

        /**
            写数据的三种方式：
                void write(int b)：将指定的字节写入此文件输出流
                    一次写一个字节数据
                 void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流
                    一次写一个字节数组数据
                void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
                    一次写一个字节数组的部分数据
         */

        //void write(int b)：将指定的字节写入此文件输出流
        fos.write(97);//a

        //byte[] getBytes()：返回字符串对应的字节数组
        byte[] bys = "abcde".getBytes();
        //fos.write(bys);//abcde

        //void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
//        fos.write(bys,0,bys.length);
        fos.write(bys,1,3);//abcd

        /**
         *     字节流写数据的两个小问题:
         *         1:字节流写数据如何实现换行呢？
         *             window:\r\n
         *             linux:\n
         *             mac:\r
         *         2:字节流写数据如何实现追加写入呢？
         *             public FileOutputStream(String name,boolean append)
         *                 创建文件输出流以指定的名称写入文件。
         *                 如果第二个参数为true ，则字节将写入文件的末尾而不是开头
         */
        FileOutputStream fos2 = new FileOutputStream("D:\\IntelliJ IDEA 2021.1.1\\workspace\\study\\src\\IO流\\FileOutputStream.txt",true);
        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }


        //最后都要释放资源
        //void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();
    }
}

输入流

package IO流.字节流;

import java.io.FileInputStream;
import java.io.IOException;

/*
    需求：
        把文件fos.txt中的内容读取出来在控制台输出
    FileInputStream：从文件系统中的文件获取输入字节
        FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名
    使用字节输入流读数据的步骤：
        1:创建字节输入流对象
        2:调用字节输入流对象的读数据方法
        3:释放资源
 */
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("D:\\IntelliJ IDEA 2021.1.1\\workspace\\study\\src\\IO流\\FileOutputStream.txt");

        //调用字节输入流对象的读数据方法
        //int read()：从该输入流读取一个字节的数据

        /*
        int by = fis.read();
        System.out.println(by);
        System.out.println((char)by);
       //如果达到文件的末尾， -1
        */

        /*
        int by = fis.read();
        while (by != -1) {
            System.out.print((char)by);
            by = fis.read();
        }
        */

        //优化
        int by;
        /*
            fis.read()：读数据
            by=fis.read()：把读取到的数据赋值给by
            by != -1：判断读取到的数据是否是-1
         */
        while ((by=fis.read())!=-1) {
            System.out.print((char)by);
        }


        //释放资源
        fis.close();
    }
}

复制

package IO流.字节流;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * ①复制文本文件，其实就把文本文件的内容从一个文件中读取出来 ( 数据源 ) ，然后写入到另一个文件中 ( 目的地)
 * ②数据源：
 *         读数据 --- InputStream --- FileInputStream
 * ③目的地：
 *         写数据 --- OutputStream --- FileOutputStream
 */
/*
    需求：
        把IO流\\mn.jpg复制到模块目录下的mn.jpg
    思路：
        1:根据数据源创建字节输入流对象
        2:根据目的地创建字节输出流对象
        3:读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        4:释放资源
 */
public class CopyDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\IntelliJ IDEA 2021.1.1\\workspace\\study\\src\\IO流\\mn.jpg");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\IntelliJ IDEA 2021.1.1\\workspace\\study\\src\\IO流2\\mn.jpg");

        //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1) {
            fos.write(bys,0,len);
        }

        //释放资源
        fos.close();
        fis.close();
    }
}

字节缓冲流

package IO流.字节流;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * 字节缓冲流：
 * BufffferOutputStream：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写 入字节，而不必为写入的每个字节导致底层系统的调用
 * BufffferedInputStream：创建BufffferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过
 *
 * 为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
 *      字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作
 * 构造方法：
 * 		字节缓冲输出流：BufferedOutputStream(OutputStream out)
 *      字节缓冲输入流：BufferedInputStream(InputStream in)
 */

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
/*
//        FileOutputStream fos = new FileOutputStream("IO流\\bos.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
		  BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("IO流\\bos.txt"));         

        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());

        //释放资源
        bos.close();

      */

        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\\bos.txt"));

        //一次读取一个字节数据
//        int by;
//        while ((by=bis.read())!=-1) {
//            System.out.print((char)by);
//        }

        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //释放资源
        bis.close();
    }
}

编码

package IO流.字符流;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
    编码：
        byte[] getBytes()：使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
        byte[] getBytes(String charsetName)：使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
    解码：
        String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 String
        String(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String
 */
public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";

        //byte[] getBytes()：使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
        //byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]

        //byte[] getBytes(String charsetName)：使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
//        byte[] bys = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]

        byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

        //String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 String
//        String ss = new String(bys);

        //String(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String
//        String ss = new String(bys,"UTF-8");

        String ss = new String(bys,"GBK");
        System.out.println(ss);
    }
}

字符流

字符输入流

package IO流.字符流;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
    构造方法：
        InputStreamReader(InputStream in)：创建一个使用默认字符集的InputStreamReader
    读数据的2种方式：
        int read()：一次读一个字符数据
        int read(char[] cbuf)：一次读一个字符数组数据
 */
public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        //InputStreamReader(InputStream in)：创建一个使用默认字符集的InputStreamReader

//        InputStreamReader isr = new InputStreamReader(new FileInputStream("IO流\\osw.txt"));
        InputStreamReader isr = new InputStreamReader(new FileInputStream("IO流\\ConversionStreamDemo.java"));

        //int read()：一次读一个字符数据

//        int ch;
//        while ((ch=isr.read())!=-1) {
//            System.out.print((char)ch);
//        }

        //int read(char[] cbuf)：一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

        //释放资源
        isr.close();
    }
}

字符输出流

package IO流.字符流;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
    构造方法：
        OutputStreamWriter(OutputStream out)：创建一个使用默认字符编码的OutputStreamWriter
    写数据的5种方式：
        void write(int c)：写一个字符
        void write(char[] cbuf)：写入一个字符数组
        void write(char[] cbuf, int off, int len)：写入字符数组的一部分
        void write(String str)：写一个字符串
        void write(String str, int off, int len)：写一个字符串的一部分
 */
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter(OutputStream out)：创建一个使用默认字符编码的OutputStreamWriter
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("IO流\\osw.txt"));

        //void write(int c)：写一个字符
//        osw.write(97);

//        //void flush()：刷新流
//        osw.flush();

        //void write(char[] cbuf)：写入一个字符数组
        char[] chs = {'a', 'b', 'c', 'd', 'e'};
//        osw.write(chs);

        //void write(char[] cbuf, int off, int len)：写入字符数组的一部分
//        osw.write(chs, 0, chs.length);
//        osw.write(chs, 1, 3);

        //void write(String str)：写一个字符串
//        osw.write("abcde");

        //void write(String str, int off, int len)：写一个字符串的一部分
        osw.write("abcde", 0, "abcde".length());

        //释放资源
        osw.close();
        //Exception in thread "main" java.io.IOException: Stream closed
//        osw.write(100);
    }
}

字符缓冲流

package IO流.字符流;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
    字符缓冲流的特有功能
        BufferedWriter：
            void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义
        BufferedReader：
            public String readLine()：读一行文字。
                结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null
 */
public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
     /*
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("IO流\\bw.txt"));
        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
//            bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
        */

        //创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("IO流\\bw.txt"));

        //public String readLine()：读一行文字。

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

        br.close();
    }
}

什么是比特(Bit),什么是字节(Byte),什么是字符(Char),它们长度是多少,各有什么区别

bit(位)最小的二进制单位，是计算机的操作部分取值0或者1
byte(字节)是计算机操作数据的最小单位由8位bit组成取值（-128-127）
char(字符)是用户的可读写的最小单位，在Java里面由16位bit组成取值（0-65535）
- 一般 utf-8 编码下，一个汉字字符占用 3 个字节；
- 一般 gbk 编码下，一个汉字字符占用 2 个字节；

什么叫对象序列化，什么是反序列化，实现对象序列化需要做哪些工作

对象序列化，将对象以二进制的形式保存在硬盘上
- 这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
- 字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
- 对象序列化流： ObjectOutputStream
反序列化；将二进制的文件转化为对象读取
- 将字节序列从文件中读取回来，重构对象
- 实现serializable接口，不想让字段放在硬盘上就加transient

对象序列化流： ObjectOutputStream

package IO流.序列化;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
    对象序列化流
        构造方法：
            ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
        序列化对象的方法：
            void writeObject(Object obj)：将指定的对象写入ObjectOutputStream
    NotSerializableException:抛出一个实例需要一个Serializable接口。 序列化运行时或实例的类可能会抛出此异常
    类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化
 */
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("IO流\\oos.txt"));

        //创建对象
        Student s = new Student("哈哈",20);

        //void writeObject(Object obj)：将指定的对象写入ObjectOutputStream
        oos.writeObject(s);

        //释放资源
        oos.close();
    }
}

对象反序列化流：ObjectInputStream

package IO流.序列化;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;


/*
    构造方法：
        ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
    反序列化对象的方法：
        Object readObject()：从ObjectInputStream读取一个对象
 */
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("IO流\\oos.txt"));

        //Object readObject()：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());

        ois.close();
    }
}

打印流

字节打印流

package IO流.特殊流;

import java.io.IOException;
import java.io.PrintStream;

/**
    打印流的特点：
        只负责输出数据，不负责读取数据
        有自己的特有方法
    字节打印流
        PrintStream(String fileName)：使用指定的文件名创建新的打印流
 */
public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        //PrintStream(String fileName)：使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("IO流\\ps.txt");

        //写数据
        //字节输出流有的方法
//        ps.write(97);

        //使用特有方法写数据
       	ps.print(97);
        ps.println(98);

        //释放资源
        ps.close();
    }
}

字符打印流

package IO流.特殊流;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
    字符打印流的构造方法：
        PrintWriter(String fileName) ：使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新

        PrintWriter(Writer out, boolean autoFlush)：创建一个新的PrintWriter
            out：字符输出流
            autoFlush： 一个布尔值，如果为真，则println ， printf ，或format方法将刷新输出缓冲区
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //PrintWriter(String fileName) ：使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新

//        PrintWriter pw = new PrintWriter("IO流\\pw.txt");

//        pw.write("haha");
//        pw.write("\r\n");
//        pw.flush();
//        pw.write("hehe");
//        pw.write("\r\n");
//        pw.flush();

//        pw.println("haha");
//        pw.flush();
//        pw.println("hehe");
//        pw.flush();

        //PrintWriter(Writer out, boolean autoFlush)：创建一个新的PrintWriter
        PrintWriter pw = new PrintWriter(new FileWriter("IO流\\pw.txt"),true);
//        PrintWriter pw = new PrintWriter(new FileWriter("IO流\\pw.txt"),false);

        pw.println("haha");
        pw.println("hehe");

        pw.close();
    }
}

标准流

标准输出流

package IO流.特殊流;

import java.io.PrintStream;

/**
    public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
 */
public class SystemOutDemo {
    public static void main(String[] args) {
        //public static final PrintStream out：标准输出流
        PrintStream ps = System.out;

        //能够方便地打印各种数据值
//        ps.print("hello");
//        ps.print(100);

//        ps.println("hello");
//        ps.println(100);

        //System.out的本质是一个字节输出流
        System.out.println("hello");
        System.out.println(100);

        System.out.println();
//        System.out.print();
    }
}

标准输入流

package IO流.特殊流;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

/**
    public static final InputStream in：标准输入流。
        通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
 */
public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        //public static final InputStream in：标准输入流

//        InputStream is = System.in;

//        int by;
//        while ((by=is.read())!=-1) {
//            System.out.print((char)by);
//        }

        //如何把字节流转换为字符流？用转换流

//        InputStreamReader isr = new InputStreamReader(is);

//        //使用字符流能不能够实现一次读取一行数据呢？可以
//        //但是，一次读取一行数据的方法是字符缓冲输入流的特有方法
//        BufferedReader br = new BufferedReader(isr);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("请输入一个字符串：");
        String line = br.readLine();
        System.out.println("你输入的字符串是：" + line);

        System.out.println("请输入一个整数：");
        int i = Integer.parseInt(br.readLine());
        System.out.println("你输入的整数是：" + i);

        //自己实现键盘录入数据太麻烦了，所以Java就提供了一个类供我们使用
        Scanner sc = new Scanner(System.in);
    }
}