【常用API】之IO流

IO（Input Output）输入输出操作。

包：import java.IO.*;

主要针对当前电脑的物理磁盘，进行目录或文件的创建，删除，读写等等操作。

流：Stream
数据在数据源与程序之间，所经历的一个路径。
以程序为主：
程序--->数据源： 输出流 OutputStream
数据源--->程序： 输入流 InputStream

重要的对象：

File类：
针对路径和文件操作的

数据操作对象：
针对文件中数据内容读写操作的。（；流Stream）

分类：

基础流：按照单个字符进行操作，一个个操作。
高层流：会创建缓冲区域，可以一次性操作数据，
必须建立在 基础流之上。

字节：按照字节操作 --- 速度快，不支持特殊字符，比如中文
字符：按照独立字符操作 --- 速度慢，支持所有的特殊字符

输入：程序读取文件
输出：程序写文件

流 Stream：

基础：
FileInputStream 字节-输入流
FileOutputStream 字节-输出流
FileReader 字符-输入流
FileWriter 字符-输出流

高层：
BufferedInputStream 缓冲-字节-输入流
BufferedOutputStream 缓冲-字节-输出流
BufferedReader 缓冲-字符-输入流
BufferedWriter 缓冲-字符-输出流

所有的流对象 Stream，在文件操作完毕后，必须执行：close()，关闭。

输入流不关闭：文件挂起。

输出流不关闭：容易导致文件没有写入结尾，破损文件。

---

--File_路径与文档操作

package com.xzm.test;

//导入IO流操作的依赖包文件
import java.io.*;


public class _01_File_路径与文档操作 {

    public static void main(String[] args) {
        
        // File类：
        // 针对物理磁盘的目录(文件夹)和文件进行创建，删除，重命名等操作的
        
        
        
        //实例化创建文档对象
        //必须参数化构造方法，指定路径，文件，后缀
        
        //【目录】
        File f = new File("C:/aaa");
        
        //判断指定的对象，是否是一个目录(有没有)
        if( f.isDirectory() )
        {
            System.out.println("是的，存在的。");
        }
        else
        {
            System.out.println("不是，不存在。");
        }
        
        //如果不是目录，
        if(!f.isDirectory()) {
            //创建它
            if( f.mkdirs() ) {
                System.out.println("创建成功！");
            }
            else {
                System.out.println("无法操作或无权限，请联系管理员！");
            }
            
        }
        
        
        //判断目录或文件是否是存在
        if( f.exists() ) {
            System.out.println("存在的");
        }
        else {
            System.out.println("不存在");
        }
        
        //===============================================
        
        //【文件】
        // 默认只能读写操作记事本可以操作的文件类型
        // 特殊文件格式，需要下载导入特定的扩展包：word
        File ff = new File("C:/aaa/aaa.txt");
        
        
        //判断是否存在，是不是文件
        if( ff.exists() ) {
            System.out.println("存在");
        }
        else {
            System.out.println("不存在");
        }
        
        if( ff.isFile() ) {
            System.out.println("是-存在");
        }
        else {
            System.out.println("不是-不存在");
        }
        
        
        //没有就创建
        if(!ff.isFile()) {
            try {
                ff.createNewFile();
            } catch (IOException e) {
                //写文件失败：【无权限】
                e.printStackTrace();
            }
        }
        
        
        //针对文件：重命名+剪切。
        //第一步：创建新文档
        File newF = new File("C:/aaa/12345.txt");
        ff.renameTo(newF);
        
        
        //获取各种参数:【目录】【文件】
        System.out.println("名称：" + ff.getName());
        
        System.out.println("相对路径：" + ff.getPath());
        
        System.out.println("路径：" + ff.getAbsolutePath());
        
        System.out.println("大小：" + ff.length()+"kb");
        
        System.out.println("最后修改日期：" + ff.lastModified()+"时间戳");
        
        
        //=========================================================
        
        //删除目录
        // f:目录，  ff:文件
        
        //要删除目录，目录必须是空的
        if( f.delete() ) {
            System.out.println("删除成功！");
        }
        else {
            //没有对应的内容才可以删除
            System.out.println("失败，目录不是空的！");
        }
        
        
        if( ff.delete() ) {
            System.out.println("删除成功！");
        }
        else {
            System.out.println("失败 - 文件被挂起！");
        }
        
        
        

    }

}

----File遍历目录

package com.xzm.test;

import java.io.File;
import java.util.Scanner;

public class _03_File_遍历目录 {

    public static void main(String[] args) {
        
        //实例化对象，指定目标
        File f = new File("C:/aaa");
        
        //调用方法 .listFiles()，返回一个File对象的数组
        //就是当前指定目标下的内容
        File[] list = f.listFiles();
        
        //循环遍历
        for(File item : list) 
        {
            //目录
            if(item.isDirectory()) {
                System.out.print("目录---");
            }            
            //文件
            if(item.isFile()) {
                System.out.print("文件---");
            }    
            //名称
            System.out.println(item.getName());
        }
        
        //==================================================
        //自定义代码，递归遍历整个指定的目录下所有内容
        
        //跨越操作系统，直接操作物理磁盘的
        //因此，Windows系统设置的隐藏效果等，
        //只是Windows的一个标识，不显示而已，
        //对于这里的代码，无效的。
        
        
        
        //第一步：创建File对象，指定目标
        //          目标是一个字符串，可以由用户输入的
        System.out.print("请输入目标：");
        File dir = new File(new Scanner(System.in).next());
        
        //第二步：调用递归方法，传入目标源
        digui(dir);
    }

    
    //递归函数
    public static void digui(File dir) {
        
        //获取传入对象下的列表
        File[] list = dir.listFiles();
        
        //迭代循环
        // 里面的异常处理，是跨过受保护的文件，不允许读取预览的
        for(File item : list)
        {
//            try {
                //目录
                if(item.isDirectory()) {
                    //输出信息，
                    System.out.println("目录---"+item.getName());
                    //递归继续找下一级
                    digui(item);
                }            
                //文件
                if(item.isFile()) {
                    //输出信息，
                    System.out.println("文件---"+item.getName());
                }
//            }
//            catch(Exception ex) {
//                continue;
//            }
        }        
    }
    
    
    
    
    
    
    
    
    
}

----基础-字节流

package com.xzm.test;

//导入io需要的依赖包文件
import java.io.*;

public class _04_基础_字节流 {

    public static void main(String[] args) {
        
        //基础 - 字节流
        //    FileInputStream    输入
        //  FileOutputStream   输出

        //基础流是最基本的对象，按照 byte 字节的方式进行操作的
        //【不支持特殊字符：中文就是其中之一】
        
        //由于是字节操作：
        //    1、不能使用String，必须是一个个 独立的 char 去操作
        //    2、它可以操作任何文件：rar，jpg，mp3，mp4，.....
        
        //【读写速度快，不支持特殊字符，支持任何类型文件】
        
        
        try {
            inputFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        
    }
    
    //===============================================
    
    //自定义方法，实现 基础-字节流写文档
    //【禁止方法中处理异常的】
    public static void outputFile() throws IOException {
        
        //声明文档对象
        File f = new File("C:/aaa/myfile.txt");
        
        //判断：创建
//        if(!f.isFile()) {
//            f.createNewFile();
//        }
        
        //创建基础字节输出流对象
        //必须建立在一个指定的File对象上面。
        //如果有文件，打开文件
        //如果没有文件，自动创建，再打开文件
        FileOutputStream fos = new FileOutputStream(f);
        
        
        //定义写入内容:不支持中文
        //程序中，换行 

        //文档中：换行 
 
        String str = "abcd
ABCD-这里中文。";
        
        
        //只能使用char类型写入
        for(int i=0; i<str.length(); i++) 
        {
            //从字符串中提取指定字符
            char cr = str.charAt(i);
            
            //写入文件
            fos.write(cr);
        }
        
        
        //【重点】：关闭流
        fos.close();
        
    }
    
    
    
    
    //自定义方法，实现 基础-字节流读文档
    public static void inputFile() throws IOException {
        
        //创建File对象--数据源
        File f = new File("C:/aaa/myfile.txt");
        
        //声明基础字节输入流
        //【强制异常处理：属于检查异常checkedException】
        //【文件不存在】
        FileInputStream fis = new FileInputStream(f);
        
        
        //读取文件
        //按照字节方式去读取， f.length() 文件大小就是字节的
        //方法：.read()，每一次读取一个，
        //        返回ASCII码，没有：-1
        //        每当读取一个之后，自动移动到下一个
        while(true)
        {
            //读取，获取ascii
            //【强制异常：无权限】
            int ascii = fis.read();
            
            if(ascii == -1) {
                break;//读取完毕
            }
            else {
                //把ascii转换成char字符
                System.out.print( (char)ascii );
            }
            
        }
        
        
        //【重点】：关闭流
        fis.close();
        
        
        
        
        
        
        
    }
    
    
    
    
    
    

}

----基础字符流

package com.xzm.test;

import java.io.*;

public class _05_基础_字符流 {

    public static void main(String[] args) {
        
        //基础 - 字符流
        //    FileReader    输入
        //  FileWriter    输出

        //基础流是最基本的对象，按照 独立字符的方式操作的
        //【支持特殊字符，是一个个字去操作的】
        
        //由于是字符操作：
        //    1、不能使用String，必须是一个个 独立的 char 去操作
        //    2、只能用于文件中的文本内容
        
        //【读写速度慢，支持特殊字符】

        
        try {
            readerFile();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
    }

    //==========================================
    
    //基础字符输出流
    public static void writerFile() throws IOException {
        
        //数据源对象
        File f = new File("C:/aaa/myfile.txt");
        
        
        //可以单独判断然后创建，例子中不用了
        
        
        //创建字符输出流
        //【强制异常处理】
        //有：打开， 没有：创建再打开
        FileWriter fw = new FileWriter(f);
        
        
        //直接写入内容 - 替换原有的
        //支持String
        fw.write("今天已经是星期三咯，
今天学习IO内容！");
        
        
        //支持追加写入
        //【只能已char类型追加】        
        fw.append('
');
        fw.append('
');
        fw.append('好');
        fw.append('☺');
        
        
        //【关闭】
        fw.close();
        
        
    }
    
    
    
    //基础 字符输入
    public static void readerFile() throws IOException {
        
        //数据源对象
        File f = new File("C:/aaa/myfile.txt");
        
        //输入流对象
        FileReader fr = new FileReader(f);
        
        //也是一个个文字读取，获取ascii
        while(true)
        {
            //读取，得到ascii
            int ascii = fr.read();
            //判断
            if(ascii==-1) {
                break;//结束
            }
            else {
                System.out.print( (char)ascii );
            }
        }
        
        //关闭
        fr.close();
        
    }
    
    
    
    
    
    
    
    
    
}

----高层字节流

package com.xzm.test;

import java.io.*;

public class _06_高层_字节流 {

    public static void main(String[] args) {
        
        //高层流：Buffered：缓冲区域
        //默认操作的先至缓冲区，然后由缓冲区一次性操作。
        //有点：
        //    1、减少对物理磁盘的操作次数。

        try {
            bufferedout();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
            
    }
    
    //=====================================================
    
    //高层-字节输出
    public static void bufferedout() throws IOException {
        
        //数据源对象
        File f = new File("C:/aaa/111.txt");
        
        //基础流
        FileOutputStream fos = new FileOutputStream(f);
        
        //创建高层流
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        
        
        //输出写内容：字节-不支持中文
        String str = "abcdABCD";
        for(int i=0; i<str.length(); i++) {
            bos.write( str.charAt(i) );
        }
        
        //上面的内容，先写入缓冲区域，
        //然后由缓冲区去操作文件
        //我们可以清空缓冲区，继续使用这个对象的
        //清空缓冲
        //【注意】：
        // 在低版本的JVM中，上面的操作不会写入物理文件。
        // 必须调用这个方法，清空缓冲，才会写入物理磁盘。
        bos.flush();
        
        
        
        //关闭：【有顺序的】
        bos.close();//高层
        fos.close();//基础
        
        
        
    }
    
    
    //高层 - 字节输入
    public static void bufferedinput() throws IOException {
        
        //数据源
        File f = new File("C:/aaa/111.txt");
        
        //基础流
        FileInputStream fis = new FileInputStream(f);
        
        //高层流
        BufferedInputStream bis = new BufferedInputStream(fis);
        
        //读取
        while(true) {
            //读取
            int ascii = bis.read();            
            //判断
            if(ascii==-1) {
                break;//结束
            }
            //输出
            System.out.print( (char)ascii );
        }
        
        //上面读取操作的内容，先记录到缓冲区
        //然后由缓冲区再呈现出来
        
        
        //关闭：【顺序】
        bis.close();//高层
        fis.close();//基础
        
        
    }
    
    
    
    
    

}

----高层字符流

package com.xzm.test;

import java.io.*;

public class _07_高层_字符流 {

    public static void main(String[] args) {
        
        //高层流：Buffered：缓冲区域
        //默认操作的先至缓冲区，然后由缓冲区一次性操作。
        //有点：
        //    1、减少对物理磁盘的操作次数。

        
        try {
            bufferedreader();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
    }

    //================================================
    
    //高层-字符，输出
    public static void bufferedwrite() throws IOException {
        
        //数据源
        File f = new File("C:/aaa/222.txt");
        
        //基础流
        FileWriter fw = new FileWriter(f);
        
        //高层流
        BufferedWriter bw = new BufferedWriter(fw);
        
        //直接创建
        //BufferedWriter bw2 = new BufferedWriter(new FileWriter(new File("C:/aaa/222.txt")));
        
        
        //写内容
        bw.write("这里是
高层字符输出流写的。");
        
        //追加：只能一个一个字符追加
        bw.append('☻');
        
        //清空缓冲区
        bw.flush();
        
        //关闭
        bw.close();
        fw.close();
        
    }
    
    
    //高层 - 字符，输入
    public static void bufferedreader() throws IOException {
        
        //一次性声明使用
        //就是上面三个独立声明的合并
        //减少变量操作
        BufferedReader br = new BufferedReader(new FileReader(new File("C:/aaa/222.txt")));
        
        
        //读取
        while(true) 
        {
            //支持一行一行读取的，没有了就是：null
            //默认是一个个读取，然后放入缓冲区
            //通过方法，从缓冲区拿出一行
            String str = br.readLine();
            
            //判断
            if(str==null) {
                break;//结束
            }
            
            //输出
            System.out.println(str);
            
        }
        
        //关闭
        // 由于没有基础流指定对象，
        // 当关闭高层流的时候，基础流也没有了
        br.close();
        
        
    }
    
    
    
}

---

java针对字符串操作，提供了两个对象：

StringBuilder：
单线程程序，非线程安全的，字符串操作对象。

StringBuffer：
多线程程序，线程安全的（锁），字符串操作对象。

创建一个内存对象，通过行为方法去操作内存中的数据。
始终只有这一个对象存在。

----StringBuilder类

package com.xzm.test;

public class _09_StringBuilder类 {

    public static void main(String[] args) {
        
        // StringBuilder：字符串操作对象
        // 单线程，非线程安全的
        
        //只创建一个对象，一个内存
        //都是通过方法去操作内存，不会产生多余的内存对象。
                
        //实例化对象
        StringBuilder sb1 = new StringBuilder();//空字符串
        StringBuilder sb2 = new StringBuilder("默认值");
        
        //组合内容:追加
        sb1.append("aaaaa");
        sb2.append("bbbbb");
        sb2.append('c');
        
        //String类有的方法，他全部都有。
        //多了新的方法
        
        //插入(索引,"内容")
        sb2.insert(3, "★★★★★");
        
        //删除指定索引的字符
        sb2.deleteCharAt(1);
        
        //删除一段：(开始索引，结束索引-1)
        sb2.delete(3, 6);
        
        //获取预览
        System.out.println(sb1);
        System.out.println(sb2);
        
        
        
        
        

    }

}

----StringBuffer类

package com.xzm.test;

public class _10_StringBuffer类 {

    public static void main(String[] args) {
        //与StringBuilder是一样的，只是里面的所有方法
        //都有锁机制，适合用于多线程
        
        
        //实例化对象
        StringBuffer sb1 = new StringBuffer();//空字符串
        StringBuffer sb2 = new StringBuffer("默认值");
        
        //组合内容:追加
        sb1.append("aaaaa");
        sb2.append("bbbbb");
        
        //String类有的方法，他全部都有。
        //多了新的方法
        
        //插入(索引,"内容")
        sb2.insert(3, "★★★★★");
        
        //删除指定索引的字符
        sb2.deleteCharAt(1);
        
        //删除一段：(开始索引，结束索引-1)
        sb2.delete(3, 6);
        
        //获取预览
        System.out.println(sb1);
        System.out.println(sb2);
        
        

    }

}