黑马程序员java基础之io流中的File类_for(file f:list)什么意思-优快云博客

本文详细介绍了Java中File类的使用方法，包括文件和文件夹的基本操作、路径获取、信息查询等，并通过实例演示了如何利用File类进行文件系统管理。

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

1.File类对文件或者文件夹进行操作

常见方法

1.创建：boolean createNewFile(): 在指定位置创建文件，如果该文件已经存在，则不创建，返回false 注意：和输出流不一样，输出流对象一创建文件，如果文件已存在，则会覆盖

boolean mkdir():创建文件夹

boolean mkdirs() 创建多级目录

2.删除：boolean delete()

void deleteOnExit() 退出时删除文件

3.判断：boolean exists()：文件是否存在

isFile():是否是文件

isDirctionary()：是否是目录

isHidden():是否隐藏

isAbsolute()：是否是绝对路径

4.获取信息：getName()；

getPath()将路径名转换成字符串；

getParent()返回父目录名，如果没有，则返回null

getAbsolutePath():返回绝对路径名字符串；

long lastModified():获取文件最后一次修改的时间

long length():文件大小

import java.io.*;

class FileDemo
{
 	public static void main(String[] args) throws IOException
	{
		method_4();
	}
	
	public static void method_4()
	{
		File f=new File("file.txt");
		sop(f.getPath());
		sop(f.getAbsolutePath());	
	}
	public static void method_3()
	{
		File f= new File("file.txt");
		//在判断文件对象是否是文件目录或者目的时，必须先判断文件对象封装的内容是否存在，通过exists判断
		
		sop(f.isDirectory());
		sop(f.isFile());
	}

	public static void comsthod_2()throws IOException
	{
		File f=new File("FileDemo.java");
		sop(f.canExecute());
		sop(f.exists());
	}
	public static void comsthod_1() throws IOException
	{
		File f=new File("file.txt");
		//将a.txt封装成file对象，可以将已有的和未出现的文件或者文件夹封装成对象

		sop(f.createNewFile());
		sop(f.delete());
		//创建文件夹
		File dir=new File("abc\\c");
		sop(dir.mkdir());
		
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

2.list方法

File: listRoots 列出可用的文件系统根目录

import java.io.*;
class FileDemo2
{
	public static void main(String[] args)
	{
		ListRootsDemo();
	}
	public static void ListRootsDemo()
	{
		File[] files=File.listRoots();//列出可用的文件系统根,
		for(File f:files)
		{
			System.out.println(f);
		}
	}
}

String[] list:返回指定目录下的文件和目录（包括隐藏文件）的字符串数组

public static void listDemo()
	{
		File f=new File("c:\\");
		String[] names=f.list();//调用list方法的File对象必须是封装了一个存在的目录，否则会发生空指针异常
		for(String name:names)
		{
			System.out.println(name);//打印出c盘下的文件列表
		}

boolean list(FilenameFilter filter) 文件过滤器:根据返回值的真假来判断是否符合需要过滤的文件，如返回为true ,则说明文件是符合要求的，如果返回为false,则说明文件都被过滤掉了

File[] listFiles:指定目录下的文件列表

import java.io.*;
class FileDemo2
{
	public static void main(String[] args)
	{
		File dir=new File("c:\\");
		File[] files=dir.listFiles();

		for(File f:files)
		{
			System.out.println(f.getName()+"--"+f.length());
		}
	}
	
	public static void listDemo_1()
	{
		File dir=new File("d:\\java0217\\day19");
		String[] arr=dir.list(new FilenameFilter(){	
			public boolean accept(File dir,String name)
			{
				//System.out.println(dir+"---"+name);
					//打印结果显示dir是指定的文件目录，name是当前目录下的文件名
				return name.endsWith(".java");
				
			}
		});  //创建一个匿名内部类实现accpet方法
		System.out.println(arr.length);
		for(String name:arr)
		{
			System.out.println(name);
		}
	}

	public static void listDemo()
	{
		File f=new File("c:\\");
		String[] names=f.list();
		for(String name:names)
		{
			System.out.println(name);
		}
	}
	public static void ListRootsDemo()
	{
		File[] files=File.listRoots();//列出可用的文件系统根,
		for(File f:files)
		{
			System.out.println(f);
		}
	}
}

练习：列出指定目录下的文件或者文件夹，包括子文件夹中的内容

import java.io.*;
class FileDemo3
{
	public static void main(String[] args)
	{
		File dir=new File("d:\\java0217");
		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]);
		}
	}
}

上例中函数自身再次调用自身，这种方法是称为递归

递归：函数自身调用自身

递归要注意：1.限定条件（递归相当于循环，如果没有条件，递归不会停止）；2.注意递归的次数，避免内存溢出

用递归求和

class FileDemo4
{
	public static void main(String[] args)
	{
		int n=getSum(100);
		System.out.println(n);
		
	}
	public static int getSum(int n)
	{
		if(n==1)
			return 1;
		else
		return n+getSum(n-1);
	}
}

4.建立层级目录

import java.io.*;
class FileDemo3
{
	public static void main(String[] args)
	{
		File dir=new File("d:\\java0217");
		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++;
		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]);
		}
	}
}

删除一个带内容的目录：

原理：在windows系统中，删除目录是从里面往外面删除的，这就涉及到递归

import java.io.*;
class removeDir
{
	public static void main(String[] args)
	{
		File dir=new File("d:\\abc");
		removeDir(dir);
	}
	public static void removeDir(File dir)
	{
		File[] files=dir.listFiles();
		for(int x=0;x<files.length;x++)
		{
			if(files[x].isDirectory())
				removeDir(files[x]);
			else
				System.out.println(files[x].toString()+files[x].delete());
		}
		System.out.println(dir+"--"+dir.delete()); 
	}
}

练习：将一个指定目录下的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:\\java0217");
		List<File> list=new ArrayList<File>();
		fileToList(dir,list);
		File file=new File(dir,"javalist.txt");
		WriteToFile(list,file.toString());
		System.out.println(list.size());

	}
	public static void fileToList(File dir,List<File> list)
	{
		File[] files=dir.listFiles();
		
		for(File file:files)
		{
			if(file.isDirectory())//如果是目录文件，继续递归
				fileToList(file,list);
			else
			{
				if(file.getName().endsWith(".java"))
					list.add(file);
			}
		}
	}
	public static void WriteToFile(List<File> list,String javaListFile)
	{
		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 new RuntimeException("写入失败");
		}
		finally
		{
			try
			{
				bufw.close();
			}
			catch(IOException e)
			{
				throw new RuntimeException("关闭流失败");
			}
		}
	}
}

4.Properties：系统属性值，是键值对。它是Map集合的子类，具有集合特点，并且存储的键值对都是字符。是集合中和IO流技术相结合的集合容器

特点：可以用于键值对形式的配置文件；需要固定的格式：键=值

import java.util.*;
class PropertiesDemo
{
	public static void main(String[] args)
	{
		getAndset();
	}
	public static void getAndset()
	{
		Properties prop=new Properties();//创建属性对象
		//设置属性键值对
		prop.setProperty("zhangsang","30");
		prop.setProperty("lise","25");

		System.out.println(prop);
		String value=prop.getProperty("lise");
		System.out.println(value);

		Set<String> names=prop.stringPropertyNames();//获取属性列表中的键集
		for(String s:names)
		{
			System.out.println(s+prop.getProperty(s));
		}
	}
	
}

练习：将info.txt中键值数据存到集合中进行操作

步骤：1.用一个流个info.txt文件相关联；2.读取一行数据，将该行数据用等号切割；3.等号左边作为键，右边作为值，存入Properties集合中

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);  //将流中的数据加载进集合
		
		//System.out.println(prop);

		prop.setProperty("lise","43");//修改集合中元素，但只是改变了内存中的结果，文档中的值任然没变
		FileOutputStream fos=new FileOutputStream("info.txt");
		prop.store(fos,"haha");//将修改的数据同时在文本中也保存，并且自动加上修改时间；“haha”是注释信息
		prop.list(System.out);
	}
	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("=");  //用“=”切割出键和值
			//System.out.println(arr[0]+"--"+arr[1]);
			prop.setProperty(arr[0],arr[1]);  //设置成键值对
		}
		bufr.close();
		System.out.println(prop);
	}
	public static void getAndset()
	{
		Properties prop=new Properties();//创建属性集合
		//设置属性键值对
		prop.setProperty("zhangsang","30");
		prop.setProperty("lise","25");

		System.out.println(prop);
		String value=prop.getProperty("lise");
		System.out.println(value);

		Set<String> names=prop.stringPropertyNames();//获取属性列表中的键集
		for(String s:names)
		{
			System.out.println(s+prop.getProperty(s));
		}
	}
	
}

练习：用于记录应用程序运行次数，如果使用次数已到，给出注册提示

需要建立一个配置文件用于记录软件的使用次数。该配置文件使用键值对的形式，便于阅读和操作数据

import java.io.*;
import java.util.*;
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");//获取键值，此时没有数据，键值为null
		
		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();
	}
}