JAVA基础 day21 字节流的输入和输出 字节流的缓冲区 （自己实现BufferedInputStream） 键盘输入 转换流的用法 改变标准输入输出设备 IO流操作的基本规律

字节流：
OutputStream:字节流写入基类。

字节流并不需要刷新操作，因为字符流底层是将传入的字节先存放在一个数组中，然后去查表得到字符，所以需要刷新。而字节流是直接将数据传送到目标位置。

FileOutputStream 文件字节写入操作类

import java.io.*;
class FileOutputStreamDemo
{
    public static void main(String[]args)throws IOException
    {
        FileOutputStream fos=new FileOutputStream("basketball.txt");
        byte[]bt={'c','d','e','f'};
        fos.write((byte)'a');
        fos.write((byte)'b');
        fos.write(bt);
        fos.close();
    }
}

FileInputStream 文件字节读出类
available()方法，可以读取文件的字节数。

import java.io.*;
class FileInputStreamDemo
{
    public static void main(String []args)throws IOException
    {
        FileInputStream fis=new FileInputStream("basketball.txt");
        int b=0;
        while ((b=fis.read())!=-1)
        {
            System.out.println((char)b);
        }
        fis.close();

    }
}

字节流缓冲区 进行复制文件

import java.io.*;
class CopyStreamDemo
{
    public static void main(String[]args)throws IOException
    {
        FileInputStream fis=new FileInputStream("basketball.jpeg");
        FileOutputStream fos=new FileOutputStream("d:\\copy.jpeg");
        BufferedInputStream bis=new BufferedInputStream(fis);
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        int num=0;
        System.out.println(fis.available());
        while ((num=bis.read())!=-1)
        {
            bos.write((char)num);
        }
        fis.close();
        fos.close();
    }
}

自己实现BufferedInputStream：将数据读入缓冲区
这个程序的难点在于：
因为读取的是byte字节，所以数据中很可能会出现8个1，即-1的情况，这时候程序会直接结束，为了避免这种情况，我们返回值设置成了int类型，即4个字节，然后&上 255，就变成了00000000 00000000 00000000 1111111.就不会再出现未达到文件结尾而出现-1的情况，而写的时候，write方法会自动将int数据变为字节数据进行写入，即只写后八位。

import java.io.*;
class MyBufferedInputStream
{
    private FileInputStream fis;
    private byte[]buf=new byte[1024];
    private int count=0,pos=0;//定义一个计数器，一个指针，计数器取得每次读取的数据，然后每读取一次就递减，指针用来读取数组中的元素，每读取一个就递增。
    MyBufferedInputStream(FileInputStream fis)
    {
        this.fis=fis;
    }
    public int myRead()throws IOException
    {
        if(count==0)//当count为0时，就从文件中向数组读取数据
        {
        count=fis.read(buf);
        if(count<0)
            return -1;
        pos=0;
        byte b=buf[pos];
        count--;
        pos++;
        return b&0xff;//因为读取的是byte字节，所以数据中很可能会出现8个1，即-1的情况，这时候程序会直接结束，为了避免这种情况，我们返回值设置成了int类型，即4个字节，然后&上 255，就变成了00000000 00000000 00000000 1111111.就不会再出现未达到文件结尾而出现-1的情况
        }
        else if(count>0)//当count不为0时，就直接从数组取就行
        {
            byte b=buf[pos];
            count--;
            pos++;
            return b&0xff;
        }
        return -1;      
    }
    public void myClose()throws IOException
    {
        fis.close();
    }

}
class MyBufferedInputStreamDemo
{
    public static void main(String[]args)throws IOException
    {
        FileInputStream fis=new FileInputStream("1.mp3");
        FileOutputStream fos=new FileOutputStream("2.mp3");
        MyBufferedInputStream mbis=new MyBufferedInputStream(fis);
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        int num=0;
        long start=System.currentTimeMillis();
        while((num=mbis.myRead())!=-1)
        {
            bos.write(num);
        }
        long end=System.currentTimeMillis();
        System.out.println((end-start));
        mbis.myClose();
        bos.close();

    }
}

键盘录入，当输入over时停止程序

import java.io.*;
class ReadIn
{
    public static void main(String[]args)throws IOException
    {
        InputStream in=System.in;
        byte []c=new byte[1024];

        int num=in.read(c);
        String s=new String(c,0,num);
        if(s.equals("over\r\n"))//因为输入中有个空格，所以要加\r\n,也可以用StringBuilder容器来实现 
            System.exit(0);
        else
            System.out.println(s);

    }
}

转换流：字符和字节之间转换的桥梁。通常涉及到字符编码转换时，可以使用转换流类的构造方法来指定字符编码表，这时候使用转换流。

读取转换流：InputStreamReader： 将字节流转换为字符流，将输入的字节变为字符，可以用字符流的方法。

import java.io.*;
class InputStreamReaderDemo
{
    public static void main(String[]args)throws IOException
    {
        InputStream in=System.in;
        InputStreamReader isr=new InputStreamReader(in);//接收一个字节流，转换为字符流
        BufferedReader br=new BufferedReader(isr);//字符流缓冲区就可以接收被转换的字节流
        String s=null;
        while(!(s=br.readLine()).equals("over"))
        {
            System.out.println(s);
        }
        br.close();
    }
}

写入转换流：OutputStreamWriter：将字符流变成字节流进行写入操作

import java.io.*;
class InputStreamReaderDemo
{
    public static void main(String[]args)throws IOException
    {
        InputStream in=System.in;
        InputStreamReader isr=new InputStreamReader(in);
        BufferedReader br=new BufferedReader(isr);
        //简写
        //BufferedReader br=
        //new BufferedReader（new InputStreamReader（System.out））;
        OutputStream out=System.out;//可以直接用write方法写到屏幕上
        OutputStreamWriter osw=new OutputStreamWriter(out);
        BufferedWriter bw=new BufferedWriter(osw);

        String s=null;
        while(!(s=br.readLine()).equals("over"))
        {
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        br.close();
    }
}

编程：键盘输入的数据写入到文件中

import java.io.*;
class TransDemo
{
    public static void main(String[]args)throws IOException
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("trans.txt")));
        String s=null;
        while(!(s=br.readLine()).equals("over"))
        {
            bw.write(s);
        }
        br.close();
        bw.close();
    }
}

IO流操作的基本规律：
1.明确源和目的
源是用来读取的：InputStream，Reader
目的是用来写入的：OutputStream，Writer
2.操作的是不是纯文本
是：字符流
否：字节流
3.明确使用的对象
源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台

改变标准输入输出设备
System类里的setIn和setOut方法可以改变标准的输入输出设备。
（标准的输入设备是键盘，输出设备是控制台）

编码：将系统信息打印到文本文件中

import java.io.*;
import java.util.*;
class SysInfoDemo
{
    public static void main(String []args)throws IOException
    {
         Properties p=System.getProperties();
         p.list(new PrintStream("sysinfo.txt"));
    }
}