黑马程序员——IO流（二）

最新推荐文章于 2024-04-12 13:56:10 发布

原创最新推荐文章于 2024-04-12 13:56:10 发布 · 324 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了Java中的File类，包括创建、删除文件及文件夹的方法，判断文件存在的各种状态，获取文件信息等功能，并展示了如何使用File类进行文件列表操作及递归删除目录。

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

File类：

用来将文件或者文件夹封装成对象

方便对文件与文件夹的属性信息进行操作

File对象可以作为参数传递给流的构造函数

流只能操作数据 Flie可以对文件与文件夹的属性信息进行操作

separator:与系统有关的默认名称分隔符，为了方便它被表示为一个字符串

File类常见方法：

1.创建

boolean creatNewFile();

在指定位置创建文件，如果该文件已经存在，则不创建，返回false

和输出流不一样，输出流对象一建立就会创建文件，如果该文件已经存在会对原文件进行覆盖

import java.io.*;
 
class FileDemo {
    publicstatic void main(String[] args) throws IOException {
        method_1();
        //System.out.println("Hello World!");
    }
 
    publicstatic void method_1() throws IOException {
        Filef = new File("file.txt");
        System.out.println("creat:"+ f.createNewFile());
    }
}

boolean mkdir()：创建文件夹只能创建一级目录如果文件夹已存在则创建失败，返回false 而且

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

import java.io.*;
 
class FileDemo {
    publicstatic void main(String[] args) throws IOException {
        method_2();
    }
 
    publicstatic void method_2() {
        Filef = new File("file.txt");
        Filedir = new File("abc//cba");// 如果没有文件夹abc 则创建失败，返回false 只能创建一级文件夹
        System.out.println("mkdir:"+ dir.mkdir());
    }
}

2.删除

boolean delete();删除失败返回假

void deleteOnExit() 在程序退出时删除指定文件。

3.判断

boolean exists()：文件是否存在

boolean isFile() 是否是文件

boolean isDirectory() 是否是目录

boolean isHidden() 是否是隐藏

boolean isAbsolute() 是否是绝对路径

4.获取信息

getName()

getPath()

getParent() 该方法返回的是绝对路径中的父目录，如果获取的是相对路径返回null

如果相对路径中有上一层目录那么该目录就是返回结果

getAbsolutePath()

length()

lastModified()

import java.io.*;
 
class FileDemo {
    publicstatic void main(String[] args) {
        //consMethod();
        method_1();//第二次运行出现false
    }
 
    publicstatic void method_1() {
        Filef = new File("file.txt");
        sop("creat:"+ f.creatNewFile());// 创建指定文件
    }
 
    publicstatic void method_3()
   {
       File f = new File("file.txt")
       //记住在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在
       //通过exists判断
       sop(f.isFile());//打印为false  文件不存在
       sop(f.isDirectory());//打印为false
   }
 
    publicstatic void consMethod() {
        //将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象
        Filef1 = new File("c:\\abc\\a.txt");
        Filef0 = new File("a.txt");
 
        Filef2 = new File("c:\\abc", "b.txt");
 
        Filed = new File("c:\\abc");
 
        Filef3 = new File(d, "c.txt");
        sop("f1:"+ f1);// 打印 f1:c:\\abc\\a.txt
        sop("f0:"+ f1);// 打印 f1:a.txt
        sop("f2:"+ f2);// 打印 f2:c:\\abc\\b.txt
        sop("f3:"+ f3);// 打印 f3:c:\\abc\\c.txt
        //由于目录分隔符\\在不同系统中定义不同 因此可以用File.separator完成跨平台操作
        Filef4 = new File("c:" + File.separator + "abc" +File.separator + "zsc" + File.separator + "b.txt");
 
    }
 
    publicstatic void sop(Object obj) {
        System.out.println(obj);
    }
 
}

Flie对象功能--文件列表

import java.io.*;
 
class FileDemo2 {
    publicstatic void main(String[] args) {
        listRootsDemo();
        listDemo();
    }
 
    publicstatic void listRootsDemo() {
        File[]files = File.listRoots();
        for(File f : files) {
            System.out.println(f);//输出结果C:\ D:\ ...
        }
    }
 
    publicstatic void listDemo()
 {
     File f = new File("C:\\");
     String[] names = f.list();\\调用list方法的file对象必须是封装了一个目录 该目录还必须存在， 否则报错空指针异常
     for(String name ：names)
     {
           System.out.println(name);//输出结果为C盘目录下的所有文件名 包含隐藏文件
     }
 }
}

list(FilenameFilter filter)

返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

class List1 {
    publicstatic void main(String[] args)
   {
       File dir = new File("E:\Java练习");
       String[] arr = dir.list(new FilenameFilter()
       {
           public boolean accept(Filedir,String name)
           //System.out.println(dir+"---"+name);//测试dir（目录）和name（目录内文件名）是什么
           //if(name.endWith(".java"))
             // return true;
            //else
              //return false;
              returnname.endWith(".java");
       })
   }
}

listFiles()

返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

class ListFiles
{
   public static void main(String[] args)
   {
       File dir = new File("E:\\");
       File[] files = dir.listFiles();
       for(File f : files)
       {
           System.out.println(f.getName()+"---"+f.length());//文件夹大写无法获取
       }
   }
}

列出指定目录下文件或者文件夹，包含子目录中的内容

也就是列出指定目录下所有内容

因为目录中还有目录，只要使用同一个列出目录的功能的函数完成即可

在列出过程中出现的还是目录的话，还可以再次调用本功能

这种表现形式或者编程手法，称为递归

递归要注意的

1.限定条件

2.要注意递归的次数，避免内存溢出

import java.io.*;
class FileDemo3
{
   public static void main(String[] args)
   {
       File dir = new File("e:\\java练习")；
       showDir(dir);
       toBin(6);
   }
   public static void toBin(int num)
   {
       if(num>0)
       {
            toBin(num/2);//函数内调用函数
            System.out.println(num%2);
       }
   }
   
   public static void showDir(File dir)
   {
       System.out.println(dir);
       File[] files = dir listFiles();
       for(int x=0;x<files.length;x++)
       {
            if(files[x].isDirectory())
                showDir[Files[x]]
            else
                System.out.println(files[x])
       }
   }
}

列出目录下所有内容--带层次

import java.io.*;
 
class FileDemo3 {
    publicstatic void main(String[] args)
   {
       File dir = new File("e:\\java练习")；
       showDir(dir);
   }
 
    publicstatic String getLevel(int level)
   {
       StringBuilder sb = new StringBuilder();
       sb.append("|--")
       for(int x=0;x<level;x++)
       {
            sb.insert(0,"  ")
        }
        return sb.toString();
   }
 
    publicstatic void showDir(File dir,int level)
   {
       System.out.println(getLevel(level)+dir.getName());
       level++;
       File[] files = dir listFiles();
       for(int x=0;x<files.length;x++)
       {
            if(files[x].isDirectory())
                showDir[Files[x,level]]
            else
               System.out.println(getLevel(level)files[x])
       }
   }
}

删除一个带内容的目录

删除原理：

在window中，删除目录从里面往外删除的

既然是从里往外删除，就需要用到递归

import java.io.*;
 
class RemoveDir {
    publicstatic void main(String[] args)
   {
       File dir = new File("E:\\TEST")
       removerDir(dir);
   }
 
    publicstatic void removeDir(File dir)
   {
       File[] files = dir.listFiles();
       for(int x=0;x<files.length;x++)
       {
            if(files[x].isDirectory())
                removeDir(files[x]);
            eles
                //files[x].delete();
                System.out.println(files[x].toString()+"::"+files[x].delete());
       }
       System.out.println(dir+":dir:"+dir.delete());
   }
}

Properties 是hashtable的子类

也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串

是集合中和IO技术相结合的集合容器

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

在加载数据时，需要数据有固定格式：键=值

import java.io.*;
import java.util.*;
 
class PropertiesDemo {
    publicstatic void main(String[] args) throws IOException {
        setAndGet();
        method_1();
        loadDemo();
    }
 
    publicstatic void loadDemo() throws IOException {
        Propertiesprop = new Properties();
        FileInputStreamfis = new FileInputStream("info.txt");
        //将流中数据加载进集合
        prop.load(fis);
        //System.out.println(prop);
        FileOutputStreamfos = new FileOutputStream("info.txt");
        prop.store(fos,"haha");
        prop.list(System.out);
        fos.close();
        fis.close();
 
    }
 
    //演示，如何将流中数据存储到集合中
    //想要将info.txt中键值数据存储到集合中进行操作
    /*
     * 1.用一个流和info.txt文件关联 2.读取一行数据，将该行数据用“=”进行切割
     * 3.等号左边作为键，右边作为值，存入到Properties集合中即可
     */
    publicstatic void method_1() throws IOException {
        BufferedReaderbufr = new BufferedReader(new FileReader(info.txt));
        Stringline = null;
        Propertiesprop = new Properties();
        while((line = bufr.readLine()) != null) {
            String[]arr = line.split("=");
            prop.setProperty(arr[0],arr[1]);
 
        }
        bufr.close();
        System.out.println(prop);
    }
 
    //设置和获取元素
    publicstatic void setAndGet() {
        Propertiesprop = new Properties();
        prop.setProperty("zhangsan","30");
        prop.setProperty("lisi","40");
 
        //System.out.println(prop);
        Stringvalue = prop.getProperty("lisi");
        System.out.println(value);
 
        prop.setProperty("lisi",89 + "");
 
        Set<String>names = prop.stringPropertyName();
        for(String s : names) {
            System.out.println(s+ ":" + prop.getProperty(s));
        }
    }
}

IO包中的其他类

打印流

PrintWriter与PrintStream

可以直接操作输入流和文件

序列流

SequenceInputStream

对多个流进行合并

操作对象

ObjectInputStream与ObjectOutputStream

练习：文件分割程序

打印流：

该流提供了打印方法，可以将各种数据类型的数据都原样打印

字节打印流

PrintStream

构造函数可以接收的参数类型（需要记下）

1.file对象 File

2.字符串路径 String

3.字节输出流 OutputStream

字符打印流

PrintWriter

1.file对象 File

2.字符串路径 String

3.字节输出流 OutputStream

4.字符输出流 Writer

import java.io.*;
 
class PrintStreamDemo {
    publicstatic void main(String[] args) throws IOException {
        BufferedReaderbufr = new BufferedReader(new InputStreamReader(System.in));
 
        PrintWriterout = new PrintWriter(new FileWriter("E:\\Java练习\\a.txt", true));
 
        Stringline = null;
 
        while((line = bufr.readLine()) != null) {
            if("over".equals(line))
                break;
            out.println(line);
 
        }
        out.close();
        bufr.close();
    }
}

合并流

SequenceInputStream

构造方法摘要

SequenceInputStream(Enumeration<? extends InputStream> e)

SequenceInputStream(InputStream s1, InputStream s2)

import java.io.*;
import java.util.*;
 
class SequenceDemo {
    publicstatic void main(String[] args) throws IOException {
        //新建Vector对象
        Vector<FileInputStream> v = newVector<FileInputStream>();
        //将流对象添加到集合中
        v.add(newFileInputStream("e:\\Java练习\\1.txt"));
        v.add(newFileInputStream("e:\\Java练习\\2.txt"));
        v.add(newFileInputStream("e:\\Java练习\\3.txt"));
 
        //返回此向量的组件的枚举。返回到Enumeration中
        Enumeration<FileInputStream>en = v.elements();
 
        //如果需要传入2个以上的流对象SequenceInputStream(Enumeration<? extends InputStream>
        //e)可以实现
        //需要传入Enumeration 而Vector可以获取Enumeration
        //因此需要新建Vector对象
        SequenceInputStreamsis = new SequenceInputStream(en);
 
        FileOutputStreamfos = new FileOutputStream("e:\\Java练习\\4.txt");
 
        byte[]buf = new byte[1024];
 
        intlen = 0;
        while((len = sis.read(buf)) != -1) {
            fos.write(buf,0, len);
        }
        fos.close();
        sis.close();
 
    }
}

切割文件

import java.io.*;
import java.util.*;
 
class SplitFile {
    publicstatic void main(String[] args) {
        //splitFile();
        merge();
    }
 
    publicstatic void merge()
   {
       ArrayList<FileInputStream> al = newArrayList<FileInputStream>();
       
       for(int x=1;x<=5;x++)
       {
            al.add(newFileInputStream("e:\\Java练习\\"+(x++)+".part"))
       }
       
       Iterator it = al.iterator();
       
       Enumeration<FileInputStream> en = newEnumeration<FileInputStream>()
       {
            public boolean hasMoreElements()
            {
                return it.hasNext();
            }
            public FileInputStreamnextElement()
            {
                return it.next();
            }
       };
       
       SequenceInputStream sis = new SequenceInputStream(en);
       
       FileOutputStream fos = new FileOutputStream("e:\\Java练习\\1.mp3");
       
       byte[] buf = new byte[1024];
       
       int len = 0;
       
       while((len=sis.read())!=-1)
       {
            fos.write(buf,0,len)
       }
       fos.close();
       sis.close();
   }
 
    publicstatic void splitFile()
   {
       FileInputStream fis = new FileInputStream("e:\\Java练习\\0.mp3");
       
       FileOutputStream fos = null;
       
       byte[] buf = new byte[1024*1024];
       
       int len = 0;
       int x = 1;
       while((len=fis.read(buf))!=-1)
       {
            fos = newFileOutputStream("e:\\Java练习\\"+(x++)+".part")
            fos.write(buf,0,len);
            fos.close();
       }
       fis.close();
   }
}