”黑马程序员“之io

----- <a href=" http://www.itheima.com" target="blank">android培训</a>、<a href=" http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
花了两天时间终于搞定了所有IO:下面是我跟毕老师一起打的
笔记：
package com.oxf.io;
import java.io.*;
public class Demo1 {
    /**
     *字符流和字节流
     *字节流两个基类
     *InputStream    OutputStream
     *
     *字符流两个基类
     *Reader  Writer
     *先学习字符流的特点
     *
     *既然IO流是用于操作数据的那么数据最常见的体现形式是：文件
     *那么先以操作文件为主来演示
     *需求：在硬盘上，创建一个文件并写入一些文字数据
     *
     *找到一个专门用于操作文件的Writer子类对象FileWriter后缀名是父类名，前缀是该对象的功能
     * @throws Exception
     *
     */
    public static void main(String[] args) throws Exception {
        //创建一个FileWriter对象，该对象一被初始化就要必须要明确被操作的文件
        //而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将覆盖。
        //其实该步就是在明企鹅塑胶要存放在目的地
        FileWriter fw=new FileWriter("d:\\demo.txt");
        //调用write方法，将写到流当中去了。要写入记事本需要flush（）或者close（）一下
        //
        fw.write("adfns");
        fw.flush();
        //关闭流资源，但是关闭之前会刷新 次内部的缓冲中的数据
        //将数据刷到目的地中
        //和flush区别是：flush刷新后流可以继续使用，close刷新后将会关闭流。不能再刷。
        fw.close();
    }

}
package com.oxf.io;

import java.io.FileWriter;
import java.io.IOException;

public class Demo2 {

    /**
     * IO异常的处理方式
     * @param args
     */
    public static void main(String[] args) {
        FileWriter fw=null;
        try {
            //
            fw=new FileWriter("d:\\demo");
            fw.write("d:\\demo");
           
        } catch (IOException e) {
            System.out.println(e.toString());
        }finally{
                try {
                    if(fw!=null)
                    fw.close();
                } catch (IOException e) {
                    System.out.println(e.toString());
                }
        }

    }

}

package com.oxf.io;

import java.io.*;

public class Demo3 {

    /**
     * 演示已有文件的数据续写
     * @param args
     */
    public static void main(String[] args) {
        //传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行数据续写
        FileWriter fw=null;
        try {
             fw=new FileWriter("d:\\demo");
             fw.write("adfbdsjf\r\n");//\r\n代表换行
             
        } catch (IOException e) {
            System.out.println(e.toString());
        }finally{
            try {
                if(fw!=null)
                fw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}
package com.oxf.io;

import java.io.*;


public class Demo4 {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //创建一个文件读取流对象，和指定名称的文件相关联
        //要保证该文件是已经存在的如果不存在，会发生异常FileNotFoundException
        FileReader fr=new FileReader("");
        //调用读取流对象的read方法
        //read():一次读一个字符，而且会自动往下读
        int ch=fr.read();
        System.out.println("ch="+(char)ch);
        int ch2=fr.read();
        System.out.println("ch2="+(char)ch2);
        int ch3=fr.read();
        System.out.println("ch3="+(char)ch3);
        int ch4=0;
        while((ch4=fr.read())!=-1){
            System.out.println(ch4);
        }
        fr.close();
    }

}
package com.oxf.io;

import java.io.*;

public class Demo5 {

    /**
     * 第二种方式：通过字符数组进行读取
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        FileReader fr=new FileReader("d:demo.txt");
        //定义一个字符数组，用于存储读到字符
        //该read(char[])返回的是读到的字符个数
//        char[] buf=new char[3];
//        int num=fr.read(buf);
//        System.out.println(num+"   "+new String(buf));
        char[] buf=new char[3];
        int num=0;
        while((num=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,num));
        }
        fr.close();
    }

}
package com.oxf.io;

import java.io.*;

public class Demo6 {

    /**
     * 读取一个。java文件。并打印在控制台上
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
            FileReader fr=new FileReader("DateDemo.java");
            char[] buf=new char[1024];
            int num=0;
            while((num=fr.read(buf))!=-1){
                System.out.print(new String(buf,0,num));
            }
            fr.close();

    }

}
package com.oxf.io;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class BuffereWriterDemo7 {

    /**
     * 缓冲区的出现是为了提高流的操作效率而出现的
     * 所以在创建缓冲区之前。必须要先有流对象
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //创建一个字符写入流对象
        FileWriter fw=new FileWriter("buf.txt");
        //为了提高字符写入流效率，加入缓冲技术
        //只要将需要被提高效率的流对象做完传递给缓冲区的构造函数作为参数即可
        BufferedWriter bufw=new BufferedWriter(fw);
        bufw.write("sdfsfsdfsd");
        bufw.newLine();//换行。跨平台。\r\n是windows系\n是nilux
        //记住只要用到缓冲区就要记得刷新
        bufw.flush();
        //其实关闭缓冲区就是关闭缓冲区中的流的对象
        bufw.close();
        fw.close();
    }

}
package com.oxf.io;
import java.io.*;
public class BufferedReaderDemo8 {

    /**
     * 字符读取流缓冲区
     * 该缓冲区提供一个一次读取一行的方法，readLine(),方便于文本数据的获取，
     * 当返回NULL时，表示读到文件末尾
     * readLine()返回的时候只返回回车符之前的字符，并不返回换行符。
     * @param args
     */
    public static void main(String[] args) throws Exception{
        //创建一个读取流对象和文件相关联
        FileReader fr=new FileReader("d:\\info.txt");
        //为了提高效率，加入缓冲技术，我们可以把fr作为参数放在字符读取流缓冲区
        BufferedReader bufr=new BufferedReader(fr);
        //BufferedReader bfdr=new BufferedReder(new FileReader(""));
        /*
        String s1=bufr.readLine();
        System.out.print("s1:"+s1);
        */
        String line=null;
        while((line=bufr.readLine())!=null){
            System.out.println(line);
        }
        bufr.close();
    }

}
package com.oxf.io;
import java.io.*;
public class CopyMp3Demo {

    /**
     * 演示mp3的复制，通过缓冲区
     * BufferedOutputStream   BufferedInputStream
     *
     * @param args
     */
    public static void main(String[] args) throws Exception{
        long start =System.currentTimeMillis();
        copy_1();
        long end=System.currentTimeMillis();
        System.out.println(start-end);
    }
    //通过字节流的缓冲区完成复制
    public static void copy_1() throws Exception{
        BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("d:\\1.mp3"));
        BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("d:\\2.mp3"));
        byte[] bt=new byte[1024];
        int len=0;
        while((len=bufis.read(bt))!=-1){
            bufos.write(bt,0,len);
        }
        bufos.close();
        bufis.close();
    }
}
package com.oxf.io;
import java.io.*;
public class CopyPic {

    /**
     * 复制一个图片
     * 1，用字节读取流对象和图片关联
     * 2.用字节写入流对象创建一个图片文件。用于存储获取到的图片数据
     *3通过循环读写完成数据存储
     * 4关闭
     * @param args
     */
    public static void main(String[] args) throws Exception{
        copypicture();
       
    }
    public static void copypicture() throws Exception{
        FileInputStream fis=new FileInputStream("d:\\1.jpg");
        FileOutputStream fos=new FileOutputStream("c:\\1.jpg");
       
        int len=0;
        byte[] bt=new byte[1024];
        while((len=fis.read(bt))!=-1){
            fos.write(bt,0,len);
        }
        fos.close();
        fis.close();
    }
}
package com.oxf.io;
import java.io.*;
public class CopyTest {

    /**
     * 将C盘一个文本文件复制到D盘
     * 复制的原理；
     * 其实就是将C盘下的文件数据存储到D盘的一个文件中
     * 步骤：
     * 1.在D盘创建一个文件，用于存储C盘文件中的数据
     * 2.定义读取流和C盘文件关联
     * 3、通过不断的读写完成数据存储
     * 4、关闭资源
     * @param args
     */
    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        copy_2();
    }
    //从D盘读一个字符，就往C盘写个字符
    public static void copy_1() throws Exception{
        //创建目的地
        FileWriter fw=new FileWriter("c:demo.txt");
        //与已有文件关联
        FileReader fr=new FileReader("d:info.txt");
        int ch=0;
        while((ch=fr.read())!=-1){
            fw.write(ch);
        }
        fw.close();
        fr.close();
    }
    //从D盘读整个文件往C盘
    public static void copy_2() throws Exception{
        FileWriter fw=new FileWriter("C:\\demo.txt");
        FileReader fr=new FileReader("d:\\info.txt");
         char[] ch=new char[1024] ;
         int num=0;
         while((num=fr.read(ch))!=-1){
             fw.write(ch,0,num);
             fw.flush();
         }
         fw.close();
         fr.close();
    }
}

package com.oxf.io;
import java.io.*;
public class CopyTextByBuf {

    /**
     * 通过缓冲区复制一个。java文件
     * @param args
     * @throws FileNotFoundException
     */
    public static void main(String[] args) throws Exception {
        BufferedReader bufr=null;
        BufferedWriter bufw=null;
       
        bufr=new BufferedReader(new FileReader("d:\\info.txt"));
        bufw=new BufferedWriter(new FileWriter("c:\\info.txt"));
        String line=null;
        while((line=bufr.readLine())!=null){
           
            bufw.write(line);
            bufw.flush();
        }
        bufw.close();
        bufr.close();
    }

}
package com.oxf.io;

import java.io.*;

public class Demo10 {

    /**
     * 字符流:使用的字符数组
     * FileReader    FileWriter
     * BufferedReader   BufferedWriter
     *
     * 字节流：使用的字节数组
     * InputStream    OutputStream
     * 需求：想要操作图片数据，这就要用到字节流
     * @param args
     */
    public static void main(String[] args)  throws Exception{
        readFile3();
        //writeFile();
    }
    public static void writeFile() throws Exception{
        FileOutputStream fos=null;       
             fos=new FileOutputStream("d:\\demo.txt");       
                fos.write("sfsjk".getBytes());
           
    }
    public static void readFile() throws Exception{
        FileInputStream fis=new FileInputStream("d:\\demo.txt");
        int ch=0;
        while((ch=fis.read())!=-1){
            System.out.println((char)ch);
        }
        fis.close();
    }
    public static void readFile2() throws Exception{
        FileInputStream fis=new FileInputStream("d:\\demo.txt");
        byte[] ch=new byte[1024];
        int len=0;
        while((len=fis.read(ch))!=-1){
            System.out.println(new String(ch,0,len));
        }
        fis.close();
    }
    //字节流特有的
    public static void readFile3() throws Exception{
        FileInputStream fis=new FileInputStream("d:\\demo.txt");
        int num=fis.available();
        byte[] buf=new byte[num];//定义一个刚刚好的缓冲区，不用再循环了
        fis.read(buf);
        System.out.println(new String(buf));
       
        //System.out.println("num="+num);
        fis.close();
    }
}
package com.oxf.io;

import java.io.*;

public class Demo11 {

    /**
     * 字符流:使用的字符数组
     * FileReader    FileWriter
     * BufferedReader   BufferedWriter
     *
     * 字节流：使用的字节数组
     * InputStream    OutputStream
     * BufferedInputStream     BufferedOutputStream
     * @param args
     *
     * 源：键盘录入，
     * 目的：控制台
     * 2.需求：想把键盘读入的数据存储到一个文件当中
     * 源：键盘
     * 目的：文件
     * 3需求：
     * 想要将一个文件的数据打印在控制台上，
     * 源：文件
     * 目的：控制台
     *
     * 流操作的基本规律：
     * 最痛苦的就是流对象有很多，不知道该用哪一个？
     * 通过两个明确来完成。
     * 1.明确源和目的。
     * 源：输入流 InputStream  Reader
     * 目的：输出流 OutputStream   Writer
     * 2.操作的数据是纯文本
     * 是：字符流
     * 不是：字节流
     *
     * 3.当体系明确后，再明确要使用哪个具体对象。
     * 通过设备来进行区分
     * 源设备：内存，硬盘，键盘
     * 目的设备：内存，硬盘。控制台
     *
     * 第一个需求：
     * 将一个文件中的数据存储到另一个文件中
     * 源：文件因为是源所以用读取流（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")
     *
     * FileWriter fw=new FileWriter("b.txt")
     * BufferedWriter bufw=new BufferedWriter(fw)
     * ---------------------------------------
     * 练习：将一个图片文件中数据存储到另一个文件中。复制文件要按照以上格式自己完成三个明确
     * 源：InputStream             字节流           硬盘
     * 目的：      OutputStream          字节流        硬盘
     *new  BufferedInputStream(new FileInputStream("d.jpg"))
     *new BufferedOutputStream(new FileOutputStream("d1.jpg"))
     * --------------------------------------------
     * 第二个需求：
     * 将键盘录入的 数据保存到一个文件中
     * 这个学期中有源和目的都存在
     * 那么分别分析
     * 源：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);
     * 所以，记住，转换流什么时候使用，字符和字节之间的桥梁。通常，涉及到字符编码转换时 ，需要用到转换流
     * -------、
     * 练习：
     * 将一个文本数据打印在控制台上，需要安装以上格式完成三个明确。
     * 需要转换流下面就是 一个例子
     */
    public static void main(String[] args) throws Exception{
        // 获取键盘录入对象
        //InputStream in  =System.in;
        //将字节流对象转换成字符流流对象，使用转换流，InputStreamReader
        //InputStreamReader isr= new InputStreamReader(new FileInputStream("d:\\demo.txt"));
        //为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
        //BufferedReader bufr=new BufferedReader(isr);
        //键盘录入最常见的写法：BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
        //System.setIn(new FileInputStream("d:\\demo.txt"));
        //System.setOut(new PrintStream("d:\\3.txt"));
        BufferedReader bufr=new BufferedReader(new InputStreamReader(new FileInputStream("d:\\demo.txt")));
        BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
        String line =null;
   
        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
           
            System.out.println(line.toUpperCase());
            bufw.newLine();
            bufw.close();
        }
   
        bufr.close();

    }

}
package com.oxf.io;

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

public class Demo12 {

    /**
     * 日志文件创建
     * @param args
     */
    public static void main(String[] args) {
        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:\\exeception.log");
                ps.write(s.getBytes());
                System.setOut(ps);
            } catch (IOException e1) {
                throw new RuntimeException("日志文件创建失败");
            }
            e.printStackTrace(System.out);
        }
       
    }

}

----- <a href=" http://www.itheima.com" target="blank">android培训</a>、<a href=" http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------