黑马程序员——Java基础——IO输入与输出_2

IO流

作用：

• 利用Java语言中的IO流技术处理设备上的数据（硬盘上的文件，内存中驻留的数据）

分类：

• 按流向：
  
  • 输入流
  • 输出流
• 按数据：
  
  • 字节流
  • 字符流

抽象基类：

• 字符流：Reader、Writer
• 字节流：InputStream、OutputStream

字节流

FileInputStream对象:

import java.io.*;
class FileStream
{
    public static void readFile_1() throws IOException
    {
        FileInputStream fis = new FileInputStream("文件名.类型");
        int ch = 0;
        while((ch = fis.read()) != -1)
        {
            System.out.println((char)ch);
        }
            fis.close();
    }
    public static void readFile_2() throws IOException
    {
        FileInputStream fis = new FileInputStream("文件名.类型");
        byte[] buf = new byte[1024];
        int len = 0;
        while((ch = fis.read(buf)) != -1)
        {
            System.out.println(new String(buf, 0, len));
        }
        fis.colse();
    }
    public static void readFile_3() throws IOException
    {
        FileInputStream fis = new FileInputStream("文件名.类型");
        //字节读取流特有方法available();
        //int num = fis.available();显示文件字节大小
        //定义一个刚刚好的缓冲区，此时不用循环
        //慎重使用，防止溢出
        byte[] buf = new byte[(fis.available)];
        fis.read(buf);
        System.out.println(new String(buf));
        fis.colse();
    }
    public static void writeFile() throws IOException 
    {
        FileOutputStream fos = new FileOutputStream("文件名.类型");
        fos.write("abcde".getBytes());
        fos.close();
    }
}

拷贝文件：

import java.io.*;
class CopyPic
{
    public static void main(String[] args)
    {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try
        {
            fos = new FileOutputStream("目标文件.类型");
            fis = new FileInputStream("文件.类型");

            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("写入关闭失败");
            }
        }
    }
}

字节流缓冲区：

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("被文件路径.类型"));
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("复制文件路径.类型"));

        int by = 0;

        while((by = bufis.read()) != -1)
        {
            bufos.write(by);
        }
        bufos.colse();
        bufis.close();
    }
}

自定义字节流缓冲区：

import java.io.*;
class MyBufferedInputStream
{
    private InputStream in;
    private byte[] buf = new byte[1024];
    private int pos = 0, count = 0;

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

    //一次读一个字节，从字节流缓冲区(字节数组)中读取
    public int myRead() throws IOException
    {
        if(count == 0)
        {
            count = in.read(buf);
            if(count < 0)
                return -1;
            pos = 0;
            byte b = buf[pos];
            count--;
            pos++;
            return b&255;
            //保留四位与15，八位与255
            //b&0xff与b&255一致，一个十六进制，一个十进制
        }
        else if(count>0)
        {
            byte b = buf[pos];
            count--;
            pos++;
            return b;
        }
        return -1;
    }
    public void myClose() throws IOException
    {
        in.myClose();
    }
}

读取键盘录入：

//读取键盘录入
//System.in对应标准输出设备:控制台
//System.out对应标准输入设备:键盘
//需求：通过键盘录入数据，当录入一行数据后，打印该行数据
//     如果录入“over”，则停止录入
//想要程序停止使用“Ctrl+c”
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();
            //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);
        }
    }
}

读取转换流,InputStreamReader:

• readLine方法是字符流缓冲区BufferedReader类中的方法，而键盘录入的read方法是字节流InputStream的方法，将字节流转换成字符流再使用字符流缓冲区的readLine方法。

import java.io.*;
class TransStreamDemo
{
    public static void main(String[] args) throws IOException
    {
            InputStream in = System.in;
            InputStreamReader isr = new InputStreamReader(in);
            BufferedReader bufr = new BufferedReader(isr);
            String line = null;
            while((line = bufr.readLine()) != null)
            {
                if("over".equals(line))
                    break;
                System.out.println(line.toUpperCase());
            }
            bufr.colse();
    }
}

写入转换流,OutputStreamWriter:

import java.io.*;
class TransStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        //InputStream in = System.in;
        //InputStreamReader isr = new InputStreamReader(in);
        //BufferedReader bufr = new BufferedReader(isr);
        //简化(键盘录入最常见写法)
        BufferedReader bufr = 
                new BufferedReader(new InputStream(System.in));

        //OutputStream out = System.out;
        //OutputStreamWriter osw = new OutputStreamWriter(out);
        //BufferedWriter bufw = new BufferedWriter(osw);
        //简化  
        BufferedWriter bufr = 
                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.colse();
    }
}

操作规律：

接受键盘录入，并将其显示在控制台上

• 源：键盘
• 终：控制台

把键盘录入的文件保存在文件中

• 源：键盘
• 终：文件

import java.io.*;
class TransStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader bufr = 
                        new BufferedReader(new InputStream(System.in)); 

        //更改此处
        BufferedWriter bufr = 
                new BufferedWriter(
                        new OutputStreamWriter(
                                new FileOutputStream("目标文件.txt")));

        String line = null;
        while((line = bufr.readLine()) != null)
        {
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
        bufr.colse();
    }
}

把一个文件中的内容打印到控制台上

• 源：文件
• 终：控制台

import java.io.*;
class TransStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        //更改此处
        BufferedReader bufr = 
                new BufferedReader(
                        new InputStream(
                                new FileInputStream(“目标文件.txt”))); 

        BufferedWriter bufr = 
                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.colse();
    }
}

流对象有很多，不知该用哪一个

1. 明确源和目的
   
   • 源：输入流 InputStream Reader
   • 目的：输出流 OutputStream Writer
2. 明确操作的数据是否是纯文本
   
   • 是：字符流
   • 不是：字节流
3. 当体系明确后，再通过设备来明确要使用哪个具体的对象
   
   • 源设备：内存，硬盘，键盘
   • 目的设备：内存，硬盘，控制台

三个需求：
将一个文本文件中数据存储到另一个文件中。复制文件

1. 源？
   InputStream Reader
2. 是不是纯文本？
   是：Reader
3. 明确使用体系中的哪个对象？明确设备：
   硬盘上的一个文件 FileReader
4. 是否需要提高效率？
   是：BufferedReader

---

1. 目的？
   OutPutStream Writer
2. 是不是纯文本？
   是：Writer
3. 明确设备：
   硬盘上的一个文件 FileWirter
4. 是否需要提高效率？
   是：BufferedWriter

将键盘录入的数据保存到一个文件中

1. 源？
   InputStream Reader
2. 是不是纯文本？
   是：Reader
3. 明确设备：
   键盘，对应的对象是System.in(字节流)明确了Reader，那么就将System.in转换成Reader IuputStreamReader
4. 是否需要提高效率？
   是：BufferedReader

---

1. 目的？
   OutPutStream Writer
2. 是不是纯文本？
   是：Writer
3. 明确设备：
   硬盘上的一个文件 FileWriter
4. 是否需要提高效率？
   是：BufferedWriter

扩展：想要把录入的数据按照指定的编码表，将数据存到文件中 GBK(默认)、UTF-8

1. 目的？
   OutPutStream Writer
2. 是不是纯文本？
   是：Writer
3. 明确设备：
   硬盘上的一个文件 FileWirter
4. 指定编码表
   OutputStreamWriter(FileOutputStream())
5. 是否需要提高效率？
   是：BufferedWriter

转换流什么时候使用？
字符和字节之间的桥梁，通常涉及到字符编码转换时，需要用的转换流

改变标准输入输出设备：
System.setIn(new FileInputStream(“文件名称.类型”))
System.out(new PrintStream(“文件名称.类型”))

异常的日志信息：

//log4j:java日志信息类
import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;
class ExceptionInfo 
{
    public static void main(String[] args) throws IOException
    {
        try
        {
            int[] arr = new int[2];
            System.out.println(arr[3]);
        }
        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://test/exec.log");
                ps.println(s);
                System.setOut(ps);
            }
            catch(IOException ex)
            {
                throw new RuntimeException("日志文件创建失败！");
            }
            e.printStackTrace(new PrintStream(System.out));
        }
    }
}

系统信息:

import java.io.IOException;
import java.io.PrintStream;
import java.util.Properties;

public class SystemInfo 
{
    public static void main(String[] args) throws IOException
    {
        Properties prop = System.getProperties();
        //System.out.println(prop);
        //prop.list(System.out);
        prop.list(new PrintStream("d://test/sysinfo.txt"));
    }
}