「Java基础」文件对象的操作总结

最新推荐文章于 2024-04-05 12:57:26 发布

油炸冰可乐

最新推荐文章于 2024-04-05 12:57:26 发布

阅读量257

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/Wang_Pro/article/details/108415662

版权

Java基础专栏收录该内容

43 篇文章 0 订阅

订阅专栏

1 File类介绍

File对象与流对象不同，流对象是对内容（字符、字节）流的封装，File对象是将流对象封装成为文件对象，然后定义一套关于文件对象的方法。

2 File类常见的方法

常见方法有：文件的创建、删除、判断、获取关于文件的信息

1 创建

Boolean createNewFile() 在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
创建文件夹mkdir()
创建多级文件夹mkdirs()

2 删除

Boolean delete()删除失败返回false
void deleteOnexit() 在程序退出时删除指定文件。

3 判断
boolean exists() :文件是否存在.
isFile():
isDirectory();
isHidden();
isAbsolute();

4 获取信息。

getName():
getPath():
getParent(): 返回父目录，当没有指定时，返回空
getAbsolutePath()
long lastModified()
long length()

3 获得指定目录中的文件名称

// 返回listFiles()方法对象,使用对象可以继续操
import java.io.File;
import java.io.FilenameFilter;

public class FileDemo2 {
    public static void main(String[] args)
    {
        getFileObject();
    }
    
    public static void getFileObject() 
    {
        File dir = new File("/Users/zy/zy_Javase/my_work/day20");
        File[] files = dir.listFiles();// 文件对象获取
        for(File f:files)
        {
            System.out.println(f.getName()+"---"+f.length());
        }
    }
}

4 使用匿名类对象，搜索指定文件

// 在文件方法中使用.list（）,传入匿名对象
// 搜索指定文件：使用匿名类对象 FilenameFilter()
import java.io.File;
import java.io.FilenameFilter;

public class FileDemo2 {
    public static void main(String[] args)
    {

        getFileObject();
        // getFileObject();
    }

    public static void getFileName()
            // 方法的作用是返回特定文件的搜索对象
    {
        File dir = new File("/Users/zy/zy_Javase/my_work/day20");
        String[] arr =dir.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return name.endsWith(".txt");
            }
        });

        for(String name: arr)
        {
            System.out.println(name);
        }
    }

5 递归方法，获得目录

问题描述：文件夹与普通文件是有区别的，当指定的文件目录中存在新的子文件夹系统时，就需要用到递归方法，重新开辟空间遍历目录。

需要注意的是，如果递归次数太多则会使内存溢出。

import java.io.File;

// 递归遍历
public class FileDemo3 {
    public static void main(String[] args)
    {
        File dir = new File("/Users/zy/zy_Javase/my_work/day20");
        showDir(dir,0);
    }
    public static String getLevel(int level)
    {
        StringBuilder sb = new StringBuilder();
        for (int x=0; x<level;x++)
        {
            sb.append("  ");
        }
        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(files[x]);
        }
    }

}

6 Properties类介绍，基本操作

Properties类是hashtable的子类，所以Properties类可以调用hashtable中的put方法存储数据，存储与取出元素都有固定的格式“键=值”

基本方法：
.setProperty() 设置键值对
.store() 存储信息
.list(PrintStream out) 接收一个输出流，打印出来
.load()加载进入信息

6.1 加载数据、修改、储存

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class ProperitesDemo {
    public static void main(String[] args) throws IOException
    {
        loadDemo();
    }
    public static void loadDemo()throws IOException
    {
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream("a.txt");
        prop.load(fis); // 加载
        prop.setProperty("DF","10"); // 存储 & 修改

        FileOutputStream fos = new FileOutputStream("a.txt");
        prop.store(fos,"Note Information"); 

        prop.list(System.out);

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

    }
}

6.2 计数器例子，读取、写入、保存

描述：需要创建一个APP的计数器，在计数器中声明使用次数小于等于5次，否则的话提醒用户充值。

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

// 1 计数
// 2 内存内容 转换 配置文件
// 3 启动加载
public class RunCount {
    public static void main(String[] args) throws IOException
    {
        Properties prop = new Properties();
        File file = new File("config.ini");
        if (!file.exists())
            file.createNewFile();

        FileInputStream fis = new FileInputStream(file);
        prop.load(fis); // 读取文件

        int count = 0;
        String value = prop.getProperty("times");// 获得存储值

        if (value!=null)
        {
            count = Integer.parseInt(value);
            if(count>=5)
            {
                System.out.println("您好，使用次数已到 5 次，请充值！");
                return;
            }
        }
        count++;

        FileOutputStream fos = new FileOutputStream(file); // 写入
        prop.setProperty("times",count+""); // put方法
        prop.store(fos,""); // 写入输出流

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

    }
}

7 打印流 PrintWriter | PrintStream

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

字节打印流：
PrintStream
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream



字符打印流：
PrintWriter
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream
4，字符输出流，Writer


import java.io.*;

class  PrintStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));// 键盘读入

		PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true); // 写入文件

		String line = null;

		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			out.println(line.toUpperCase());
			//out.flush();
		}

		out.close();
		bufr.close();

	}	
}

8 合并流

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class SequenceDemo {
    public static void main(String[] args)throws IOException
    {
        Vector<FileInputStream> v = new Vector<FileInputStream>();
        v.add(new FileInputStream("b.txt"));
        v.add(new FileInputStream("c.txt"));
        v.add(new FileInputStream("d.txt"));

        Enumeration<FileInputStream> en = v.elements(); // 收集元素
        SequenceInputStream sis = new SequenceInputStream(en); // 序列化

        FileOutputStream fos = new FileOutputStream("all.txt"); // 输出位置

        byte[] buf =new byte[1024];
        int len = 0;
        while ((len=sis.read(buf))!=-1) 
        {
            fos.write(buf,0,len);// 写入
        }
        fos.close();
        sis.close();
    }
}

9 切割流｜合并流实现

合并流的逆向操作，将文件切割成为多个部分

合并流的思路：列表->迭代器->实现枚举->加入序列流->写入文件

将输入流列表制作为迭代器，使用枚举方法，加入序列流，写入文件。

import java.io.*;
import java.util.*;

public class IoCut {
    public static void main(String[] args)throws IOException
    {
        splitFile();
        // combine();
    }
    public static void splitFile()throws IOException
    {
        FileInputStream fis = new FileInputStream("pic.png"); // 创建切割对象
        FileOutputStream fos = null;

        byte[] buf = new byte[1024*1024]; // 指定切割大小
        int len = 0;
        int count = 1;
        while ((len=fis.read(buf))!=-1)
        {
            fos = new FileOutputStream("PIC"+(count++)+".part");
            fos.write(buf,0,len); // 切割
            fos.close();
        }

        fis.close();

    }
    public static void combine() throws IOException
    {
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for(int x=1;x<3; x++)
        {
            al.add(new FileInputStream("PIC"+(x)+".part"));
        }

        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("con.png");

        byte[] buf = new byte[1024]; //1M
        int len = 0;
        while ((len=sis.read(buf))!=-1)
        {
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
}