黑马程序员--java基础--io流（2）

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

 

目录：1、File概述 2、递归3、Properties类 4、管道流

1、File类概述

File类常见方法：

1，创建

boolean creatNewFile();在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

static File   createTempFile(String prefix,String suffix)在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。

static File   createTempFile(String prefix,String suffix，File directory)在指定文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。和输出流不一样，输出流对象一建立创建文件，而且文件已经存在，会覆盖

boolean mkdir();创建文件夹

boolean mkdirs();创建多级文件夹

2，删除

boolean delete():删除失败返回false

void deleteOnExit();在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。在程序退出时删除指定文件

3，判断

boolean compareTo(File pathname)按字母顺序比较两个抽象路径名。

boolean exists():文件是否存在

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

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

isHidden();/测试此文件是否是一个隐藏文件。

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

4，获取信息

getName();获取名称

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

getParent();返回此抽象路径名父目录的路径名字符串，如果此路径名没有指定父目录，则返回null.

getParentFile()返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回null.

getAbsolutePath();返回的是绝对路径名字符串

getAbsoluteFile();返回绝对路径名形式

long  length()返回由此抽象路径名表示的文件的长度。

long  lastModified() 返回最后一次被修改的时间。

示例

import java.io.*;  
public class FileDemo {  
    public static void main(String[] args) throws IOException  
    {   method_2();  
        method_1();  
        consMethod();  
    }  
    public static void method_5()throws IOException  
    {  
        File f=new File("c:\\text.java");  
        File f1=new File("d:\\haha.java");  
        System.out.println("rename:"+f.renameTo(f1));//将f的名称换成f1的。   
    }  
    public static void method_4()throws IOException  
    {  
        File f=new File("d:\\abc\\file1.txt");  
            System.out.println("path:"+f.getPath());//封装什么就是什么   
             System.out.println("abspath"+f.getAbsolutePath());//不论是什么都是绝对的。   
             System.out.println("parent"+f.getParent());//该方法返回的是绝对路径中的父目录，如果获取的是相当路径，返回的是null   
         //如果相对路径中有上一层目录，那么该目录返回结果。   
    }  
      
    public static void method_3() throws IOException  
    {  
        File f=new File("file.txt");  
                //f.createNewFile();结果是文件是真，目录是假   
        f.mkdir();//结果是目录是真，文件是假。   
        //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在   
        //通过exists判断   
        System.out.println("dir:"+f.isDirectory());  
        System.out.println("file:"+f.isFile());  
        System.out.println(f.isAbsolute());//绝对路径的判断   
    }  
    public static void method_2()  
    {     
        File f=new File("file.txt");  
                //System.out.println("exists:"+f.exists());   
        //创建文件夹   
        File dir=new File("abc\\kkk");  
        System.out.println("mkdir:"+dir.mkdir());  
                //System.out.println("execute"+f.canExecute());测试应用程序是否可以执行此抽象路径名表示的文件。   
    }  
    public static void method_1() throws IOException  
    {     
        File f=new File("file.txt");  
        f.deleteOnExit();  
                //code();   
        System.out.println("creat:"+f.createNewFile());  
        System.out.println("delete:"+f.delete());  
          
    }  
      
            //创建File对象   
    public static void consMethod()  
    {  
        //将a.txt封装File对象，可以将已有的和未出现的文件或者文件夹封装成对象   
        File f1=new File("a.txt");  
        //   
        File f2=new File("c:\\abc"/*指定的父目录*/,"b.txt");  
        File d=new File("c:\\abc");/*封装目录*/  
        File f3=new File(d,"c.txt");  
        System.out.println("f1:"+f1);  
        System.out.println("f2:"+f2);  
        System.out.println("f3:"+f3);  
        File f4=new File("c:"+File.separator/*\\目录分隔符*/+"abc\\zzz\\a.txt");  
    }  
}  

2、递归

列出指定目录下文件或者文件夹，包含子目录中的内容，也就是列出指定目录下所有内容，因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话，还可以再次调用本功能。也就是函数自身调用自身，这种表现形式，或者编程手法，称为递归。

递归要注意：

    1，限定条件，

    2,要注意递归的次数，尽量避免内存溢出。

import java.io.File;

public class Testl {

     public static void main(String[] args) 					
     {
           File f=new File("D:jdk\\java");
            show(f);
			
			
     }
      public static void show(File f)
    {	
		
        File[]  f1= f.listFiles();
       for (int i = 0; i < f1.length; i++) 
        {	
	   if (f1[i].isDirectory()) 
        {
	   show(f1[i]); //如果是目录继续调用自己的方法。
         }						
             else
              System.out.println(f1[i]);
        }
		
 }
}

 

删除一个带内容的目录

删除原理：在window中，删除目录从里面往外删除的，既然是从里往外删除，就需要用到递归。java删除是不走回车站的。

 

import java.io.*;  
public class RemoveDir {  
    public static void main(String[] args) {  
        File dir=new File("d:\\testdir");  
        removeDir(dir);  
    }  
    public static void removeDir(File dir)  
    {   
        File[] files=dir.listFiles();  
        for(int x=0;x<files.length;x++)  
        {  
            if(files[x].isDirectory())  
                removeDir(files[x]);  
              
            System.out.println(files[x].toString()+":file:"+files[x].delete());  
        }  
        System.out.println(dir+"::dir::"+dir.delete());  
    }  
}  

练习 ：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中，建立一个java文件列表文件

思路：

     1，对指定的目录进行递归

    2，获取递归过程所有的java文件的路径

    3，将这些路径存储到集合中。

    4，将集合中的数据写入到一个文件中。

import java.io.*;  
import java.util.*;  
public class JavaFileList {  
    public static void main(String[] args) {  
        File dir=new File("d:\\java123");  
        List<File>list=new ArrayList<File>();  
        fileToList(dir,list);  
                  //System.out.println(list.size());   
        File file=new File(dir,"javalist.txt");  
        writerToFile(list,file.toString());  
    }  
    public static void fileToList(File dir,List<File> list)  
    {  
        File[] files=dir.listFiles();  
        for(File file:files)  
        {  
            if(file.isDirectory())  
                fileToList(file,list);  
            else  
            {  
                if(file.getName().endsWith(".java"))  
                    list.add(file);  
            }  
        }  
    }  
    public static void writerToFile(List<File>list,String javaListFile)  
    {  
        BufferedWriter bufw=null;  
        try {  
            bufw = new BufferedWriter(new FileWriter(javaListFile));  
            for (File f : list) {  
                String path = f.getAbsolutePath();  
                bufw.write(path);  
            }  
        } catch (IOException e) {  
            throw new RuntimeException();  
        }  
        finally{  
        try {     
                if(bufw!=null)  
                    bufw.close();  
            } catch (Exception e2) {  
                throw new RuntimeException();  
            }  
        }  
    }  
}  

3、Properties类 

Properties是Hashtable的子类， 也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串，不需要泛型。

是集合中和io技术相符合的集合容器

该对象的特点可以用于键值对形式的配置文件。

 那么在加载数据时，需要数据有固定格式：键=值，必须有键和值。

 void load(InputStream inStream)从输入流中读取属性列表（键和元素对）

void load(Reader reader)按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）

void loadFromXML（InputStream in）将指定输入流中由XML文档所表示的所有属性加载到此属性表中。

Object setProperty(String key,String value)调用的Hashtable方法put。

 Set(String) stringPropertyNames()返回此属性列表中的键集，其中该键及其对应值是字符串，如果是在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

import java.io.*;  
import java.util.*;  
public class PropertiesDemo {  
    public static void main(String[] args) throws IOException  
    {   loadDemo();  
             //method_1();   
             //setAndGet();   
    }  
        //load方法原理。   
    public static void loadDemo() throws IOException  
    {  
        Properties prop=new Properties();  
        FileInputStream fis=new FileInputStream("info.txt");//先关联一个文件。   
        //将流中的数据加载进集合   
        prop.load(fis);  
        prop.setProperty("wangwu", "34");//改变内存的方法，操作集合中的数据.Property加载的是键值对。   
        FileOutputStream fos=new FileOutputStream("info.txt");  
        prop.store(fos, "hah");  
                  //System.out.println(prop);   
        prop.list(System.out);//列出来   
        fos.close();  
        fis.close();  
    }  

4、管道流：

管道读取流和管道写入流可以像管道一样对接上，管道读取流就可以读取管道写入流写入的数据。

注意：需要加入多线程技术，因为单线程，先执行read，会发生死锁，因为read方法是阻塞式的，没有数据的read方法会让线程等待。

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

    PipedInputStream pipin = new PipedInputStream();

    PipedOutputStream pipout = new PipedOutputStream();

    pipin.connect(pipout);

    new Thread(new Input(pipin)).start();

    new Thread(new Output(pipout)).start();

}

对象的序列化：目的：将一个具体的对象进行持久化，写入到硬盘上。

注意：静态数据不能被序列化，因为静态数据不在堆内存中，是存储在静态方法区中。

如何将非静态的数据不进行序列化？用transient 关键字修饰此变量即可。

Serializable：用于启动对象的序列化功能，可以强制让指定类具备序列化功能，该接口中没有成员，这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid，可以在类中，手动指定一个名称为serialVersionUID id号。依据编译器的不同，或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。

import java.io.*;

class ObjectStreamDemo {

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

        writeObj();

        readObj();

    }

    public static void readObj()throws Exception{

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

        Object obj = ois.readObject();//读取一个对象。

        System.out.println(obj.toString());

    }

    public static void writeObj()throws IOException{

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

        oos.writeObject(new Person("lisi",25)); //写入一个对象。

        oos.close();

    }

}

class Person implements Serializable{

    private static final long serialVersionUID = 42L;

    private transient String name;//用transient修饰后name将不会进行序列化

    public int age;

    Person(String name,int age){

        this.name = name;

        this.age = age;

    }

    public String toString(){

        return name+"::"+age;

    }

}

                                                                                                                                   

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