黑马程序员_学习笔记IO流

——- android培训、java培训、期待与您交流！ ———-

IO流

IO流用来处理文件与内存，文件与文件，文件与网络，网络与内存之间的数据传输。
Java对数据的访问操作是通过流的方式, Java中用于操作流的对象都在java.io.*包中。

File类 文件操作类，表示文件对象或目录对象，可进行与文件本身有关的创建、删除文件等操作

File类字段摘要

static String pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。

static char pathSeparatorChar 与系统有关的路径分隔符。

static String separator 与系统有关的默认名称分隔符

static char separatorChar 与系统有关的默认名称分隔符

File类构造方法

File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(URI uri) 通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

File的相关方法

String getName():返回文件名或路径名（若是路径，返回最后一级子路径名）

String getPath():返回对象对应的路径名

File getAbsoluteFile():返回绝对路径

String getAbsolutePath():返回对象对应的绝对路径

String getParent():返回文件目录的上一级目录名

boolean renameTo(File newName):重命名此File对象对应的文件或目录，若重命名成功返回true;

boolean exists():判断对象对应的文件或目录是否存在；

boolean canWrite():判断对象对应文件或目录是否可写；

boolean canRead():判断对象对应文件或目录是否可读；

boolean isFile():判断对象是文件，不是目录；

boolean isDirectory() 判断对象的文件是否是一个目录；

boolean isAbsolute() 判断对象对应文件或目录是否为绝对路径名；

boolean createNewFile() 当且仅当不存在，该方法创建一个该File对象所指定的新文件，创建成功返回true。

boolean delete():删除File对象所对应的文件或路径；

boolean mkdir() 创建File对象所对应的目录，调用该方法的File对象必须对应路径，而不是文件。

String[] list():列出File对象的所有子文件名和路径名。

File[] listFiles():列出File对象的所有子文件和路径。

static File[] listRoots():列出系统所有的根路径；

import java.io.File;
import java.io.IOException;


public class Demo1 {


    public static void main(String[] args)throws IOException {


       File f = new File("E:/你好.txt");


       System.out.println(f.createNewFile());//false
       System.out.println(f.getName());//你好.txt
       System.out.println(f.getParent());//E:\
       System.out.println(f.length());//6905
    }
}

/*
    练习：列出文件夹下所有文件（包含子文件夹内）

    思路：本程序肯定要依靠递归的操作完成，因为在一个给定的路径下有可能还是文件夹，那么如果是文件夹的话则肯定要继续列出，重复判断。
    在使用递归时，必须有一个明确的递归结束条件，称为递归出口。
*/


import java.io.File;
public class Demo2 {


    public static void main(String[] args) {


       File f = new File("D:\\JAVA\\itheima");
       mylist(f);
    }


    public static void mylist(File f) {


       System.out.println(f);//先输出一下，因为不能确定接受来的文件是否是文件夹！


       if (f.isDirectory()) {
           File[] file = f.listFiles();
           for (File file2 : file) {
              mylist(file2);
           }


       }


    }


}

/*
    练习：删除一个目录（注意：要删除目录必须删除目录下的文件和子目录)
*/
import java.io.File;


public class Demo11 {


    public static void main(String[] args) {


       File f = new File("D:\\JAVA\\test");
       deleter(f);
       System.out.println("删除成功！");
    }


    public static void deleter(File f){
        if(!f.exists())
            return ;
       if(f.isFile()){
           f.delete();
       }else if(f.isDirectory()){
           File []file = f.listFiles();
           for (File file2 : file) {
              deleter(file2);//调用自身，递归！
                //删除子文件夹（内部没有文件的时候可以删除）
              file2.delete();
           }
       }
    }
}

/*
    使用文件过滤器，输出指定的文件。

    File 类里有方法： String[] list(FilenameFilter filter)   
     返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
    FilenameFilter(文件过滤器)该接口里包含accept(File dir,String name)方法，
    该方法依次对指定File的所有子目录，子文件夹进行迭代。
    dir - 被找到的文件所在的目录。name - 文件的名称。
    当且仅当该名称应该包含在文件列表中时返回 true；否则返回 false
*/



import java.io.File;
importjava.io.FilenameFilter;


class MyFilter implements FilenameFilter {


    private String ext;
    public MyFilter(String ext) {
       super();
       this.ext = ext;
    }


    @Override
    public boolean accept(File dir, String name) {
       return name.endsWith(ext);
    }
}


public class Demo3 {


    public static void main(String[] args) {


       File f = new File("D:\\JAVA\\itheima");
       File[] file = f.listFiles(new MyFilter(".txt"));
       for (File file2 : file) {
           System.out.println(file2);
       }
    }
}

流

数据流是一串连续不断的数据的集合,就像水管里的水流,在水管的一端一点一点地供水,而在水管的另一端看到的是一股连续不断的水流.
数据写入程序可以使一段一段地向数据流管道中写入数据,这些数据段会按先后顺序形成一个长的数据流.

在程序中所有的数据都是以流的方法进行传输和保存的。

Java 的IO是实现输入和输出的基础。
流的分类
按流动方向的不同可以分为输入流和输出流
从文件读取到内存中，，从网络读取到内存中，为输入流
从内存保存到文件，从内存发送到网络，为输出流

按处理数据的单位不同分为字节流和字符流；

按功能的不同可分为节点流和处理流；
节点流：直接操作目标设备，例如：磁盘或一块内存区域。
处理流：通过操作节点流,从而间接完成输入或输出功能的流。处理流是的存在是建立在一个已经存在的输入流或输出流的基础之上的。

所有流都继承于以下四种抽象流类型的某一种：
InputStream OutputStream
Reader Writer

流的操作步骤:

一、使用File类找到一个文件对象,得到io操作的源.
二、通过字节流或字符流的子类创建对象,(得到IO操作的通道)
三、进行读或写的操作.
四、关闭流(因为io本身不具有打开文件的能力，而是基于本地操作系统来进行文件的读写操作，占用一定的本地资源，所以使用完要关闭。

//构建输入流，读进来，输出到控制台！


import java.io.FileInputStream;
import java.io.InputStream;


public class Demo4 {


    public static void main(String[] args)throws Exception {
       //第一步：创建源!
       String filename = "test.txt";
       //第二步：创建管道！
       FileInputStream fis = new FileInputStream(filename);
       //第三步：操作！
       byte []buff = new byte[1024];//一般为1024的整数倍
       int len;//记录有效字节数
       while((len = fis.read(buff)) !=-1){


           System.out.println(new String(buff,0,len));
       }
       //第四步：关闭资源(字符流必须关闭资源，因为它中间有缓冲区！对于字节流可以不用关闭，但是还是建议写上，习惯！)
       fis.close();
    }
}

字节流和字符流

InputStream和Reader是所有输入流的基类，他们都是抽象类，本身不能创建实例，但是他们是所有输入流的模板。
一般来说处理文本文件时使用字符流，处理其他文件时使用字节流。能使用字符流就使用字符流。

注意：字符流必须关闭资源，因为它中间有缓冲区！而字节流不需要,但是一般（最后）都会关闭资源！

字节流和字符流的区别

字节流和字符流在使用上的代码结构都是非常类似的，但是其内部本身也是有区别的，因为在进行字符流操作的时候会使用到缓冲区（内存中），而字节流操作的时候是不会使用到缓冲区的。
字节输出流即使最后没有关闭内容也可以输出。但是如果是字符输出流的话，则如果不关闭，最后一条内容是无法输出的，因为所有的内容都是保存在了缓冲区之中。
如果现在字符流即使不关闭也可以完成输出的话，则必须使用flush()强制性清空缓冲区：

import java.io.File;
importjava.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class Demo6 {


    public static void main(String[] args) {
       File f = new File("test1.txt");
       readFile(f);
    }


    public static void readFile(File file){
        //创建文件输入流
       FileReader fr = null;
       try {
            //可能产生FileNotFoundException
           fr = new FileReader(file);
       } catch (FileNotFoundException e){
           e.printStackTrace();
       }
       char[] c = new char[1024];
       int len;
       try {
           while((len = fr.read(c)) != -1){
              System.out.println(new String(c,0,len));
           }
       } catch (IOException e) {
           e.printStackTrace();
       }


       try {
            //关闭资源时可能发生异常
            if(fr==null)
                fr.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
    }
}

/*
    需求： 文件拷贝


*/


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


public class Demo8 {


    public static void main(String[] args)throws IOException {
       File src = new File("d:\\java\\test.txt");
       File des = new File("d:\\java\\copyTest.txt");
       copy(src, des);
    }


    public static void copy(File src, File des)throws IOException {
         //java7开始的自动关闭资源
       try (FileInputStream fis =new FileInputStream(src);
              FileOutputStream fos = new FileOutputStream(des);) {
           byte[] buf = new byte[1024];
           int len=0;
           while ((len = is.read(b)) != -1){
              os.write(b,0,len);
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
    }
}

/**
 * 题目：复制图片！
 *
 * 图片是二进制文件，所以使用字节流！
 *  
 */





import java.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;


public class Demo7 {


    public static void main(String[] args) throws Exception {


       File src = new File("D:\\java.jpg");
       File des = new File("D:\\copyjava.jpg");
       copyFile(src,tar);
    }


    public static void copyFile(File src,File des) throws Exception{


       /*if(!src.exists()){
           throw new Exception("对不起，源文件不存在！");
       }*/
       FileInputStream fin = new FileInputStream(src);
       FileOutputStream fos = new FileOutputStream(tar);
       byte [] c = new byte[1024];
       int len=0;
       while((len = fin.read(c)) != -1){
           os.write(c,0,len);
       }


      fis.close();
      fos.close();


    }


}

字节字符转换流
字节字符转换流是字符流

OutputStreamWriter:把字节输出流对象转成字符输出流对象
InputStreamReader:把字节输入流对象转成字符输入流对象

FileWriter和FileReader分别是OutputStreamWriter和InputStreamReader的直接子类，而不是Writer和Reader的直接子类，
无论使用字节流还是字符流实际上在内存中最终都是通过字节的形式来操作流的。以并没有字符流转换字节流。

2、打印流 只有两个，PrintWriter和PrintStream

思考：如果现在要想完成一个字符串或者是boolean型或者是字符型的数据输出使用OutputStream是否方便？

肯定是不方便的，因为OutputStream中只能操作字节数据，所以其他的数据类型很难操作，那么在Java的IO包中为了解决这种问题增加了两种类：PrintStream、PrintWriter。

打印流有非常好的打印功能，可以打印任何的数据类型。如，整数，小数，字符串等。

3、格式化输出

Java5后，PrintStream类多了printf()方法用于格式化输出操作。但是格式化输出的时候必须指定输出数据的类型：
（构造方法）
PrintStream format(String fo, Object… args)使用指定格式字符串和参数将格式化字符串写入此输出流中。

需要格式 % 占位符

4、标准流

标准输入流: System.in 默认表示的是键盘录入
标准输出流: System.out 默认表示的是屏幕输出

import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintStream;


public class SyetemDemo {
    public static void main(String[] args)throws IOException {


       System.out.println("123456789");
       System.err.println("123652");//同样是一种输出流,打印出的是123652




       // static voidsetOut(PrintStream out) 重新分配“标准”输出流。


       System.setOut(new PrintStream("list.txt"));//重定向输出

       System.out.println("AAAA");
       System.out.println("BBBB");//就输出了在文件里


       int i = System.in.read();//接受从键盘输入的数据，写在最前面（没有任何重新分配）才有效

       System.out.println("i所对应的是：" + (char) i);//把它转换为字符型
       System.out.println(i);


       // 重新分配，由标准键盘输入变为由文件输入


       System.setIn(new FileInputStream("list.txt"));
       byte[] buff = new byte[1024];
       int len = 0;
       while ((len = System.in.read(buff)) != -1) {
           System.out.println(new String(buff, 0, len));//重新定义了由打印到屏幕上转换为打印到文件
       }
    }
}