Java基础——IO(2)

原创 2015年11月19日 16:43:36

File类

1.列出文件及文件过滤

/**
 * 练习:用String[] list(FilenameFilter filter)方法获取一个目录下所有的.java文件,
 * 其他文件不要。 
思路:1、FilenameFilter是一个过滤器接口,用匿名内部类传入filter对象 
          2、复写FilenameFilter接口的accept(File file,String name)方法,
          并判断name是否是java文件 
          3、遍历String类型数组 

 */
import java.io.File;
import java.io.FilenameFilter;

public class Test1 {

    public static void main(String[] args) {
        File file = new File("F:\\java");
        getJavaList(file);

    }

    private static void getJavaList(File file) {
        //传入FilenameFilter匿名内部类子类对象,并复写accept方法  
        String s[] = file.list(new FilenameFilter() {

            @Override
            public boolean accept(File dir, String name) {
                //判断文件名是否是以.java结尾  
                return name.endsWith(".java");
            }
        });
        System.out.println("文件长度:"+file.length());
        for(String ss : s ){
            System.out.println(ss);
        }
    }
}

2.获取信息

3.创建

递归

练习一:


/*
需求:列出指定目录下文件或文件夹,包含子目录,即列出指定目录下所有内容(带层次的)。

分析,因为目录中还有目录,只有使用同一个列出目录功能的函数完成即可,
在列出过程中出现的还是目录的话,还可以再调用本功能,这就是利用递归原理。

*/
import java.io.*;
public class  RecursionDemo
{
    public static void main(String[] args) 
    {
        //关联指定路径
        File dir=new File("F:\\java");

        //列出关联路径中所有的.java文件
        allFileList(dir,0);
    }

    //列出指定目录下的所以内容
    public static void allFileList(File dir,int level)
    {
        //有层次的输出
        System.out.println(getLevel(level)+dir);
        level++;
        File[] fileArr=dir.listFiles();//获取本目录下的所以文件和目录的抽象路径

        //遍历
        for (File file : fileArr)
        {
            //isDirectory() :测试此抽象路径名表示的文件是否是一个目录。
            if(file.isDirectory())
            {
                //如果目录下还是目录,则继续调用本函数
                allFileList(file,level);
            }
            else
                System.out.println(getLevel(level)+file);//显示(列出)文件
        }   
    }

    //带层次的列表
    public static String getLevel(int level)
    {
        StringBuilder sb=new StringBuilder();
        sb.append("|--");
        //每多一级目录,就多输出指定字符
        for (int x=level;x>0 ; x--)
        {
            //sb.append("|--");
            sb.insert(0,"|  ");
        }
        return sb.toString();
    }
}

练习二:


/*
删除一个带内容的目录。
删除原理:
在windows中,删除目录从里面往外面删除的。
既然是从里往外删除。就需要用到递归。

*/
import java.io.*;
public class RemoveDir 
{
    public static void main(String[] args) 
    {
        //指定目录
        File dir=new File("f:\\1");
        //删除目录
        removeDir(dir);

    }

    //删除传入目录
    public static void removeDir(File dir)
    {
        File[] files=dir.listFiles();//列出目录下的所以文件和文件夹
        //遍历
        for (File file : files )
        {
            //如果还是目录且非隐藏
            if(!file.isHidden()&&file.isDirectory())
                removeDir(file);//继续删除目录里的内容
            else
                System.out.println(file.toString()+":-file-:"+file.delete());//删除文件
        }
        System.out.println(dir+":::dir:::"+dir.delete());//删除目录
    }
}

练习三:


/*
练习:
将一个指定目录下的java文件的绝对路径,存储到一个文本文件中。建立一个java文件列表的文件。
思路:
     1、对指定的目录进行递归。
     2、获取递归过程所有的java文件的路径。
     3、将这些路径存储到集合中。
     4、将集合中的数据写入到一个文件中。
*/
import java.util.*;
import java.io.*;

public class  JavaFileList
{
    public static void main(String[] args) 
    {
        //指定目录
        File dir=new File("F:\\java");

        //定义一个List集合,用于存储.java文件的File对象
        List<File> list =new ArrayList<File>();

        //调用获取文件路径方法
        fileToList(dir,list);

        //指定写入文件
        File file=new File(dir,"javafilelist.txt");
        //调用写入文件方法
        writeToFile(list,file);

    }
    //获取指定文件夹内的所有java文件的绝对路径,并存入集合中
    public static void fileToList(File dir,List<File> list)
    {
        File[] files=dir.listFiles();//列出dir路径下的所以文件和目录,
        //遍历
        for (File file : files)
        {
            //如果是目录,则继续获取
            if(file.isDirectory())
            {
                list.add(file.getAbsoluteFile());//把父目录路径也存入
                fileToList(file,list);
            }
            //将是.java文件的绝对路径存入
            else if(file.getName().endsWith(".java"))
                list.add(file);
        }
    }

    //将集合中元素写入到一个文本文件中
    public static void writeToFile(List<File> list,File file)
    {

        BufferedWriter bw=null;

        try
        {   //使用字符流缓冲区对象关联写入的文件
            bw=new BufferedWriter(new FileWriter(file));
            for (File file0 : list )
            {
                bw.write(file0.getAbsolutePath());//写入
                bw.newLine();//换行
                bw.flush();//刷新
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("写入文件失败");
        }
        finally
        {
            try
            {
                if(bw!=null)
                    bw.close();//关流
            }
            catch (IOException e)
            {
                throw new RuntimeException("流资源关闭失败");
            }
        }
    }
}

Properties类

概述:

他是一个键值对形式,常用作配置文件。

最有特点的方法:

可以直接将键值对放到输入输出流之中

还可以放置到XML文件中

练习1:


//演示,如何将流中的数据存储到集合中。
    //想要将info.txt中键值数据存到集合中进行操作。
    /*
        1,用一个流和info.txt文件关联。
        2,读取一行数据,将该行数据用"="进行切割。
        3,等号左边作为键,右边作为值。存入到Properties集合中即可。

    */
        //将文件数据存储进Properties集合方法
public class Test2{
    public static void main(String[] args) throws IOException {
        method();
    }
    public static void method()throws IOException
    {
        //使用字符读取缓冲流关联文件
        BufferedReader bufr = new BufferedReader(new FileReader("d:\\info.txt"));

        String line = null;
        //定义Properties集合
        Properties prop = new Properties();

            while((line=bufr.readLine())!=null)
        {
            String[] arr = line.split("=");//将一行数据以“=”号进行分割
            //将=左边作为键存入,将=右边作为值存入
            prop.setProperty(arr[0],arr[1]);
        }

        bufr.close();//关流

        System.out.println(prop);
    }
}

打印流

一、概述

    1、打印流包括:PrintStream和PrintWriter

    2、该流提供了打印方法,可将各种类型的数据都原样打印。

二、字节打印流:PrintStream

构造方法中可接收的参数类型:

    1、File对象。File

    2、字符串路径:String

    3、字符输出流:OutputStream

三、字符串打印流:PrintWriter

构造方法中可接受的参数类型

    1、File对象:File

    2、字符串路径:String

    3、字节输出流:OutputStream

    4、字符输出流:Writer

序列流

一、概述

1、SequenceInputStream对多个流进行合并。也被称为合并流。

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始,并从第一个输入流开始读取,直到到达文件末尾,接着从第二个输入流读取,依次类推,直到到达包含的最后一个输入流的文件末尾为止。 

2、常用构造函数

    SequenceInputStream(Enumeration<?extends FileInputStream> e)

二、常见合并多个流文件步骤

    1、创建集合,并将流对象添加进集合

    2、创建Enumeration对象,将集合元素加入。

    3、创建SequenceInputStream对象,合并流对象

    4、创建写入流对象,FileOutputStream关联写入文件

    5、利用SequenceInputStream对象和FileOutputStream对象读数据进行反复读写操作。

P.S



import java.io.*;

import java.util.*;

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

        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for (int x = 1; x <= 3; x++) {
            al.add(new FileInputStream("d:\\IO\\"+x + ".txt"));
        }

        final Iterator<FileInputStream> it = al.iterator();

        Enumeration<FileInputStream> en = Collections.enumeration(al);
        /*
         * //Collections工具类的enumeration方法核心代码:
         *  Enumeration<FileInputStream> en =
         * new Enumeration<FileInputStream>(){ public boolean hasMoreElements(){
         * return it.hasMoreElements(); 
         * }
         * 
         * public FileInputStream nextElement(){ return it.next(); } 
         * };
         */

        SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("d:\\IO\\4.txt");

        byte[] buf = new byte[1024];

        int len = 0;

        while ((len = sis.read(buf)) != -1) {
            fos.write(buf, 0, len);
        }

        fos.close();
        sis.close();
    }
}

Serializable序列化接口

主要用于类的流操作

例:
将一个常规的类对象序列化的obj.object文件对象中去


public class ObjectStreamDemo {

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

        writeObj();
        readObj();
    }

    public static void readObj() throws IOException, ClassNotFoundException {

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\obj.object"));
        //对象的反序列化。 
        Person p = (Person)ois.readObject();

        System.out.println(p.getName()+":"+p.getAge());

        ois.close();

    }

    public static void writeObj() throws IOException, IOException {

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\obj.object"));
        //对象序列化。  被序列化的对象必须实现Serializable接口。 
        oos.writeObject(new Person("小强",30));

        oos.close();

    }

}

相关文章推荐

黑马程序员——Java基础----IO(字节流、操作规律等)(2)

-----------android培训、java培训、java学习型技术博客、期待与您交流!------------                                       ...

黑马程序员——Java语言基础——07.IO流(2)File类和其他流

------- android培训、java培训、期待与您交流! ---------- 2-1 File类 将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件...

Java基础知识之IO(2)

文件复制小案例(温习Java基础知识之IO(1)中的知识)package copy;import java.io.File; import java.io.FileInputStream; impor...

黑马程序员 Java基础<十>---> IO流<2>(File类,Properties,打印流,合并流)

-----------android培训、java培训、java学习型技术博客、期待与您交流! ------------ 第一节   File类 一、概述: 1、File类:文件...

黑马程序员 java基础<四>--IO流(2)

-------android培训、java培训、java学习型技术博客、期待与您交流! ----------                                       ...

java基础学习IO流之递归 十一 -2

递归: /** * @author Angus * 递归; 方法定义调用方法本身的现象 * 注意: * A;递归一定要有出口,否则就会死递归 * B:递归次数不能过多,否则内存溢出 *...
  • onceing
  • onceing
  • 2017年03月09日 09:52
  • 132

黑马程序员-江远云 我的java语言基础之路2-IO篇

---------------------- android培训、java培训、期待与您交流! ---------------------- Propertise 是hashtable的子...
  • isyue
  • isyue
  • 2012年03月14日 12:55
  • 1643

黑马程序员_Java基础_IO(2)

---------------------- Android、Java开发期待与您交流! ---------------------- 字节流和字符流         Java中对文件的读...

黑马程序员--Java基础之IO流(2)

Java基础之IO流(2) 10、IO流--Properties简述         properties 是hashtable的子类,它具备Map集合的特点,而且它里面存储的键值对都是字符串。它是集...

黑马程序员——Java基础---IO流(字符流、字节流、转换流、流操作规律)

简述: IO(Input Output) IO流用于处理设备之间的数据传输。(比如硬盘上的文件,内存中驻留的数据)IO流是用于操作数据的,数据的最常见体现形式是:文件。 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java基础——IO(2)
举报原因:
原因补充:

(最多只允许输入30个字)