JAVA笔记11__File类/File类作业/字节输出流、输入流/字符输出流、输入流/文件复制/转换流

/**
 * File类：文件的创建、删除、重命名、得到路径、创建时间等，是唯一与文件本身有关的操作类
 */
public class Main {

    public static void main(String[] args) {
        //File.separator 表示分隔符
        File f1 = new File("c:" + File.separator + "fuck" + File.separator + "javaTest1.txt");
        String s1 = File.pathSeparator; //路径分隔符
        System.out.println(File.separator + "  " + s1);

        boolean b1 = f1.exists(); //文件是否存在
        System.out.println(b1);
        if (!b1) {
            try {
                boolean bt1 = f1.createNewFile(); //创建文件
                System.out.println(bt1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println(f1.delete()); //删除文件

        //System.out.println(""); 快捷键：打sout,然后中按Tab键
        System.out.println(f1.getParent()); //得到文件的上一级路径 

        System.out.println(f1.isDirectory()); //判断是否是目录

        File f2 = new File("c:" + File.separator + "fuck" + File.separator);
        String[] fname = f2.list(); //列出文件夹中的所有文件名
        for(String i:fname) System.out.println(i);

        File[] files = f2.listFiles(); //列出文件中的所有文件，以file数组返回
        for(File i:files) System.out.println(i.getName()+" "+i.length());

        File f3 = new File("c:\\fuck\\JavaTest1");
        System.out.println(f3.mkdir()); //创建文件夹
        f3.delete();

        System.out.println(f3.renameTo(new File("c:\\fuck\\JavaTest2"))); //重命名
    }
}

/**
 * 在某个目录中找到某个扩展名的所有文件
 */
public class Main {
    private static int num = 0;
    public static void findFile(File f,String extName){
        if(f==null)
            return;
        else{
            if(f.isDirectory()){
                File[] fs = f.listFiles();
                if(fs!=null){
                    for(File i:fs)
                        findFile(i,extName);
                }
            }else{
                String path = f.getPath().toLowerCase();
                if(path.endsWith(extName)){
                    System.out.println(f.getPath());
                    ++num;
                }
            }
        }
    }
    public static void main(String[] args) {
        File  f = new File("c:\\fuck\\");
        String extName = ".cpp";
        findFile(f,extName);
        System.out.println(num);
    }
}

/**
 * IO流：输入输出流
 * 流：一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。
 * 流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。
 * 根据处理数据类型的不同分为：1.字符流      2.字节流
 * 根据数据流向不同分为：1.输入流(程序从外部读取)       2.输出流（程序将数据写到外部）
 *
 * OutputStream类：接受输出字节并将这些字节发送到某个接收器
 */
public class Main {

    public static void main(String[] args) {
        //write1();
        write2();
        System.out.println("finished.");
    }

    /**
     * 字节输出流方式一：每次输出一个字节
     */
    public static void write1(){
        OutputStream out = null;
        try {
            out = new FileOutputStream("c:\\fuck\\javaTest1.txt");
            String info = "helloIO";
            byte[] bs = info.getBytes();
            for(int i=0;i<bs.length;++i)
                out.write(bs[i]);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * 字节输出流方式二：每次输出指定大小字节
     */
    public static void write2(){
        OutputStream out = null;
        try {
            out = new FileOutputStream("c:\\fuck\\javaTest1.txt",true); //参数true表示追加输出
            String info = "hello fish7";
            byte[] bs = info.getBytes();
            //out.write(bs);
            out.write(bs,0,5);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

public class Main {

    public static void main(String[] args) {
        //read1();
//        read2();
        read3();
        System.out.println("finished.");
    }

    /**
     * 字节输入流的读取方式一：每次读取一个字节
     */
    public static void read1(){
        InputStream  in = null;
        try {
            in = new FileInputStream("c:\\fuck\\javaTest1.txt");
            int bs = -1; //定义一个字节，-1表示没有数据
            while((bs = in.read())!=-1){
                System.out.print((char)bs);
            }
            System.out.println("");
        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally{
            try {
                in.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * 字节输入流的读取方式二：一次性读取所有字节（适合不太大的文件）
     */
    public static void read2(){
        InputStream in = null;
        try {
            File f = new File("c:\\fuck\\javaTest1.txt");
            in = new FileInputStream(f);
            byte[] bs = new byte[(int)f.length()]; //根据文件大小构造字节数组
            int len = in.read(bs);
            System.out.println(new String(bs));
            System.out.println("len = "+len);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally{
            try {
                in.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * 字节输入流的读取方式三：每次读取指定大小的字节（折中的方法）
     */
    public static void read3(){
        InputStream in = null;
        try {
            File f = new File("c:\\fuck\\javaTest1.txt");
            in = new FileInputStream(f);
            byte[] bs = new byte[5];
            int len = -1; //每次读取的实际长度
            StringBuilder sb = new StringBuilder();
            while((len=in.read(bs))!=-1){
                sb.append(new String(bs,0,len));
            }
            System.out.println(sb);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally{
            try {
                in.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

/**
 * 字符流：底层也是用字节流实现的
 */
public class Main {

    public static void main(String[] args) {
        writer1();
        System.out.println("finished.");
    }

    /**
     * 字符输出流方式一：以字符数组方式输出
     */
    public static void writer1(){
        Writer out = null;
        try {
            File f = new File("c:\\fuck\\javaTest1.txt");
            out = new FileWriter(f,true); //true表示追加方式
            String info = "good good study, day day up.";
            //out.write(info.toCharArray());
            out.write(info);

        } catch (IOException ex) {
            ex.printStackTrace();
        } finally{
            try{
                out.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

/**
 * 字符流：底层也是用字节流实现的
 */
public class Main {

    public static void main(String[] args) {
        //byteReader(); //输出一堆乱码
        reader1();
        System.out.println("finished.");
    }

    /**
     * 字符输入流方式一：使用指定大小的字符数组输入
     */
    public static void reader1(){
        File f = new File("c:\\fuck\\javaTest1.txt");
        try {
            Reader in = new FileReader(f);
            char[] cs = new char[10];
            int len = -1;
            StringBuilder sb = new StringBuilder();
            while((len=in.read(cs))!=-1){
                sb.append(new String(cs,0,len));
            }
            in.close();
            System.out.println(sb);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * 使用字节流读取文本文件
     */
    public static void byteReader(){
        File f = new File("c:\\fuck\\javaTest1.txt");
        try {
            InputStream in = new FileInputStream(f);
            byte[] bs = new byte[10];
            int len = -1;
            StringBuilder sb = new StringBuilder();
            while((len=in.read(bs))!=-1){
                sb.append(new String(bs,0,len));
            }
            in.close();
            System.out.println(sb);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

/**
 * 字符流：底层也是用字节流实现的
 * ：根据指定的编码，将1个或多个字节转化为java里的unicode字符，然后进行操作
 * 字符操作一般用Writer,Reader等，字节操作一般用InputStream,OutputStream以及各种包装类，比如：
 * BufferedInputStream和BufferedOutputStream等
 * 总结：如果你确认你要处理的流是可打印的字符，那么使用字符流会简单些，如果不确认，那么用字节流总是不会错的。
 */
public class Main {

    public static void main(String[] args) {
        //byteReader(); //输出一堆乱码
        reader1();
        System.out.println("finished.");
    }

    /**
     * 字符输入流方式一：使用指定大小的字符数组输入
     */
    public static void reader1(){
        File f = new File("c:\\fuck\\javaTest1.txt");
        try {
            Reader in = new FileReader(f);
            char[] cs = new char[10];
            int len = -1;
            StringBuilder sb = new StringBuilder();
            while((len=in.read(cs))!=-1){
                sb.append(new String(cs,0,len));
            }
            in.close();
            System.out.println(sb);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * 使用字节流读取文本文件
     */
    public static void byteReader(){
        File f = new File("c:\\fuck\\javaTest1.txt");
        try {
            InputStream in = new FileInputStream(f);
            byte[] bs = new byte[10];
            int len = -1;
            StringBuilder sb = new StringBuilder();
            while((len=in.read(bs))!=-1){
                sb.append(new String(bs,0,len));
            }
            in.close();
            System.out.println(sb);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

/**
 * 指定一个盘符下的文件，把该文件复制到指定的目录下。
 */
public class Main {

    public static void main(String[] args) {
        copyFile("c:\\fuck\\javaTest1.txt","c:\\fuck\\javaTest2.txt");
        copyFile("c:\\fuck\\ning.bmp","c:\\fuck\\ning2.txt"); //把.txt改成.bmp就可以看了
        System.out.println("finished.");
    }

    public static void copyFile(String src,String des){
        File f1 = new File(src);
        File f2 = new File(des);
        InputStream in = null;
        OutputStream out = null;
        try {
            in = new FileInputStream(f1);
            out = new FileOutputStream(f2);
            byte[] bs = new byte[105];
            int len = -1;
            while((len=in.read(bs))!=-1){
                out.write(bs,0,len);
            }

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally{
            try {
                in.close();
                out.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

    }
}

/**
 * 转换流：将一个字节流转换为字符流，也可以将一个字符流转换为字节流
 * OutputStreamWriter：可以将输出的字符流转换为字节流的输出形式，可使用指定的charset将要写入流
 *                     中的字符编码成字节。
 * InputStreamReader：将输入的字节流转换为字符流输入形式，使用指定的charset读取字节并将其解码为
 *                    字符。
 */
public class Main {

    public static void main(String[] args) {
        //writer();
        reader();
        System.out.println("finished.");
    }

    public static void writer(){ //把字符流转成字节流
        try {
            OutputStream out = new FileOutputStream("c:\\fuck\\javaTest1.txt");
            String info = "你好吗abc.";
            Writer w1 = new OutputStreamWriter(out); //通过字节输出流构造一个字符输出流
            w1.write(info);

            w1.close();
            out.close();
        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static void reader(){ //把字节流转成字符流
        try {
            InputStream in = new FileInputStream("c:\\fuck\\javaTest1.txt");
            Reader r1 = new InputStreamReader(in);
            char[] cs = new char[105];
            int len = -1;
            StringBuilder sb = new StringBuilder();
            while((len=r1.read(cs))!=-1){
                sb.append(new String(cs,0,len));
            }
            r1.close();
            in.close();
            System.out.println(sb);

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}