day20 File类

最新推荐文章于 2023-05-16 19:16:21 发布

要努力啊要努力

最新推荐文章于 2023-05-16 19:16:21 发布

阅读量306

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/lotusws/article/details/55002137

版权

Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

<1 File类概述>

流：只能操作数据

package day20;

import java.io.File;

/**
 * Created by Administrator on 2017/2/12.
 */
public class FileDemo {
    public static void main(String[] args){
        consMethod();
    }

    //创建File对象
    public static void consMethod(){
        //将a.txt封装成file对象。可以将已有的和未出现的文件或文件夹封装成对象。
        File f = new File("a.txt");

        File f1 = new File("c:\\abc\\b.txt");
        File f2 = new File("c:\\abc", "b.txt");  //b.txt可以替换成字符串str

        File d = new File("c:\\abc");
        File f3 = new File(d, "b.txt");

        sop("f:" + f);   //封装的是什么，就打印什么。里面封装的是相对的，所以就打印出相对的a.txt
        sop("f1:" + f1);
        sop("f2:" + f2);
        sop("f3:" + f3);

        File f4 = new File("c:\\abc\\zz\\a.txt"); //这种分隔符 不利于跨平台
        File f5 = new File("c:" + File.separator + "abc" + File.separator + "zz" + File.separator + "a.txt"); //这句话到了LInux平台也可执行。会自动识别相应的分隔符

    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

<2 File对象功能：创建和删除>

package day20;

import java.io.File;
import java.io.IOException;

/**
 * File类常见方法：
 * 1.创建。
 *   boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
 *                            和输出流不一样，输出流对象一建立 就创建文件。而且文件已经存在，会覆盖。
 * 2.删除。
 *   boolean delete()：删除失败时，返回假
 *   void deleteOnExit()：在程序退出时，删除指定文件。
 *
 * 3.判断。
 *
 * 4.获取信息
 *
 * Created by Administrator on 2017/2/12.
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {

//        consMethod();
        method_1();
    }

    public static void method_1() throws IOException {
        File f = new File("file.txt");
//        sop("create: " + f.createNewFile());
        sop("delete: " + f.delete());
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

<3 File对象功能：判断>

package day20;

import java.io.File;
import java.io.IOException;

/**
 * File类常见方法：
 * 1.创建。
 *   boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
 *                            和输出流不一样，输出流对象一建立 就创建文件。而且文件已经存在，会覆盖。
 *   boolean mkdir()：创建文件夹
 *   boolean mkdirs()：创建多级文件夹。
 * 2.删除。
 *   boolean delete()：删除失败时，返回假
 *   void deleteOnExit()：在程序退出时，删除指定文件。
 *
 * 3.判断。
 *   boolean exists()：文件是否存在
 *   isFile()：
 *   isDirectory();
 *   isHidden();
 *   isAbsolute();
 *
 * 4.获取信息
 *
 * Created by Administrator on 2017/2/12.
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {

//        consMethod();
//        method_2();
        method_3();
    }

    public static void method_3() throws IOException {
        File f = new File("file.txt");

//        f.createNewFile();
        f.mkdir();

        //记住：在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在
        //通过exists判断。
        sop("dir: " + f.isDirectory());
        sop("file: " + f.isFile());

        sop(f.isAbsolute());
    }

    public static void method_2(){
        File f = new File("file.txt");
//        sop("exists: " + f.exists()); //先判断。免得抛异常。这就是把文件封装成File对象的好处
//        sop("execute: " + f.canExecute());

        //创建文件夹
        File dir = new File("abc\\kkk"); //目录abc必须得先存在
        sop("mkdir: " + dir.mkdirs());
    }



    public static void sop(Object obj){
        System.out.println(obj);
    }
}

<4 File对象功能：获取>

package day20;

import java.io.File;
import java.io.IOException;

/**
 * File类常见方法：
 * 1.创建。
 *   boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
 *                            和输出流不一样，输出流对象一建立 就创建文件。而且文件已经存在，会覆盖。
 *   boolean mkdir()：创建文件夹
 *   boolean mkdirs()：创建多级文件夹。
 * 2.删除。
 *   boolean delete()：删除失败时，返回假
 *   void deleteOnExit()：在程序退出时，删除指定文件。
 *
 * 3.判断。
 *   boolean exists()：文件是否存在
 *   isFile()：
 *   isDirectory();
 *   isHidden();
 *   isAbsolute();
 *
 * 4.获取信息
 *   getName():
 *   getPath():
 *   getParent():
 *
 *   getAbsolutePath():
 *   long laseModified()
 *   long length():
 *
 *
 * Created by Administrator on 2017/2/12.
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {

//        consMethod();
//        method_2();
//        method_3();
        method_4();
        method_5();
    }

    //类似文件移动
    public static void method_5(){
        File f1 = new File("c:\\Test.java");
        File f2 = new File("d:\\hahah.java");

        sop("rename: " + f1.renameTo(f2));
    }

    public static void method_4(){
        File f = new File("c:\\abc\\file.txt");

        sop("path: " + f.getPath());
        sop("abspath: " + f.getAbsolutePath());
        sop("parent: " + f.getParent()); //该方法返回的是绝对路径中的父目录。如果获取的是相对路径，则返回null。
                                         //如果相对路径中有上一层目录，那么该目录就是返回结果。
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

<5 File对象：文件列表 >

list(), listRoots()

package day20;

import java.io.File;

/**
 * Created by Administrator on 2017/2/13.
 */
public class FileDemo2 {
    public static void main(String[] args){
//        listRootsDemo();
        listDemo();
    }

    public static void listDemo(){
        File f = new File("c:\\");
        String[] names = f.list(); //调用list方法的file对象必须是封装了一个目录。该目录还必须存在。（如果是file文件，则返回为null，报空指针异常
        for(String name: names){
            System.out.println(name);
        }
    }

    public static void listRootsDemo(){
        File[] files = File.listRoots();
        for(File f: files){
            System.out.println(f);
        }
    }
}

<6 File对象：文件列表>

package day20;

import java.io.File;
import java.io.FilenameFilter;

/**
 * Created by Administrator on 2017/2/13.
 */
public class FileDemo2 {
    public static void main(String[] args){
        listDemo_3();
    }

    public static void listDemo_3(){
        File dir = new File("c:\\");
        File[] files = dir.listFiles();

        for(File f: files){
            System.out.println(f.getName() + "::" + f.length());
        }

    }

    public static void listDemo_2(){
        File dir = new File("D:\\code\\PycharmProjects\\Test");
        String[] arr = dir.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
//                System.out.println("dir: " + dir + "...name::" + name);
                /*if(name.endsWith(".bmp")){
                    return true;
                }
                else{
                    return false
                }*/

                return name.endsWith(".bmp");
//                return false;
            }
        });

        System.out.println("len: " + arr.length);
        for(String name: arr){
            System.out.println(name);
        }
    }

}

<7 列出目录下所有内容-递归>

package day20;

import java.io.File;

/**
 * 列出指定目录下文件或者文件夹，包含子目录中的内容。
 * 也就是列出指定目录下所有内容
 *
 * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
 * 在列出过程中出现的还是目录的话，还可以再次调用本功能。
 * 也就是函数自身调用自身。
 * 这种表现形式，或者编程手法，称为递归。
 * Created by Administrator on 2017/2/13.
 */
public class FileDemo3 {
    public static void main(String[] args){
        File dir = new File("f:\\");
        showDir(dir);
    }
    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]);
            }
        }



    }
}

代码2

package day20;

import java.io.File;
import java.io.ObjectInput;

/**
 * 列出指定目录下文件或者文件夹，包含子目录中的内容。
 * 也就是列出指定目录下所有内容
 *
 * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
 * 在列出过程中出现的还是目录的话，还可以再次调用本功能。
 * 也就是函数自身调用自身。
 * 这种表现形式，或者编程手法，称为递归。
 *
 * 递归要注意：
 * 1.限定条件。
 * 2.要注意递归的次数。尽量避免内存溢出。
 * Created by Administrator on 2017/2/13.
 */
public class FileDemo3 {
    public static void main(String[] args) {
        File dir = new File("f:\\");
//        showDir(dir);
//        toBin(6);
        int n = getSum(8000);
        System.out.println(n);
    }

    public static int getSum(int n){
        if(n == 1){
            return 1;
        }else{
            return n + getSum(n - 1);
        }
    }

    public static void toBin(int num){
        if(num > 0){
            toBin(num/2);
            System.out.println(num%2);
//            num = num / 2;
        }

package day20; import java.io.File; import java.io.ObjectInput; /** * 列出指定目录下文件或者文件夹，包含子目录中的内容。 * 也就是列出指定目录下所有内容 * * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。 * 在列出过程中出现的还是目录的话，还可以再次调用本功能。 * 也就是函数自身调用自身。 * 这种表现形式，或者编程手法，称为递归。 * * 递归要注意： * 1.限定条件。 * 2.要注意递归的次数。尽量避免内存溢出。 * Created by Administrator on 2017/2/13. */ public class FileDemo3 { public static void main(String[] args) { File dir = new File("f:\\"); showDir(dir, 0); // toBin(6); // int n = getSum(8000); // System.out.println(n); } public static String getLevel(int level){ StringBuilder sb = new StringBuilder(); sb.append("|--"); for(int x = 0; x < level; x++){ // sb.append("|--"); sb.insert(0, " "); } return sb.toString(); } public static void showDir(File dir, int level){ System.out.println(getLevel(level) + dir.getName()); level++; // System.out.println(dir); 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]); } } } }

} /*showA(); void showA(){ showB(); sop(A); } void showB(){ showC(); sop(B); } void showC(){ sop(C); } void sop(Object obj){}*/}

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

package day20;

import java.io.File;
import java.io.ObjectInput;

/**
 * 列出指定目录下文件或者文件夹，包含子目录中的内容。
 * 也就是列出指定目录下所有内容
 *
 * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
 * 在列出过程中出现的还是目录的话，还可以再次调用本功能。
 * 也就是函数自身调用自身。
 * 这种表现形式，或者编程手法，称为递归。
 *
 * 递归要注意：
 * 1.限定条件。
 * 2.要注意递归的次数。尽量避免内存溢出。
 * Created by Administrator on 2017/2/13.
 */
public class FileDemo3 {
    public static void main(String[] args) {
        File dir = new File("f:\\");
        showDir(dir, 0);
//        toBin(6);
//        int n = getSum(8000);
//        System.out.println(n);
    }

    public static String getLevel(int level){
        StringBuilder sb = new StringBuilder();
        sb.append("|--");
        for(int x = 0; x < level; x++){
//            sb.append("|--");
            sb.insert(0, " ");
        }
        return sb.toString();
    }

    public static void showDir(File dir, int level){

        System.out.println(getLevel(level) + dir.getName());
        level++;
//        System.out.println(dir);
        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]);
            }
        }
    }
}

<9 删除带内容的目录>

package day20;

import java.io.File;

/**
 * 删除一个带内容的目录。
 * 删除原理：
 * 在Windows中，删除目录时从里面往外删除的。
 *
 * 既然是从里往外删除，就需要用到递归。
 * 
 * java的删除不走回收站。
 * 系统级隐藏的文件 无法删除
 * Created by Administrator on 2017/2/13.
 */
public class RemoveDir {
    public static void main(String[] args){
        File dir = new File("f:\\");
        removeDir(dir);
    }

    public static void removeDir(File dir){
        File[] files = dir.listFiles();

        for(int x = 0; x < files.length; x++){
            if(!files[x].isHidden() && files[x].isDirectory()){
                removeDir(files[x]);
            }else{
                System.out.println(files[x].toString() + ":-file-:" + files[x].delete());
            }
        }
        System.out.println(dir + "::" + dir.delete());
    }
}

<10 创建java文件列表>

package day20;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * 练习：
 * 僵硬指定目录下的java文件的绝对路径，存储到一个文本文件中。
 * 建立一个java文件列表文件。
 *
 * 1. 对指定的目录进行递归。
 * 2. 获取递归过程所有的java文件的路径。
 * 3. 将这些路径存储到集合中。
 * 4. 将集合中的数据写入到一个文件中。
 * Created by Administrator on 2017/2/13.
 */
public class JavaFileList {
    public static void main(String[] args) throws IOException {
        File dir = new File("f:\\sws");
        List<File> list = new ArrayList<File>();

        fileToList(dir, list);
//        System.out.println(list.size());
        File file = new File(dir, "a.txt");
        writeToFile(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{
                list.add(file);
            }
        }
    }

    public static void writeToFile(List<File> list, String javaListFile) throws IOException {
        BufferedWriter bufw = null;

        try {
            bufw = new BufferedWriter(new FileWriter(javaListFile));

            for(File f: list){
                String path = f.getAbsolutePath();
                bufw.write(path);
                bufw.newLine();
                bufw.flush();
            }

        } catch (IOException e) {
            throw  e;
        }finally {
            try{
                if(bufw != null){
                    bufw.close();
                }
            }catch(IOException e){
                throw e;
            }
        }
    }

}

<12 Properties获取>

set、get方法

package day20;

import java.util.Properties;
import java.util.Set;

/**
 * Properties是hashtable的子类。
 * 也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
 *
 * 它是集合和IO技术相结合的集合容器。
 *
 * 该对象的特点：可以用于键值对形式的配置文件。
 *
 * (从流中加载键值对信息)
 * Created by Administrator on 2017/2/13.
 */
public class PropertiesDemo {
    public static void main(String[] args){
        setAndGet();
    }

    //设置和获取元素
    public static void setAndGet(){
        Properties prop = new Properties();

        prop.setProperty("zhangsan", "30"); //设置键值对
        prop.setProperty("lisi", "39");

        System.out.println(prop);

        String value = prop.getProperty("lisi"); //获取
        System.out.println(value);

        prop.setProperty("lisi", 19+"");

        Set<String> names = prop.stringPropertyNames();
        for(String s: names){
            System.out.println(s);
            System.out.println(s + ":" + prop.getProperty(s));
        }

    }
}

<13 Properties存取配置文件>

package day20;


import java.io.*;
import java.util.Properties;
import java.util.Set;

/**
 * Properties是hashtable的子类。
 * 也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
 *
 * 它是集合和IO技术相结合的集合容器。
 *
 * 该对象的特点：可以用于键值对形式的配置文件。
 *
 * 那么在加载数据时，需要数据有固定格式：键=值
 *
 * (从流中加载键值对信息)
 * Created by Administrator on 2017/2/13.
 */
public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
//        method_1();
        loadDemo();
    }

    public static void loadDemo() throws IOException {
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream("a.txt");

        //将流中的数据加载进集合
        prop.load(fis);
        prop.setProperty("wangwu", "39");

        FileOutputStream fos = new FileOutputStream("a.txt");

        prop.store(fos, "haha");

//        System.out.println(prop);
        prop.list(System.out);

        fos.close();
        fis.close();
    }

    //演示：如何将流中的数据存储到集合中。
    //想要将a.txt中的键值数据存到集合中进行操作。
    /*
      1. 用一个流和a.txt文件关联
      2. 读取一行数据，将改行数据用"="进行切割。
      3. 等号左边作为键，右边作为值。存入到Properties集合中即可.
     */
    public static void method_1() throws IOException {
        BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
        String line = null;
        Properties prop = new Properties();

        while((line = bufr.readLine()) != null){
            String[] arr = line.split("=");
//            System.out.println(line);
//            System.out.println(arr[0] + "..." + arr[1]);
            prop.setProperty(arr[0], arr[1]);
        }
        bufr.close();
        System.out.println(prop);
    }
}

<14 Properties练习>

package day20; import java.io.*; import java.util.Properties; /** * 用于记录应用程序运行次数。 * 如果使用次数已到，那么给出注册提示。 * * 很容易想到的是：计数器。 * 可是 该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。 * 可是随着该应用程序的退出，该计数器也在内存中消失了。 * * 下一次再启动该程序，又重写开始从0计数。 * 这样不是我们想要的。 * * 程序即使结束，该计数器的值也存在。 * 下次程序启动会先加载该计数器的值并加1后再重新存储起来。 * * 所以要建立一个配置文件。用于记录该软件的使用次数。 * * 该配置文件使用键值对的形式。 * 这样便于阅读数据，并操作数据。 * * 键值对数据时map集合。 * 数据是以文件形式存储，用io技术。 * 那么map+io --> properties. * * 配置文件可以实现营业程序数据的共享 * Created by Administrator on 2017/2/13. */ public class RunCount { public static void main(String[] args) throws IOException { Properties prop = new Properties(); File file = new File("count.txt"); if(!file.exists()){ file.createNewFile(); } FileInputStream fis = new FileInputStream(file); prop.load(fis); int count = 0; String value = prop.getProperty("time"); if(value != null){ count = Integer.parseInt(value); if(count >= 5){ System.out.println("请购买"); return; } } count++; prop.setProperty("time", count + ""); FileOutputStream fos = new FileOutputStream(file); prop.store(fos, ""); fos.close(); fis.close(); } }

<15 PrintWriter>

package day20; import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.List; /** * 练习： * 僵硬指定目录下的java文件的绝对路径，存储到一个文本文件中。 * 建立一个java文件列表文件。 * * 1. 对指定的目录进行递归。 * 2. 获取递归过程所有的java文件的路径。 * 3. 将这些路径存储到集合中。 * 4. 将集合中的数据写入到一个文件中。 * Created by Administrator on 2017/2/13. */ public class JavaFileList { public static void main(String[] args) throws IOException { File dir = new File("f:\\sws"); List<File> list = new ArrayList<File>(); fileToList(dir, list); // System.out.println(list.size()); File file = new File(dir, "a.txt"); writeToFile(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{ list.add(file); } } } public static void writeToFile(List<File> list, String javaListFile) throws IOException { BufferedWriter bufw = null; try { bufw = new BufferedWriter(new FileWriter(javaListFile)); for(File f: list){ String path = f.getAbsolutePath(); bufw.write(path); bufw.newLine(); bufw.flush(); } } catch (IOException e) { throw e; }finally { try{ if(bufw != null){ bufw.close(); } }catch(IOException e){ throw e; } } } }

<16 合并流 SequenceInputStream>

将多个读取流合并成一个读取流

package day20; import java.io.*; import java.util.Enumeration; import java.util.Vector; /** * Created by Administrator on 2017/2/14. */ public class SequenceDemo { public static void main(String[] args) throws IOException { Vector<FileInputStream> v = new Vector<FileInputStream>(); v.add(new FileInputStream("c:\\1.txt")); v.add(new FileInputStream("c:\\2.txt")); v.add(new FileInputStream("c:\\3.txt")); Enumeration<FileInputStream> en = v.elements(); SequenceInputStream sis = new SequenceInputStream(en); FileOutputStream fos = new FileOutputStream("c:\\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(); } }

<17 切割文件>(再听)

package day20; import java.io.*; import java.util.ArrayList; import java.util.Enumeration; import java.util.Iterator; /** * Created by Administrator on 2017/2/14. */ public class SplitFile { public static void main(String[] args) throws IOException { // splitFile(); merge(); } public static void merge() throws IOException { ArrayList<FileInputStream> al = new ArrayList<FileInputStream>(); for(int x = 1; x <= 3; x++){ al.add(new FileInputStream("c:\\splitfiles\\" + x + ".part")); } final Iterator<FileInputStream> it = al.iterator(); Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() { @Override public boolean hasMoreElements() { return it.hasNext(); } @Override public FileInputStream nextElement() { return it.next(); } }; SequenceInputStream sis = new SequenceInputStream(en); FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp"); byte[] buf = new byte[1024]; int len = 0; while((len = sis.read(buf)) != -1){ fos.write(buf, 0, len); } fos.close(); sis.close(); } public static void splitFile() throws IOException { FileInputStream fis = new FileInputStream("c:\\1.bmp"); FileOutputStream fos = null; byte[] buf = new byte[1024 * 1024]; int len = 0; int count = 1; while((len = fis.read(buf)) != -1){ fos = new FileOutputStream("c:\\splitfiles\\" + (count++) + ".part"); fos.write(buf, 0, len); fos.close(); } fis.close(); } }