IO流2的理解

最新推荐文章于 2025-03-14 09:30:00 发布

原创最新推荐文章于 2025-03-14 09:30:00 发布 · 356 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#1024程序员节 #redis #缓存

Java 专栏收录该内容

86 篇文章

订阅专栏

一、File类

1、概述

文件和目录路径名的抽象表示形式。

特点：
a、用来将文件或者文件夹封装成对象
b、方便对文件与文件夹进行操作
c、File对象可以作为参数传递给流的构造函数
d、File 类的实例是不可变的；也就是说，一旦创建，File 对象表示的抽象路径名将永不改变。

例1

import java.io.*;
class FileDemo
{
	public static void main(String[] args)
	{
		consMethod();
	}

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

		File f2=new File("c:\\abc","b.txt");//设置父类目录下的文件

		File d=new File("c:\\abc");

		File f3=new File(d,"c.txt");

		sop("f1:"+f1);
		sop("f2:"+f2);
		sop("f3:"+f3);

		File f4=new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
	}

	public static void sop(Object obj)//打印函数
	{
		System.out.println(obj);
	}
}

结果输出：

2、File类常见方法

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

2）、删除
boolean delete():删除失败返回false。如果文件正在被使用，则删除不了false。
void deleteOnExit():在程序退出时删除指定文件。

3）、判断
boolean exists():文件是否存在。
isFile():是否是文件。
isDirectory():是否是目录。

注意：在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。

通过exists判断。

isHidden（）：是否是隐藏文件。
isAbsolute（）：是否是绝对的。

4）、获取信息

getName()：获取名字

getPath()：获取路径

getParent()：获取父路径

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

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

getAbsolutePath()：获取绝对路径

long lastModified()：获取最后修改时间

long length()：获取长度

5）、列出文件及文件过滤
static File[]listRoots();//列出可用的文件系统根目录，即系统盘符。

String[] list();//列出当前目录下所有文件，包括隐藏文件。
//调用list方法的file对象必须是封装了一个目录，并且该目录必须存在。

String[] list(FilenameFilter filter);
//返回一个字符串数组，获取目录中满足指定过滤器的文件或目录

//FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，
//accept（Filedir，String name），返回的是boolean型，对不符合条件的文件过滤掉

小练习：

/*
需求：用String[] list(FilenameFilter filter)方法获取一个目录下所有的.java文件，其他文件不要。
思路：
1、创建File目标路径
2、构造函数过滤.java后缀的文件，用到String的方法endswith（）；
3、创建函数复写FilenameFilter中的accept（）方法。
*/
import java.io.*;
import java.lang.*;

class FilenameFilterDemo
{
	public static void main(String[] args)
	{
		File file=new File("D:\\JAVA编码");//目标目录
		getJavaFile(file);
	}

	public static void getJavaFile(File dir)//与主函数关联
	{
		String[] javaFile=dir.list(new FilenameFilter()//匿名对象
		{
			public boolean accept(File dir,String name)//复写accept方法
			{
				return name.endsWith(".java");//只保留以.java结尾的文件
			}
		});

		System.out.println("len:"+javaFile.length);//获取长度

		for(String s:javaFile)//高级for遍历
		{
			System.out.println(s);
		}
	}
}

结果输出：

3、递归

列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。

递归要注意：
1、限定条件。
2、要注意递归的次数，尽量避免内存溢出。

例2

import java.io.*;

class FileDemo
{
	public static void main(String[] args)
	{
		File dir=new File("d:\\JAVA编码");//文件目录
		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]);//是的话重新调用showDir
			else
				System.out.println(files[x]);//不是的话打印数组
		}
	}
}

结果输出：

有层次地列出目录：

例3

import java.io.*;

class FileDemo
{
	public static void main(String[] args)
	{
		File dir=new File("d:\\JAVA编码");//文件目录
		showDir(dir,0);
	}

	public static String getLevel(int level)
	{
		StringBuilder sb=new StringBuilder();//容器
		sb.append("|--");在数据前插入
		for(int x=0;x<level;x++)
		{
			sb.insert(0,"|  ");	//从0级出开始插入	
		}
		return sb.toString();//返回指定格式
	}

	public static 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);//是的话重新调用showDir
			else
				System.out.println(getLevel(level)+files[x]);//不是的话打印数组
		}
	}
}

结果输出：

删除一个带内容的目录。

删除原理：
在window中，删除目录从里面往外删除的。

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

例4

import java.io.*;
class RemoveDir
{
	public static void main(String[] args)
	{
		File dir=new File("d://games");//需要删除的目录
		removeDir(dir);//调用删除函数
	}

	public static void removeDir(File dir)
	{
		File[] files=dir.listFile();//集合排序

		for(int x=0;x<files.length;x++)//遍历
		{
			if(files[x].isDirectory())//判断是否为目录
				removeDir(file[x]);//是，重新调用函数，递归
			else
				System.out.println(files[x].toString()+":-file-:"+files[x].delete());//不是，就把该文件删除
		}

		System.out.println(dir+"::dir::"+dir.delete());//删除目录
	}
}

创建java文件列表：

例5

/*
需求：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。
思路：
1、对指定的目录进行递归。
2、获取递归过程所有java文件的路径。
3、将这些路径存储到集合中。
4、将集合中的数据写入到一个文件中。
*/
import java.io.*;
import java.util.*;
class JavaFilelist
{
	public static void main(String[] args)throws IOException
	{
		File dir=new File("d:\\JAVA编码");//创建目录

		List<File> list=new ArrayList<File>();//创建集合

		fileToList(dir,list);//关联函数

		File file=new File(dir,"javalist.txt");//存入在父目录下创建的文件
		writeToFile(list,file.toString());//关联函数
	}

	public static void fileToList(File dir,List<File> list)//文件装入集合函数
	{
		File[] files=dir.listFiles();//排序集合

		for(File file : files)//增强for循环
		{
			if(file.isDirectory())//是否为目录
				fileToList(file,list);//是，则递归。返回重新调用函数
			else
			{
				if(file.getName().endsWith(".java"))//否，则筛选以.java为后缀的文件
					list.add(file);//将筛选的文件添加到集合中
			}
		}
	}

	public static void writeToFile(List<File> list,String javaListFile)throws IOException//写入文件函数
	{
		BufferedWriter bufw=null;//创建成员变量，方便finally中的方法调用
		
		try
		{
			bufw=new BufferedWriter(new FileWriter(javaListFile));//缓冲文件

			for (File f:list)//增强for循环
			{
				String path=f.getAbsolutePath();//获取绝对路径
				bufw.write(path);//打印路径
				bufw.newLine();//换行
				bufw.flush();
			}
		}
		catch (IOException e)
		{
			throw e;
		}
		finally
		{
			if(bufw!=null)
				bufw.close();
		}
	}
}

结果输出：

二、Properties

1、概述

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

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

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

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

2、常用方法

1）设置

setProperty（String key，String value）：调用 Hashtable 的方法 put。

2）获取

getProperty（String key）：用指定的键在此属性列表中搜索属性。
StringPropertyNames：获取集合内的所有元素

3）

4）

5）

例1 如何将流的数据存储到集合中

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

class PropertiesDemo
{
	public static void main(String[] args)throws IOException
	{
		loadDemo();
	}

	public static void loadDemo()throws IOException
	{
		Properties prop=new Properties();

		FileInputStream fis=new FileInputStream("info.txt");//读取数据
	
		prop.load(fis);//将流中的数据加载进集合。

		prop.setProperty("wangwu","39");//更改集合中的数据

		FileOutputStream fos=new FileOutputStream("info.txt");//输出存储数据

		prop.store(fos,"haha");//生成数据

		prop.list(System.out);//输出到控制台上

		fos.close();//关闭流
		fis.close();
	}
}

结果输出：

load方法原理：

演示。如何将流中的数据存储到集合中。
想要将info.txt中键值数据存到集合中进行操作。

1、用一个流和info.txt文件关联。
2、读取一行数据，将该行数据用“=”进行切割。
3、等号左边作为键，右边作为值。存入到Properties集合中即可。

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

class PropertiesDemo
{
	public static void main(String[] args)throws IOException
	{
		method();
	}

	public static void method()throws IOException
	{
		BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));//创建读取缓冲区，读取文件

		String line=null;
		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);
	}

}

小练习：用于记录应用程序运行次数。

/*
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。

很容易想到的是：计数器。
可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，该计数器也在内存中消失了。

下一次再启动该程序，又重新开始从0计数。
这样不是我们想要的。

程序即使结束，该计数器的值也存在。
瑕疵程序启动会先加载该计数器的值并加1后再重新存储起来。

所以要建立一个配置文件。用于记录该软件的使用次数。

该配置文件使用键值对的形式。
这样便于阅读数据，并操作数据。

键值对数据是map集合。
数据是以文件形式存储，使用io技术。
那么map+io-->properties

配置文件可以实现应用程序数据的共享。
*/
import java.util.*;
import java.io.*;
class RunCount
{
	public static void main(String[] args)throws IOException
	{
		Properties prop=new Properties();

		File file=new File("count.ini");//创建文件
		if(!file.exists())//判断文件是否存在，不存在则创建
			file.createNewFile();

		FileInputStream fis=new FileInputStream(file);//用字节流操作数据

		prop.load(fis);//流中的数据加载到集合中

		int count=0;//计数器
		String value=prop.getProperty("time");//以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,"");//以键值对的格式加载到Properties表中

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

结果输出：

三、IO包中的其他类

1、打印流

PrintWriter与PrintStream

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

例1

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 BufferedWriter(new FileWriter("a.txt")),true);//数据输出到目标文件里，并且自动刷新

		String line=null;

		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))//判断什么时候结束
				break;
			out.println(line.toUpperCase());//打印成大写
		}

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

结果输出：

2、序列流

SequencelnputStream

对多个流进行合并

常见合并多个流文件步骤：

1）、创建集合，并将流对象添加进集合。
2）、创建Enumeration对象，将集合元素加入。
3）.创建SequenceInputStream对象，合并流对象。
4）.创建写入流对象，FileOutputStream关联写入文件。
5）.利用SequenceInputStream对象和FileOutputStream对象读数据进行反复读写操作。

例2

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

class SequenceDemo
{
	public static void main(String[] args)throws IOException
	{
		Vector<FileInputStream> v=new Vector<FileInputStream>();//泛型限定

		v.add(new FileInputStream("d:\\1.txt"));//把流存入集合
		v.add(new FileInputStream("d:\\2.txt"));
		v.add(new FileInputStream("d:\\3.txt"));

		Enumeration<FileInputStream> en=v.elements();//把流作为v中的元素

		SequenceInputStream sis=new SequenceInputStream(en);//合并流

		FileOutputStream fos=new FileOutputStream("d:\\4.txt");//全部输出到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();
	}
}

结果输出：

例3 切割、合并MP3类型文件

package study;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;

public class Test8 {

	public static void main(String[] args) throws Exception {
		merge();
	}
	
	public static void splitFile() throws Exception{
		//字节流读取文件
		FileInputStream fis=new FileInputStream("D:\\爱尔兰画眉1.mp3");
		//定义输出字节流为空
		FileOutputStream fos=null;
		//创建1M的容器
		 byte[] buf=new byte[1024*1024];
		 //创建读取标记
		 int len=0;
		 //定义计数器
		 int count=1;
		 //循环输出
		 while((len=fis.read(buf))!=-1){
			 fos=new FileOutputStream("D:\\"+(count++)+".part");//分成若干份
			 fos.write(buf,0,len);//避免装不满，数组里空位的情况，确保取出的数据都是有效值
			 fos.close();//数组装载，每卸货一次（生成一份文件），则关闭输出流一次
		 }
		 fis.close();//关闭输出流
	}
	
	public static void merge() throws IOException{
		//Vector过时了，换ArrayList集合，泛型限定为FileInputStream
		ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
		//文件碎片多则循环添加，少则直接添加
		int count=1;//创建计数器
		for(int x=0;x<5;x++){
			al.add(new FileInputStream("D:\\"+(count++)+".part"));
		}
		
		//用集合迭代器与Enumeration关联，需加final修饰
		final Iterator<FileInputStream> it=al.iterator();
		
		//由匿名内部类创建Enumeration接口的子类对象，复写hasmoreElments方法和nextElment方法
		Enumeration<FileInputStream> en=new Enumeration<FileInputStream>(){

			@Override
			public boolean hasMoreElements() {
				// TODO Auto-generated method stub
				return it.hasNext();
			}

			@Override
			public FileInputStream nextElement() {
				// TODO Auto-generated method stub
				return it.next();
			}};
			
		//创建合并流对象，与Enumeration子类对象相关联	
		SequenceInputStream sis=new SequenceInputStream(en);
		
		//创建输出流对象，设置路径
		 FileOutputStream fos=new FileOutputStream("D:\\爱尔兰画眉10.mp3");
		 
		 //创建容器
		 byte[] buf=new byte[1024*1024];
		 //创建读取标记
		 int len=0;
		 //循环读写
		 while((len=sis.read(buf))!=-1){
			 fos.write(buf,0,len);//确保取出的数据都是有效值
		 }
		 
		 //关流
		 fos.close();
		 sis.close();
	}
}