IO-字节流

1GB=1024M
1M=1024KB
1KB=1024B
java.io.File类:可以描述文件或目录
　　构造函数:
　　　　File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
　　常用方法:
　　　　long getTotalSpace():分区的大小，以字节为单位；
　　　　file.getFreeSpace();获取分区中未分配的字节数。 ,以字节为单位
　　　　getPath():返回此对象表示的文件的相对路径名
　　　　String getAbsolutePath( ):返回此对象表示的文件的绝对路径名

public class TestFile {
    public static void main(String[] args) {
        File file = new File("C:");
        long totalSize = file.getTotalSpace();// 获取分区总大小,以字节为单位
        long freeSize = file.getFreeSpace();// 获取分区中未分配的字节数。 ,以字节为单位
        long usedSize = file.getUsableSpace();// 
        System.out.println("C盘总大小:"+(double)totalSize/1024/1024/1024+"GB");
        System.out.println("C盘可用空间:"+(double)freeSize/1024/1024/1024+"GB");
        System.out.println("C盘 已用空间:"+(double)usedSize/1024/1024/1024+"GB");
        File file2 = new File("C:\KFSoft\KFDialClient");
        if(file2.exists()){
            String path = file2.getPath();
            String path2 = file2.getAbsolutePath();
            System.out.println(path);
            System.out.println(path2);
        }
    }
}

编写一个程序，实现展现特定的文件夹及其子文件(夹)。（使用递归来做）

public class TestFile2 {
    public static void main(String[] args) {
        //编写一个程序，实现展现特定的文件夹及其子文件(夹)。（使用递归来做）
//        File file = new File("D:/test");
//        getFile(file);
        
    }
    public static void getFile(File file){
        //判断file是否为空,防止空指针异常
        if(file!=null){
            File[] fs = file.listFiles();//获取该文件下的所有子文件或目录
            for (File f : fs) {
                System.out.println(f.getAbsolutePath());
                if(f.isDirectory()){//判断是否为目录
                    getFile(f);//递归调用
                }
            }
        }
        
    }
    
    
}

Java流的分类:
　　1.按方向分为输入流和输出流(相对于计算机的内存来说,而不是相对于目标或源来说)
　　　　输入流: InputStream/Reader
　　　　输出流:OutputStream/Writer
　　2.按读写单位分为字节流(8位)和字符串流(16位)
　　　　字节流(字节输入流:InputStream和字节输出流OutputStream)
　　　　字符流(字符输入流:Reader和字符输出流Writer)
　　3.按功能分节点流和处理流
　　　　节点流:可以直接从数据源或目的地读写数据
　　　　处理流:（包装流）：不直接连接到数据源或目的地，是其他流进行封装。目的主要是简化操作和提高性能。

InputStream/OutputStream都是抽象类,不能实例化。
java.io.FileInputStream类继承了java.io.InputStream
　　常用的构造方法:
　　　　FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream
　　　　其中有一个检查异常需要捕获:FileNotFoundException
　　常用方法:
　　　　read():从此输入流中读取一个数据字节。 如果已到达文件末尾，则返回 -1 ,其中有一个检查异常需要捕获:IOException
　　　　close():其中有一个检查异常需要捕获:IOException
　　利用FileInputStream读取中文文本时出现乱码?
　　　　原因:中文汉字占用1个字符(2个字节)，FileInputStream每次读取1个字节，利用字符输入流解决

public class TestFileInputStream {
    //读取D:/aa.txt的文件内容
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis = new FileInputStream("D:/aa.txt");
            int len;
            //read():从输入流读取一个字节,如果已到达文件末尾，则返回 -1
            while((len=fis.read())!=-1){
                char c=(char)len;
                System.out.print(c);
            }
//            fis.close(); //关闭流应该放在try...catch..finally中的finally内，可以确保流被关闭
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                //关闭流：捕获IOException
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符串的构造函数
　　String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
　　String(byte[] bytes, int offset, int length)通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
　　构造函数:
　　　　FileInputStream(File file)
　　常用方法:
　　　　read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

public class TestFileInputStream2 {
    public static void main(String[] args) {
        File file = new File("D:/aa.txt");
        FileInputStream fis=null;
        try {
            //1.创建FileInputStream对象:将文件转换成文件字节输入流
            fis=new FileInputStream(file);//建立"管道"
            byte[] bs = new byte[1024];//缓冲区
            //2.使用read方法读取内容
            int len = fis.read(bs);//从此输入流中将最多 b.length 个字节的数据读入一个 byte数组中
//            for (byte b : bs) {
//                System.out.print((char)b);
//            }
//            String str = new String(bs);
            String str = new String(bs,0,len);
            System.out.println(str);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
        
    }
}

FileOutputStream类继承了OutputStream(抽象类)
　　构造函数:
　　　　FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。
　　　　FileOutputStream(String name, boolean append) 创建一个向具有指定 name 的文件中写入数据的输出文件流。
　　　　FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。。
　　　　FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流
　　注意:
　　　　1.FileOutputStream(File file)或FileOutputStream(String name)构造函数时 ，写入文件内容时会发生覆盖
　　　　2.FileOutputStream(File file,boolean append)或FileOutputStream(File file, boolean append)时，
　　　　　当append为true，会追加内容
　　　　3.FileOutputStream写入文件内容，如果文件不存在,将自动创建。
　　常用的方法:
　　　　write(byte[] b) 将 b.length 个字节从指定 byte 数组写入此文件输出流中。
　　　　write(int b) 将指定字节写入此文件输出流
　　　　write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
　　close() 关闭流

public class TestFileOutStream {
    public static void main(String[] args) {
        File file = new File("D:/cc.txt");
        FileOutputStream fos=null;
        try {
            //如果文件不存在,创建文件
//            if(!file.exists()){
//                file.createNewFile();//创建D:/bb.txt
//            }
            //创建FileOutputStream对象
//            fos = new FileOutputStream(file);
            fos = new FileOutputStream(file,true);//true:是否追加
//            fos.write('s');
//            fos.write('x');
//            fos.write('t');
//            String str="zzsxt,is very good!";
//            byte[] bs = str.getBytes();//将字符串转换为字节的数组
//            fos.write(bs);
            String str2="zzsxt,is very good!";
            byte[] bs2 = str2.getBytes();//将字符串转换为字节的数组
//            fos.write(bs2);
            fos.write(bs2,0,bs2.length);
            System.out.println("写入完毕!");
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
        
    }
}

文件复制:
　　将D:/bb.txt文件复制到F:/bb.txt中
　　步骤:
　　　　1.使用文件输入流读取D:/bb.txt
　　　　2.使用文件输出流写入到F:/bb.txt

public class FileCopy {
    public static void main(String[] args) {
        File source=new File("D:/bb.txt");//数据源
        File target=new File("F:/bb.txt");//目的地
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //1.读取文件
            //创建字节文件输入流(读文件)和输出流(写内容)
            fis = new FileInputStream(source);
            fos = new FileOutputStream(target);
            int len;
            //使用循环读取文件内容
            while((len=fis.read())!=-1){
                //将读取文件内容写入目标文件中
                fos.write(len);
            }
            System.out.println("文件复制完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                //关闭流
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
        
    }
}

需求:将D盘下的"TreeSet.png"复制到当前项目下

public class FileCopy2 {
    public static void main(String[] args) {
        File source  = new File("D:/TreeSet.png");
//        File target  = new File("F:/workspaces/ioDemo/TreeSet.png");
        File target  = new File("TreeSet.png");//相对路径(当前项目的路径)
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            fis = new FileInputStream(source);
            fos = new FileOutputStream(target);
//            //通过输入流读取图片信息 
            byte[] bs = new byte[1024];
            int len;
            while((len=fis.read(bs))!=-1){
                fos.write(bs,0,len);
            }
//            int len;
//            while((len=fis.read())!=-1){
//                fos.write(len);
//            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
}