黑马程序员---Java基础学习笔记IO

来源：互联网发布：两个数最小公约数c语言编辑：程序博客网时间：2024/04/28 13:58

------------Android培训、Java培训、期待与您交流------------

流对象：其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。

流的操作规律：

1，明确源和目的。

数据源：就是需要读取，可以使用两个体系：InputStream、Reader；

数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；

2，操作的数据是否是纯文本数据？

如果是：数据源：Reader

数据汇：Writer

如果不是：数据源：InputStream

数据汇：OutputStream

3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？

明确操作的数据设备。

数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)

数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。

4，需要在基本操作上附加其他功能吗？比如缓冲。

如果需要就进行装饰。

转换流特有功能：转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

转换流的最强功能就是基于字节流 + 编码表。没有转换，没有字符流。

发现转换流有一个子类就是操作文件的字符流对象：

InputStreamReader

|--FileReader

OutputStreamWriter

|--FileWrier

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。

FileReader fr = new FileReader("a.txt");

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");

以上两句代码功能一致，

如果仅仅使用平台默认码表，就使用FileReader fr = new FileReader("a.txt"); //因为简化。

如果需要制定码表，必须用转换流。

转换流 = 字节流+编码表。

转换流的子类File = 字节流 + 默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

[java] view plaincopyprint?
public class IOTest   
{  
    /* 
    public static void main(String[] args) throws IOException  
    { 
        //创建一个FileWriter对象，该对象一旦被初始化就必须要明确被操作的文件 
        //而且该文件会被创建到指定的目录下，如果该目录下已有同名文件，将被覆盖。 
        FileWriter fw = new FileWriter("iojava.txt"); 
        //调用write方法，将字符串写入到流中 
        fw.write("abcde"); 
        //刷新流对象中的缓冲流中的数据，将数据刷到目的文件中 
        //fw.flush(); 
        //关闭流资源，但是关闭之前会刷新一次内部缓冲流中的数据，将数据刷到目的文件 
        //flush刷新后，流可以继续使用，close刷新后，流将关闭无法使用。 
        fw.close(); 
    } 
    */  
    /* 
    //标准的IO异常处理程序 
    public static void main(String[] args) 
    { 
        FileWriter fw = null; 
        try 
        { 
            fw = new FileWriter("iojava01.txt"); 
            fw.write("abcdefg");//仅仅是写到数据流中，还没有写到目的文件中 
        } 
        catch (IOException e)  
        { 
            System.out.println(e.toString()); 
        } 
        finally 
        { 
            try  
            { 
                if(fw!=null)//避免空指针异常 
                fw.close(); 
            }  
            catch (IOException e)  
            { 
                System.out.println(e.toString()); 
            } 
        } 
    } 
    */  
      
    //对已有文件的数据续写  
    public static void main(String[] args) throws IOException   
    {  
        //传递true参数，代表不覆盖已存在的文件，并在已有文件末尾处续写数据  
        FileWriter fw = new FileWriter("iojava.txt" , true);  
        fw.write("haha\r\njava");// \r\n为Win中回车符  
        fw.close();  
    }  
}  

File类：将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。

File类常见方法：

1：创建。

boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。

boolean mkdir()：创建此抽象路径名指定的目录。

boolean mkdirs()：创建多级目录。

2：删除。

boolean delete()：删除此抽象路径名表示的文件或目录。

void deleteOnExit()：在虚拟机退出时删除。

注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。

window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。

3：获取.

long length()：获取文件大小。

String getName()：返回由此抽象路径名表示的文件或目录的名称。

String getPath()：将此抽象路径名转换为一个路径名字符串。

String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回null。

long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。

File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。

4：判断：

boolean exists()：判断文件或者文件夹是否存在。

boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。

boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。

boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。

5：重命名。

boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。

如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

[java] view plaincopyprint?
import java.io.File;  
import java.io.FilenameFilter;  
import java.io.IOException;  
  
public class FileClassDemo   
{  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
    public static void main(String[] args) throws IOException   
    {  
        //consMethod();  
        //createFile();  
        //deleteFile();  
        //executeFile();  
        //judgeFile();  
        //listRoots();  
        //listDemo();  
        //listDemo1();  
        //listFiles();  
        /* 
        //递归调用 
        File dir = new File("C:\\A"); 
        showDir(dir , 0); 
        */  
        toBinary(6);  
        //sop("num="+getSum(10));  
    }  
    //创建File对象  
    public static void consMethod()  
    {  
        //将iojava06.txt封装成为file对象，可以将已有的和未出现的  
        //文件或者文件夹封装成对象  
        File f = new File("iojava06.txt");  
        //File ff = new File("C:\\A\\ff.txt");  
        //将文件和目录分为两个参数来传递，好处是第二参数可变  
        File ff = new File("C:\\A" , "ff.txt");  
          
        File d = new File("C:\\A");  
        File fff = new File(d,"fff.txt");  
          
        File ffff = new File("C:"+File.separator+"A"+File.separator+"ffff.txt");  
        sop("f:"+f);  
        sop("ff:"+ff);  
        sop("fff:"+fff);  
        sop("ffff:"+ffff);  
    }  
      
    public static void createFile() throws IOException  
    {  
        File f = new File("file.txt");  
        sop("creat:"+f.createNewFile());  
        //在指定位置创建文件，若存在，则不创建返回false，和输出流不一样，后者对象  
        //一建立就会创建文件，而且若文件已存在则会覆盖。  
    }  
      
    public static void deleteFile() throws IOException  
    {  
        File f = new File("file.txt");  
        f.deleteOnExit();//在程序退出时删除指定文件  
        sop("delete:"+f.delete());  
    }  
      
    public static void executeFile() throws IOException  
    {  
        File f = new File("iojava04.txt");  
        sop("execute:"+f.canExecute());  
    }  
      
    public static void judgeFile() throws IOException  
    {  
        File f = new File("file.txt");  
        sop("creat:"+f.createNewFile());  
        sop("file:"+f.exists());//判断之前要明确是否存在  
        sop("dir:"+f.isDirectory());  
        sop("file:"+f.isFile());  
        sop(f.isAbsolute());//判断是否是绝对路径  
        sop(f.isHidden());//是否是隐藏文件  
          
        File ff = new File("C:\\A\\filecopy.txt");  
        sop("rename:"+f.renameTo(ff));  
    }  
      
    public static void listRoots()  
    {  
        File[] files = File.listRoots();//显示所有盘符  
        for(File f : files)  
        {  
            sop(f);  
        }  
    }  
      
    public static void listDemo()  
    {  
        File f = new File("C:\\");//C盘目录下所有的文件或者文件夹以及隐藏文件  
        String[] filenames = f.list();//当list访问的是一个文件是，则会返回null  
        for(String names : filenames)  
        {  
            sop(names);  
        }  
    }  
      
    public static void listDemo1()  
    {  
        File f = new File("C:\\A\\");  
        String[] filenames = f.list(new FilenameFilter()   
        {  
            public boolean accept(File dir, String name)   
            {  
                return name.endsWith(".txt");  
            }  
        });  
        for(String names : filenames)  
        {  
            sop(names);  
        }  
    }  
      
    public static void listFiles()  
    {  
        File dir = new File("C:\\A");  
        File[] files = dir.listFiles();  
        for(File f : files)  
        {  
            sop(f.getName()+"::"+f.length()+"K");  
        }  
    }  
      
    public static void showDir(File dir , int lv)  
    {  
        /* 
         * 列出指定目录下文件或者文件夹，包含子目录中的内容。 
         * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可 
         * 在列出工程中出现的还是目录的话，还可以再次调用本功能。 
         * 也就是函数自身调用自身，这就是递归 
         * 递归需要注意： 
         * 1.限定条件：需要有条件判断是程序能够停止 
         * 2.注意递归的次数，以防内存溢出。 
         */  
        sop(getLevel(lv)+dir.getName());  
        lv++;  
        File[] files = dir.listFiles();  
        for(int i = 0 ; i < files.length ; i++)  
        {  
            if(files[i].isDirectory())  
                showDir(files[i] , lv);  
            else  
                sop(getLevel(lv)+files[i]);  
        }  
    }  
    public static String getLevel(int lv)  
    {  
        StringBuilder sbr = new StringBuilder();  
        sbr.append("|--");  
        for(int i = 0 ; i < lv ; i++)  
        {  
            sbr.insert(0 , "|  ");  
        }  
        return sbr.toString();  
    }  
      
    public static void toBinary(int num)  
    {  
        //递归打印二进制  
        if(num>0)  
        {  
            toBinary(num/2);  
            System.out.print(num%2);  
        }  
    }  
    public static int getSum(int num)  
    {  
        //求和  
        if(num == 1)  
            return 1;  
        else  
        {  
            return num+getSum(num-1);  
        }  
    }  
}  

------------Android培训、Java培训、期待与您交流----------

0 0