【第22期】观点:IT 行业加班,到底有没有价值?

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基础-13--IO 2

--------------------- android培训 、 java培训 、 期待与您交流! ----------------------   1、  IO(...
  • okili
  • okili
  • 2014-06-05 16:30
  • 218

J2SE自学(三)——Java语法基础(一)

1、编写程序的目的是为了处理数据 2、数据用变量来表示 3、变量本质上就是计算机一块或多块内存空间 4、学习编程语言,不管java,c#还是其它,开始基础部分应该掌握什么知识了: 1)、知道这门语言给我们提供了那些数据类型,以及它的容积。 2)、如何声明一个相应数据类型的变量。 3)、如何给变量赋值和取值。 5、Java为我们提供了的数据类型如下: 基本数据类型(四类八种):byte、short、int、long、float、double、char、boolean 引用数据类型:类(class)、接口(interface)、数组

黑马程序员——Java基础之IO流

IO流   一、概述: IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包里 流按操作数据分为两种:字节流和字符流;[编码表的存在][汉字与1...

黑马程序员——Java基础之IO流(一)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------  一、<

java基础——文件(IO)操作2

一、System.in和 System.out   为了支持标准输入输出设备,Java定义了两个特殊的流对象:System.in 和System.out。   System.in: 对应键盘...
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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