黑马程序员——java基础——IO流（一）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——

IO流用来处理设备间的数据传输
流按照操作数据分为两种：字节流和字符流
流按流向分为：输入流和输出流

//字符流文件的读取：
import java.io.*;
class  FileReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个文件读取流对象，和指定名称的文件相关联。
        //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
        FileReader fr = new FileReader("demo.txt");

        //读取文件的第一种方法：
        //调用读取流对象的read方法。read():一次读一个字符。而且会自动往下读。
        int ch = 0;
        while((ch=fr.read())!=-1)
        {
            System.out.println("ch="+(char)ch);//需要将ch转为字符
        }
        //读取文件的第二种方法
        char[] buf = new char[1024];//一个字符是两个字节，所以1024个字符是2k,自定义数组里面字符个数为1024个
        int num = 0;//num返回的是写入数组里面的字符个数
        while ((num=fr.read(buf))!=-1)
        {
            System.out.print("num="+num+"......"+new String(buf,0,num));
            //new string(ch)将字符数组以字符串的形式表现出来，截取ch[0]到ch[num]之间的字符,用print() 不用println()
        }

        //读取文件的第三种方法：加入缓冲区，可以一次读一行，提高效率
        BufferedReader bufr = new BufferedReader(new FileReader("demo.txt"));
        String line = null;
        while ((line=bufr.readLine())!=null)
        {
            System.out.println("line="+line);
        }

        fr.close();
    }
}

//字符流文件的写入和续写：
import java.io.*;
class FileWriterDemo 
{
    public static void main(String[] args) throws IOException
    {
        //必须先创建一个指定的文件
        //该步骤就是明确文件存放的目的地
        //在指定目录下创建一个文件，如果有同名的文件存在，就会覆盖
        FileWriter fw = new FileWriter("demo.txt",true);//加true，可以直接在已有的文件下，将数据写入文件末尾处
        fw.write("hsgjkhasjh");//将内容写在了流中，在Windows系统下 \r\n  代表enter键
        fw.flush();//将流中的数据刷新到目的文件中，并且可以继续写入内容
        fw.close();//在关闭流之前会先将内容刷新到指定文件中，执行此操作后就不能继续写入文件了
    }
}

在文件的读取和写入时，一般都会发生IOException，IO流对异常的处理有其特殊的处理方式

用IO流对一个文件进行复制
将g盘下的一个.java文件复制到f盘下
1.在f盘下创建一个指定文件
2.和g盘下的指定文件相关联
3.将g盘下的文件写到f盘下
4.关闭资源

import java.io.*;
class IOCopy 
{
    public static void main(String[] args) 
    {
        copy();
    }
    public static void copy()
    {
        //在外面建立引用
        BufferedWriter bufw= null;
        BufferedReader bufr = null;
        try
        {
            bufw = new BufferedWriter(new FileWriter("F:\\Demo.java"));
            bufr = new BufferedReader(new FileReader("Demo.java"));
            String line = null;
            //加入缓冲技术，可以一次读一行，提高了效率
            while ((line=bufr.readLine())!=null)
            {
                bufw.write(line);
                bufw.newLine();//一定要在写一行后写一个换行符
                bufw.flush();//写一行刷新一行
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        //一定要关闭资源，在关闭资源时，也会发生异常，所以也要处理
        finally 
        {
            try
            {
                //关闭资源前要判断流中有没有数据，有可能由于前面的异常流中根本就没有数据
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e)
            {
                System.out.println("写入流资源关闭失败");
            }
            try
            {
                if(bufr!=null)
                    bufr.close();
            }
            catch (IOException i)
            {
                System.out.println("读取流资源关闭失败");
            }
        }
    }
}

字符流只能用来操作纯文本数据，对于图片，影音等数据的操作，我们不能使用字符流，要使用字节流
用字节流来实现对一个图片文件进行复制

//复制一个图片
import java.io.*;
class CopyPic
{
    public static void main(String[] args) 
    {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try
        {
            fos = new FileOutputStream("F:\\2.jpg");//建立目的文件2.jpg  用于写到目的文件中
            fis = new FileInputStream("F:\\1.jpg");//将指定文件读出
            //自定义一个字节数组缓冲区，大小我们可以自定义，一般文件较小时，我们定义1k
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len=fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }
        catch (IOException e)
        {
            System.out.println("图片读写异常");
        }
        //读取流和写入流的资源要分别处理和关闭
        finally
        {
            try
            {
                if (fos!=null)
                    fos.close();
            }
            catch (IOException e)
            {
                System.out.println("输出流资源关闭异常");
            }
            try
            {
                if (fis!=null)
                    fis.close();
            }
            catch (IOException e)
            {
                System.out.println("输入流资源关闭异常");
            }
        }
    }
}

总结：字节流的几种读取和写入的方式：
几种读取和写入方式的区别；
1.一次读一个字节然后写入到输出流中
2.将一定量的数据存储到字节数组中，然后将字节数组中的字节一次性全写入到输出流中
3.定义缓冲区，缓冲区内部其实就是封装的一定大小的字节数组，缓冲区的原理是先将输入流中的数据写入到缓冲区的字节数组中，然后通过缓冲区的read方法，将字节数组中的数据一个个的读出

转换流，可以实现字节流和字符流的转换
需求：将键盘录入的数据存储到硬盘上的一个文件中

import java.io.*;
class TransStreamDemo  
{
    public static void main(String[] args) throws IOException
    {
        /*
        System.setIn(new FileInputStream("ReadIn.java"));//可以用来改变输入流 源
        System.setOut(new PrintStream("123.txt"));//可以用来改变输出流 目的
        */
        BufferedReader bufr = null;
        BufferedWriter bufw = null;
        try
        {
            //读取键盘录入的指定格式，加入缓冲区可以录入并操作一行
            bufr = new BufferedReader(new InputStreamReader(System.in));
            //BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("Demo.java")));

            //BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));打印到控制台 
            //将录入的数据存到指定的文件中
            bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("Demo.txt")));

            String line = null;
            while ((line = bufr.readLine())!=null)
            {
                //录入Over程序结束
                if("over".equals(line))
                    break;

                bufw.write(line.toUpperCase());
                bufw.newLine();//必须先换行后再刷新
                bufw.flush();//必须要刷新，因为字符数据储存在缓冲区中，并且需要读一行就刷新一行，
                            //循环只有在读到over时才会结束，bufr.close(),刷新时为缓冲区中全部的数据
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        //一定要关闭资源，在关闭资源时，也会发生异常，所以也要处理
        finally 
        {
            try
            {
                //关闭资源前要判断流中有没有数据，有可能由于前面的异常流中根本就没有数据
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e)
            {
                System.out.println("写入流资源关闭失败");
            }
            try
            {
                if(bufr!=null)
                    bufr.close();
            }
            catch (IOException e2)
            {
                System.out.println("读取流资源关闭失败");
            }
        }
    }
}

流操作的基本规律；
记住 三个明确
1.明确源和目的
源：输入流：Reader InputStream
目的：输出流：Writer OutputStream
2.明确是否为纯文本文件
是：字符流
不是：字节流
3.当体系明确后，应该明确应该用哪个具体的对象
通过设备来区分：
源设备：键盘，硬盘，内存
目的设备：控制台，硬盘，内存

键盘录入的对象是System.in 但其本身属于纯文本，故为了方便，用转换流将字节流转换成字符流
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

想把录入的数据按照指定的编码表（utf-8）打印到文本中
必须使用转换流 即 OutputStreamWriter
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“1.txt”),”UTF-8”));

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

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

class Person
{
    public void work()
    {
        System.out.println("手写");
    }
}
class SuperPerson 
{
    private Person p ;
    SuperPerson(Person p)
    {
        this.p = p;
    }
    public void superWork()
    {
        System.out.println("用电脑");
        p.work();
        System.out.println("复印");
    }
}

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

对于异常我们不能简单的处理，一般情况下我们会将程序的异常信息用文档记录下来
这时我们就会用到一个可以和流相结合的异常方法
void printStackTrace(PrintWriter s)
void printStackTrace(PrintStream s)

小知识点：

//将异常的信息写入到日志文件中
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionLog
{
    public static void main(String[] args) 
    {
        try
        {
            int[] arr = new int[1];
            //角标越界，会发生异常
            System.out.println(arr[3]);
        }
        //捕捉到异常后，可以将异常的信息存储到一个文件中
        catch (Exception e)
        {
            try
            {
                //带着时间打印到日志文件中
                Date d = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String time = sdf.format(d);

                PrintStream ps = new PrintStream("a.txt");
                //将日期按照指定的格式写入
                ps.println(time);
                e.printStackTrace(ps);
            }
            catch (Exception e1)
            {
                System.out.println("文件不存在");
            }
        }
    }
}

//将系统的信息存储到一个日志文件中
import java.io.*;
import java.util.*;
class SystemInfo
{
    public static void main(String[] args) 
    {
        //Properties是一个Map集合，里面装的都是String类型的键值对，并且他可以与流相结合
        Properties prop = System.getProperties();
        try
        {
            //将属性列表输出到指定的输出流(文件b.log)
            prop.list(new PrintStream("b.log"));
        }
        catch (Exception e)
        {
            System.out.println("找不到文件");
        }
    }
}