File笔记

最新推荐文章于 2021-11-30 10:16:07 发布

zs40122

最新推荐文章于 2021-11-30 10:16:07 发布

阅读量534

点赞数

分类专栏： java笔记文章标签： java 笔记

本文链接：https://blog.csdn.net/zs40122/article/details/52289808

版权

java笔记专栏收录该内容

16 篇文章 1 订阅

订阅专栏

File类常见方法：
1.创建
boolean createNewFile(); 在指定位置创建文件，如果该文件已经存在，则不创建，返回false
与输出流不同，输出流对象一建立就会立即创建文件。而且文件已存在也会覆盖。
boolean mkdir(); 创建文件夹
boolean mkdirs(); 创建多级文件夹
2.删除
boolean delete();//用此方法文件可能不会被删除。删除失败返回false
//如文件正在被使用。若程序异常此句放于finally中仍删不了文件，因文件正在被使用。
void deleteOnExit();//程序退出时删除文件。调用此方法，不管什么情况，虚拟机退出文件都将会被删除。

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

//前提：文件是否存在
boolean isDirectory(); 判断次抽象路径名表示的文件是否是一个目录
boolean isFile(); 判断此抽象路径名表示的文件是否是一个标准文件
boolean isAbsolute(); 判断此抽象路径是否为绝对路径(无论文件是否存在)

4.获取信息
String getName();//对象调用getName()获取名称
getPath(); //获取路径(文件不一定要存在)
getParent(); //获取绝对路径中的父目录(没有明确指出父路径或获取的是相对路径会返回Null)
getAbsolutePath();//返回绝对路径(文件不一定要存在)

File getAbsoluteFile();//返回绝对路径，并将返回的绝对路径封装成对象

long lastModified();返回此抽象路径表示的文件最后一次被修改的时间
length();抽象路径名表示的文件长度

String[] list();当前目录下的文件及文件夹的名称

File[] listFiles();当前目录下的文件及文件夹的对象

import java.io.*;

class FileDemo
{
	public static void main(String[] args) throws IOException
	{
		//consMethod();
		//method_1();
		//method_2();
		//method_3();
		//method_4();
		//method_5();
		method_6();
	}

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

		//sop("create:"+f.createNewFile());  创建文件(在用户当前目录下或者指定目录)
		sop("delete:"+f.delete());  //删除文件
	}

	public static void method_2()
	{
		File f = new File("FileDemo.java");

		sop("exists:"+f.exists());

		//sop("execute:"+f.canExecute()); //canExecute() 判断文件是否能运行
	}

	public static void method_3() 
	{
		//File dir = new File("F:\\黑马程序员 Java\\第二十天\\abc");
		File dir = new File("abc");

		sop("mkdir:"+dir.mkdir());
		//mkdir();只能创建一级目录 即每次只能创建一层目录
	}

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

		//在判断文件对象是否是文件或目录时，必须先判断该文件对象封装的内容是否存在。
		sop("dir1:"+f.isDirectory()); //false
		sop("file1:"+f.isFile());//false  文件不存在

		f.createNewFile();
		sop("dir2:"+f.isDirectory()); //false
		sop("file2:"+f.isFile()); //true

		f.mkdir();
		sop("dir2:"+f.isDirectory()); //true
		sop("file2:"+f.isFile()); //false
	}

	public static void method_5()
	{
		File f = new File("f5.txt");

		sop("path:"+f.getPath());  //f5.txt
		//会打印相对路径及文件即f中封装的路径及文件。
		sop("abspath:"+f.getAbsolutePath());//F:\黑马程序员 Java\第二十天\days20\f5.txt
		//只会打印绝对路径

		sop("parent:"+f.getParent());//null 获取的是相对路径。
		//若相对路径中有上一层目录则该目录就是返回结果。如封装的是"abc\\f5.txt",则会返回abc
	}

	public static void method_6()
	{
		File f1 = new File("file.txt");
		File f2 = new File("f.txt");

		//sop("renameTo:"+f1.renameTo(f2)); //renameTo();  重命名
		
		File f3 = new File("F:\\Test.txt");//有文件
		File f4 = new File("D:\\Test2.txt");//无文件
		sop("renameTo2:"+f3.renameTo(f4));//此时renameTo() 是剪切加重命名的功能
	}

	//创建File对象
	public static void consMethod()  //构造方法演示
	{
		//将a.txt封装成file对象.可以将已有的和未出现的文件封装成对象。
		//File f1 = new File("F:\\黑马程序员 Java\\第二十天\\days20\\a.txt");
		File f1 = new File("a.txt");

		//
		File f2 = new File("F:\\黑马程序员 Java\\第二十天\\days20\\","b.txt");
		//此种形式，前面传路径后面传文件，后面文件是可变的，可以传变量

		//File d = new File("F:\\黑马程序员 Java\\第二十天\\days20\\");
		//名称分隔符"\\"在不同平台下会不同，影响跨平台型。用方法separator实现跨平台。
		File d = new File("F:"+File.separator+"黑马程序员 Java"+File.separator+"第二十天"+File.separator+"days20"+File.separator+"");
		File f3 = new File(d,"c.txt");
		
		//sop("f1:"+f1); //f1:F:\黑马程序员 Java\第二十天\days20\b.txt  绝对路径
		sop("f1:"+f1); //f1:a.txt   相对路径
		sop("f2:"+f2);
		sop("f3:"+f3);
	}

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







import java.io.*;

class FileDemo2
{
	public static void main(String[] args)
	{
		//listRootsDemo();
		//listDemo();
		//listDemo2();
		listDemo3();
	}

	public static void listDemo3()
	{
		//当前目录下的文件及文件夹的对象
		File dir = new File("F:\\黑马程序员 Java\\第二十天\\days20");
		File[] files = dir.listFiles();

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

	public static void listDemo()
	{
		File f = new File("F:\\"); //打印F盘当前下的所有文件及文件夹的名称(包含隐藏文件)

		String[] names = f.list(); //调用了list方法的file对象必须是封装了一个存在的目录， 
		//当list方法所属对象是文件时因不是目录，所以返回的数组为空，会发生空指针异常。
		//ruo目录是空的，则返回的数组也为空(0)。

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

	public static void listDemo2()
	{
		File dir = new File("F:\\黑马程序员 Java\\第二十天\\days20");

		String[] arr = dir.list(new FilenameFilter()
		{    //匿名内部类
			public boolean accept(File dir,String name)
			{
				/*
				System.out.println("dir:"+dir+"...name"+name);
				return true;

				if(name.endsWith(".class"))
					return true;
				else
					return false;
				*/

				return name.endsWith(".class");
			}
		});
		//list方法在依据对象(new FilenameFilter())的accept方法的返回值来判断文件是否为需要的文件。
		//所以 return true；会打印指定目录下所有文件。return false；打印len：0。

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

	public static void listRootsDemo()
	{
		File[] files = File.listRoots(); //列出本电脑中有效的盘符

		for(File f:files)
		{
			System.out.println(f);
		}
	}
}






/*
列出指定目录下的文件或者文件夹，包含子目录中的内容。
即列出指定目录下所有内容。

递归
注意：
1.限定条件。
2.注意递归次数。每一次调用函数，栈内存中都会存放一次方法，过多会导致内存溢出。
*/

import java.io.*;

class FileDemo3
{
	public static void main(String[] args)
	{
		File dir = new File("F:\\黑马程序员 Java");
		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]);
		}
	}
}







import java.io.*;

/*
删除一个带内容的目录

在Windows中，删除目录是从里往外删除的。

在Java中将文件删除，文件是不会进回收站的！

会发生空指针异常：
在系统盘中有些隐藏文件java访问不到，files会为空，应该尽量判断非隐藏的内容;
系统中有些文件其实是目录，有些目录其实是文件，java访问这些也会空指针异常。
*/

class RemoveDir
{
	public static void main(String[] args)
	{
		File dir = new File("");
		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]);
			System.out.println(files[x].toString()+":-file-:"+files[x].delete());
		}
		System.out.println(dir+"::dir::"+dir.delete());
	}
}







/*
将一个指定目录下的java文件的绝对路径存储到一个文件中。
建立一个java文件列表文件

思路：
1.对指定目录进行递归
2.获取递归过程所有的java文件路径
3.
*/

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

class JavaFileList
{
	public static void main(String[] args) throws IOException
	{
		File dir = new File("F:\\黑马程序员 Java\\第十九天\\days19");//源

		List<File> list = new ArrayList<File>();

		fileToList(dir,list);

		System.out.println(list.size());

		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)
		{
			if(file.isDirectory())
				fileToList(file,list);
			else
			{
				if(file.getName().endsWith(".java"))
					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;
			}
		}
	}
}







/*
Properties是hashtable的子类。
即它具备map集合的特点。而且它里面存储的键值对都是字符串，不需要泛型。

Properties类表示了一个持久的属性集。(应用于如某软件保存自身配置信息)

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

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

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

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

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

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

		FileInputStream fils = new FileInputStream("info.txt");

		//将流中的数据加载进集合
		prop.load(fils);

		//若想改数据，直接调用seiProperty();输出中会改但原始文件中数据不变。
		//即setProperty();只是改变的内存的结果。
		//而方法store()；不仅将数据加入流中，还加载到文件中。

		prop.setProperty("wangwu",59+"");

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

		prop.store(fos,"zhushi");

		//sop("prop:"+prop);//{lisi=19,zhangsan=26,wangwu=39}

		prop.list(System.out);
		 /*
		 --listing properties--
		 zhangsan=26
		 lisi=19
		 wangwu=39
		 */

		 fos.close();
		 fils.close();
	}



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

		String line = null;

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

		bufr.close();
		sop("prop:"+prop);
	}

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

		prop.setProperty("zhangsan","30");//强制要求属性的键和值均使用字符串
		prop.setProperty("lisi","26");

		sop("prop:"+prop);// {zhangsan=30,lisi=26}

		String value = prop.getProperty("lisi");//获取键"lisi"的值
		sop("lisi value:"+value);
		prop.setProperty("lisi","16");//修改值
		sop("lisi value:"+prop.getProperty("lisi"));

		Set<String> names = prop.stringPropertyNames(); //stringPropertyNames()方法返回一个Set集合
		for(String s:names)
		{
			sop(s+".."+prop.getProperty(s));
		}
	}

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






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

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

字符打印流
PrintStream
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(System.out);//输出流
		PrintWriter out = new PrintWriter("PW.txt");//刷新只是对流而言的，此处不能用自动刷新。
		//PrintWriter out = new PrintWriter(new FileWriter("fw.txt"),true);将文件与流关联，可以自动刷新

		String line = null;

		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			//out.write("line:"+line.toUpperCase());//写到了缓冲区中
			out.println(line.toUpperCase());
			out.flush();//刷新只是对流而言的
		}

		/*
		PrintWriter(OutputStream out, boolean autoFlush) 
		  自动刷新。只能用于有换行标记的方法--println、printf或format方法。

		 PrintWriter out new PrintWriter(System.out,true);
		 String line = null;
		 while((line=bufr.readLine())!=null)
		 {
			if("over".equals(line))
				break;
			out.println(line.toUpperCase());
		 }
		*/

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







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

/*
序列流
SequenceInputStream
	对多个流进行合并
*/

class SequenceInputStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		Vector<FileInputStream> v = new Vector<FileInputStream>();
		//Vector中有Enumeration

		//将与文件关联的流存入集合中
		v.add(new FileInputStream("F:\\黑马程序员 Java\\第二十天\\days20\\s1.txt"));
		v.add(new FileInputStream("F:\\黑马程序员 Java\\第二十天\\days20\\s2.txt"));
		v.add(new FileInputStream("F:\\黑马程序员 Java\\第二十天\\days20\\s3.txt"));

		//将多个流合并 
		Enumeration<FileInputStream> en = v.elements();
		SequenceInputStream sis = new SequenceInputStream(en);

		FileOutputStream fos = new FileOutputStream("F:\\黑马程序员 Java\\第二十天\\days20\\s4.txt");

		byte[] buf = new byte[1024]; //建立缓冲区

		int len = 0;

		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}
		fos.close();
		sis.close();
	}
}







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

class SplitFile
{
	public static void main(String[] args) throws IOException
	{
		splitfile();
		merge();
	}

	public static void merge() throws IOException
	{
		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
		//Vector效率比较低

		for(int x=1;x<=3;x++)
		{
			al.add(new FileInputStream("F:\\黑马程序员 Java\\第二十天\\days20\\"+x+".part"));
		}

		Iterator<FileInputStream> it = al.iterator();

		Enumeration<FileInputStream> en = new Enumeration<FileInputStream>();
		{
			public boolean hasMoreElements()
			{
				return it.hasNext();
			}
			public FileInputStream nextElement()
			{
				return it.next();
			}
		};

		SequenceInputStream sis = new SequenceInputStream(en);

		FileOutputStream fos = new FileOutputStream("F:\\黑马程序员 Java\\第二十天\\days20\\0.mp3");

		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("F:\\黑马程序员 Java\\第二十天\\days20\\1.mp3");
		FileOutputStream fos = null;//输出流对象

		byte[] buf = new byte[1024*1024];//建立1m的缓冲区，以1m为单位切割

		int len = 0;
		int count = 1;

		while((len=fis.read(buf))!=-1)
		{
			fos = new FileOutputStream("F:\\黑马程序员 Java\\第二十天\\days20\\"+(count++)+".part");
			fos.write(buf,0,len);
			fos.close();
		}
		fis.close();
	}
}