首页  »   编程

黑马软件工程师——java基础——File类,打印流

网友分享于:2015-04-24  浏览:0次
黑马程序员——java基础——File类,打印流


黑马程序员——java基础——File类,打印流

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------


一,File类

用来将文件或者文件夹封装成对象
方便对文件与文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数。

File类常见方法:
1,创建。
 boolean createNewFile():在指定位置创建文件,如果该文件已经存在,则不创建,返回false。
      和输出流不一样,输出流对象一建立创建文件。而且文件已经存在,会覆盖。

 boolean mkdir():创建文件夹。
 boolean mkdirs():创建多级文件夹。
2,删除。
 boolean delete():删除失败返回false。如果文件正在被使用,则删除不了返回falsel。
 void deleteOnExit();在程序退出时删除指定文件。
3,判断。
 boolean exists() :文件是否存在.
 isFile():是否是文件
 isDirectory();是否是目录
 isHidden();是否隐藏文件
 isAbsolute();是否是绝对路径

4,获取信息。
 getName():获取文件名
 getPath():获取文件的相对路径
 getParent():获取文件父目录

 getAbsolutePath() :获取文件的绝对路径
 long lastModified() :获取文件的最后修改时间
 long length() :获取文件的长度

示例一:

public class FileDemo {
	public static void main(String[] args) throws IOException
	{
		//method_1();
		//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:"+f2.renameTo(f1));

	}

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

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

	}
	
	public static void method_3()throws IOException
	{
		File f = new File("d:\\abc\\abc\\file2.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());
		//sop("execute:"+f.canExecute());
		//创建文件夹
		File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");

		sop("mkdir:"+dir.mkdirs());
	}
	

	public static void method_1()throws IOException
	{
		File f = new File("file.txt");
//		sop("create:"+f.createNewFile());
		//sop("delete:"+f.delete());
	}
	//创建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);
	}
}
示例二:

public class FileDemo2 {

	public static void main(String[] args) {
		// listRootsDemo();
		// listDemo();
		// listDemo_2();
		File dir = new File("d:\\");
		File[] files = dir.listFiles();// ();//返回一个抽象路径名数组,获取当前文件夹下的所有文件和文件夹

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

	}

	// 练习:用String[] list(FilenameFilter filter)方法获取一个目录下所有的.bmp文件,其他文件不要。
	public static void listDemo_2() {
		File dir = new File("d:\\abc");

		String[] arr = dir.list(new FilenameFilter() {
			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");

			}
		});

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

	// 列出当前目录下所有文件,包括隐藏。调用list方法的file对象必须是封装了一个目录。该目录还必须存在。
	public static void listDemo() {
		File f = new File("c:\\abc.txt");

		String[] names = f.list();// 调用list方法的file对象必须是封装了一个目录。该目录还必须存在。
		for (String name : names) {
			System.out.println(name);
		}
	}

	// 列出可用的文件系统根目录,即系统盘符
	public static void listRootsDemo() {
		File[] files = File.listRoots();

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

}
递归

1、定义

       当函数内每一次循环还可以调用本功能来实现,也就是函数自身调用自身。这种表现形式,或者编程手法,称为递归。

2、递归注意事项

        a、限定条件。是来结束循环调用,否则是死循环。

        b、注意递归的次数,尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的方法,所以会不断在栈内存中开辟新空间,次数过多,会导致内存溢出。

示例一:

/*
 删除一个带内容的目录。
 删除原理:
 在window中,删除目录从里面往外删除的。
 既然是从里往外删除。就需要用到递归。
 */
public 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() + ":-file-:"
						+ files[x].delete());
		}

		System.out.println(dir + "::dir::" + dir.delete());
	}
}

示例二:

 

package com.founder.file;

import java.io.File;

/*
 需求:列出指定目录下文件或者文件夹,包含子目录中的内容。也就是列出指定目录下所有内容。

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

 */
public class FileDemo3 {

	public static void main(String[] args) {
		File dir = new File("d:\\abc");
		// showDir(dir,0);

		// toBin(6);
		// int n = getSum(8000);
		// System.out.println("n="+n);

		System.out.println(dir.delete());
	}

	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++;
		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]);
		}
	}
}

示例三:

/* 
 练习: 
 将一个指定目录下的java文件的绝对路径,存储到一个文本文件中。建立一个java文件列表的文件。 
 思路: 
 1、对指定的目录进行递归。 
 2、获取递归过程所有的java文件的路径。 
 3、将这些路径存储到集合中。 
 4、将集合中的数据写入到一个文件中。 
 */

public class JavaFileList {

	public static void main(String[] args) throws IOException {

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

		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());

	}

	// 获取指定文件夹内的所有java文件的绝对路径,并存入集合中
	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


PropertiesHashtable的子类,它具备Map集合的特点。而且它里面还有存储的键值对,都是字符串,无泛型定义。是集合中和IO技术想结合的集合容器。

特点:

        1)可用于键值对形式的配置文件

        2)在加载时,需要数据有固定的格式,常用的是:键=

方法

1、设置

        Object setProperty(String key,String value);

        //设置键和值,调用Hashtable的方法put

2、获取

        String getProperty(String key);

        //指定key搜索value

        Set<String> stringPropertyName();

        //返回属性列表的键集,存入Set集合

3、加载流和存入流

        void load(InputStream ism);

        //从输入字节流中读取属性列表(键和元素对)。又称将流中的数据加载进集合。

        void load(Readerreader);

        //从输入字符流中读取属性列表(键和元素对)。又称将流中的数据加载进集合。

        void store(OutputStreamout,String comments);

        //对应load(InputStream )将属性列表(键值对)写入输出流。comments属性列表的描述。

        void store(Writerwriter, String comments);

        //对应load(Reader)将属性列表(键值对)写入输出流。comments属性列表的描述。

示例一:

/*
Properties是hashtable的子类。
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点:可以用于键值对形式的配置文件。
那么在加载数据时,需要数据有固定格式:键=值。
*/
public 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 fis = new FileInputStream("info.txt");

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

		prop.setProperty("wangwu","39");
		FileOutputStream fos = new FileOutputStream("info.txt");
		prop.store(fos,"haha");

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

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

	}

	//演示,如何将流中的数据存储到集合中。
	//想要将info.txt中键值数据存到集合中进行操作。
	/*
		1,用一个流和info.txt文件关联。
		2,读取一行数据,将该行数据用"="进行切割。
		3,等号左边作为键,右边作为值。存入到Properties集合中即可。

	*/
	public static void method_1()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 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",89+"");
		Set<String> names = prop.stringPropertyNames();
		for(String s : names)
		{
			System.out.println(s+":"+prop.getProperty(s));
		}
	}


}

示例二:

/* 
 练习:
 用于记录应用程序运行次数。如果使用次数已到,那么给出注册提示。    
 分析: 
 很容易想到的是:计数器。可是该计数器定义在程序中,随着该应用程序的退出,该计数器也在内存中消失了。 
 所以要建立一个配置文件,用于记录该软件的使用次数。该配置文件使用键值对的形式。键值对数据是map集合。数据是以文件形式存储。使用io技术。那么map+io——>Properties。 
 */
public class RunCount {
	public static void main(String[] args) throws IOException {
		Properties prop = new Properties();

		File file = new File("counter.ini");
		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();

	}
}


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

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

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

public 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();
	}
}






相关解决方案

最新解决方案