IO流

java.io.File类：文件和路径名的抽象表示形式，与平台无关

File能新建、删除、重命名文件和文件夹，单file不能访问文件的内容，如果需要访问文件的内容，则要使用输入、输出流

file可以作为参数传递给流的构造函数

 

File的常用构造函数：

 

File的常用方法：

查看文件的属性：

 

 验证文件、文件夹是否存在：

获取文件、文件的信息

 

 与文件相关的操作

 

与目录相关的操作

 

 

java io的原理：

IO流用来处理设备之间的数据传输

在java程序中，对于数据的输入、输出操作以流的方式进行

java.io包下提供了各种的类和接口，以获取不同种类的数据，并通过标准的方法进行输入、输出操作

 

输入InputStream、Reader：读取外部的数据（磁盘、光盘等外部设备的数据）到程序（内存中）

输出OutputStream、Writer：将程序（内存）中的数据输出到磁盘、光盘等外部设备

 

流的分类：：

按操作数据单位的不同分为：字节流（8个字节）、字符流（16个字节）

按数据的流向分为：输入流、输出流

按流的角色不同：节点流，处理流

 

 

 InputSteam和Reader是输入流的基类

InputStream

public void fileInputStream() throws Exception {

        // 1.创建一个File类的对象。
        File file = new File("hello.txt");

        // 2.创建一个FileInputStream类的对象
        FileInputStream fis = new FileInputStream(file);

        // 3.调用FileInputStream的方法，实现file文件的读取。
        /*
         * read():读取文件的一个字节。当执行到文件结尾时，返回-1
         */
        // int b = fis.read();
        // while(b != -1){
        // System.out.print((char)b);
        // b = fis.read();
        // }


        int b;
        while ((b = fis.read()) != -1) {
            System.out.print((char) b);
        }

        // 4.关闭相应的流
        fis.close();
    }

 

public void  fileOutputStream() {
        // 1.创建一个File对象，表明要写入的文件位置。
        // 输出的物理文件可以不存在，当执行过程中，若不存在，会自动的创建。若存在，会将原有的文件覆盖
        File file = new File("hello2.txt");

        // 2.创建一个FileOutputStream的对象，将file的对象作为形参传递给FileOutputStream的构造器中
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            // 3.写入的操作
            fos.write(new String("I love China！").getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 4.关闭输出流
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

public void copy() {
        // 1.提供读入、写出的文件
        File file1 = new File("");
        File file2 = new File("");
        // 2.提供相应的流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            // 3.实现文件的复制
            byte[] b = new byte[20];
            int len;
            while ((len = fis.read(b)) != -1) {
                // fos.write(b);//错误的写法两种： fos.write(b,0,b.length);
                fos.write(b, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }

 

 

 

 

Reader

 

public void fileReader(){
        FileReader fr = null;
        try {
            File file = new File("");
            fr = new FileReader(file);
            char[] c = new char[24];
            int len;
            while((len = fr.read(c)) != -1){
                String str = new String(c, 0, len);
                System.out.print(str);
            }
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

 

 OutputStream

 

 

因为字符流直接以字符进行操作单位，所以Writer可以用字符串来替换字符数组，即以String作为参数

 

public void  fileReaderWriter(){
        //1.输入流对应的文件src一定要存在，否则抛异常。输出流对应的文件dest可以不存在，执行过程中会自动创建
        FileReader fr = null;
        FileWriter fw = null;
        try{
            //不能实现非文本文件的复制
//            File src = new File("");
//            File dest = new File("");
            File src = new File("");
            File dest = new File("");
            //2.
            fr = new FileReader(src);
            fw = new FileWriter(dest);
            //3.
            char[] c = new char[24];
            int len;
            while((len = fr.read(c)) != -1){
                fw.write(c, 0, len);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

 

        /*
     * 实现字节流与字符流之间的转换：
     * 转换流：InputStreamReader  OutputStreamWriter
     * 编码：字符串  --->字节数组
     * 解码：字节数组--->字符串
     */
    @Test
    public void test1(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //解码
            File file = new File("dbcp.txt");
            FileInputStream fis = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(fis, "GBK");
            br = new BufferedReader(isr);
            //编码
            File file1 = new File("dbcp4.txt");
            FileOutputStream fos = new FileOutputStream(file1);
            OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
            bw = new BufferedWriter(osw);
            String str;
            while((str = br.readLine()) != null){
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
        }catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                
            }
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                
            }
        }
        
    }        

常见的字符编码：

ASCII：美国标准的信息交换码，用一个字节的7位表示

ISO-8859-1：拉丁码表，欧洲码表，用一个字节的8位表示

GB2312：中国的中文编码表

GBK：中国的中文编码表

Unicode：国际标准码，融合了多种文字，所有文字都用两个字节来表示，java语言使用的就是这个编码

UTF-8：最多使用3个字节来表示一个字符

转换流的编码使用：

可以将字符按指定格式的编码进行存储

可以对字符按指定格式的编码进行解读，有构造函数完成

标准的输入、输出流：

System.in和System.out分别代表了系统的标准输入和输出设备

System.in的类型是InputStream，System.out的类型是PrintStream

通过System.setIn()， System.setOut()方法对默认设备进行更改

public void demo(){
        BufferedReader br = null;
        try {
            InputStream is = System.in;
            InputStreamReader isr = new InputStreamReader(is);
            br = new BufferedReader(isr);
            String str;
            while(true){
                System.out.println("请输入字符串：");
                str = br.readLine();
                if(str.equalsIgnoreCase("e") || str.equalsIgnoreCase("exit")){
                    break;
                }
                String str1 = str.toUpperCase();
                System.out.println(str1);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
        }
    }