黑马程序员----IO流（中）

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

IO流

1.File类

对文件和文件夹进行封装得到的类，我们知道在IO流中，文件或者文件夹是比较复杂的对象，如果不封装成对象的话，我们自己操作起来很费力，不过值得庆幸的是java把他们封装成了对象--File，使用该对象我们可以创建、删除、获取、判断等对文件或者文件夹进行一系列操作，而这些操作都是文件和文件夹最清楚，因此定在在File类中。

小知识点：

  separator字段：跟系统相关的名称分隔符（windows下就是\），使用这个字段代替"\\"，具有跨平台特性。

new出来的File对象还不是一个硬盘上的文件或者文件夹，而是存在于内存中的，只有当我们创建之后才会出现在硬盘上。

常用方法：

创建：
boolean createNewFile();在File对象路径属性指定位置创建文件，如果已有文件，则创建失败。
不同于输出流对象，输出流对象一创建，则文件也被创建。
boolean mkdir();创建一级文件夹。
boolean mkdirs();创建多级文件夹。
删除：
boolean delete();删除当前对象表示的文件。
void deleteOnExit();jvm退出时删除文件。
判断：
boolean exists();文件或文件夹是否存在（存在表示存在于硬盘上），该方法是很多其他判断方法的前提方法，也就是说例如我们判断一个File对象是否为文件，使用isFile()方法，但是之前我们应该先判断该文件或文件夹是否存在于硬盘，如果不存在，不管它是文件还是文件夹总是，isFile总是返回false。
boolean isDirectory();判断对象是否为一个文件夹。
boolean isFile();判断对象是否为一个文件。
boolean isHidden();判断对象是否为隐藏文件或文件夹。
进行这些判断前，先判断其是否存在。
boolean isAbsolute();
该判断不需要文件存在。
获取：
getName();获取对象名。
getPath();封装什么路径就返回什么。
getParent();在封装时如果没明确指定文件或文件夹的父目录，那么就返回null，例如：File("a.txt").parent();返回null。
getAbsolutePath();不管封装什么路径，都是返回绝对路径。
length();返回文件大小。
lastModified();最后一次修改时间。
修改：
renameTo(File dest);用dest对当前File对象进行重命名（如果路径有变化，那么就会有移动文件的效果）。
例如：new File("c:\\a.txt").renameTo(new File("d:\\b.txt"));就是将C盘下的a.txt移动到D盘，并改名为b.txt。
文件列表：
String[] list();列出当前对象下所有文件和文件夹，如果当前对象为文件，返回null。
String[] list(FilenameFilter filter);文件名过滤。accept(dir,name):dir表示当前目录，name表示其中所有文件名
*File[] listFiles();
*File[] listFiles(FilenameFilter filter);与list相比，返回的是文件和文件夹对象，而不只是名称。
开发中常用listFiles，因为它 返回的是File对象，而File对象 功能更强大，能对文件进行更多的操作。
File[] listRoots();列出系统根目录。

File类练习：

/*
测试File类方法
小练习：取出指定目录下指定后缀名的所有文件
*/
import java.io.*;
class FileDemo 
{
	public static void main(String[] args) throws IOException
	{
		listFiles_demo();
	}
	private static void create_demo()throws IOException
	{
		//File f1 = new File("ccc\\file.txt");
		File f1 = new File("file.txt");//此时f1还是不存在的
		f1.createNewFile();//执行这句后，f1出现在硬盘上，会报异常，当路径不存在时

		File f2 = new File("file\\file.txt");
		f2.mkdir();//创建目录，也就是文件夹，有后缀名的不一定是文件，还是需要判断的

		File f3 = new File("file\\temp\\temp\\temp\\file.txt");
		f3.mkdirs();//mkdir只能创建一级目录，而mkdirs可以创建多级目录
	}
	private static void delete_demo()throws IOException
	{
		File f=new File("delete.txt");
		//sop(f.mkdir());
		sop(f.createNewFile());//既调用了创建文件，又创建文件夹的话，只有第一句成功，其他失败
		sop("delete:"+f.delete());
		sop("delete:"+f.delete());//失败

		File f2=new File("deleteOnExit.txt");
		f2.mkdir();
		f2.deleteOnExit();
		try{Thread.sleep(3000);}catch(Exception e){}//使得jvm延迟3秒关闭，我们可以看到deleteOnExit.txt是先创建了，3秒后被删除
	}
	private static void judge_demo()throws IOException
	{
		File f=new File("temp");
		sop("exists："+f.exists());
		f.createNewFile();
		sop("exists："+f.exists());//判断是文件还是文件夹前，需要先判断是否存在，如果不存在，则怎么判断都是返回false
		sop("directory："+f.isDirectory());
		sop("file："+f.isFile());
		sop("hidden："+f.isHidden());
	}
	private static void get_demo()
	{
		File f1 = new File("file.txt");
		File f2 = new File("e:\\JavaProgram\\day20\\file2.txt");
		sop("f1 name:"+f1.getName());
		sop("f2 name:"+f2.getName());
		sop("f1 path:"+f1.getPath());
		sop("f2 path:"+f2.getPath());
		sop("f1 abspath:"+f1.getAbsolutePath());
		sop("f2 abspath:"+f2.getAbsolutePath());
		sop("f1 parent:"+f1.getParent());
		sop("f2 parent:"+f2.getParent());
		sop("f1 length:"+f1.length());
		sop("f2 length:"+f2.length());
		sop("f1 lastModified:"+f1.lastModified());
		sop("f2 lastModified:"+f2.lastModified());
	}
	private static void renameTo_demo()
	{
		File f1=new File("rename1.txt");
		File f2=new File("rename2.txt");
		f1.renameTo(f2);
	}
	private static void listRoots_demo()
	{
		for(File f : File.listRoots())//静态方法，列出所有可用盘符
		{
			sop(f);
		}
	}
	private static void list_demo_1()
	{
		File dir=new File("c:\\");
		for(String name : dir.list())//列出所有文件文件夹，包括隐藏的
		{
			sop(name);
		}
	}
	private static void list_demo_2()
	{
		//获取指定目录下所有.java文件
		File dir=new File("E:"+File.separator+"JavaProgram"+File.separator+"day19");
		String[] names=dir.list(new FilenameFilter(){
			public boolean accept(File dir,String name)
			{
				if(name.endsWith(".java"))return true;
				//文件以.java结尾，并且该对象是文件而不是文件夹，就返回真
				//小问题：如果一个文件夹名为xxx.java，那么也会被认为是一个java文件返回
				return false;
			}
		});
		for(String name : names)
		{
			sop(name);
		}
	}
	private static void listFiles_demo()
	{
		File dir=new File("d:\\");
		for(File file : dir.listFiles())
		{
			sop("name:"+file.getName()+"...length:"+file.length()+"...parent:"+file.getParent());
		}
	}
	private static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

运行图：

列出目录下所有内容，包括子目录中的内容（递归解决）：

//需求：获取到当前目录及其子目录下所有文件
//思路：递归
import java.io.*;
class FileTest 
{
	public static void main(String[] args) 
	{
		File root=new File("e:\\斗兽棋\\");
		//File root=new File("e:\\");
		printDir(root,1);
	}
	private static void printDir(File dir,int c)//目录名
	{
		System.out.println(dir.getName()+"：");
		File[] files=dir.listFiles();
		if(files.length<=0)
		{
			for(int j=0;j<c;j++)//每一行打印几个\t是不确定的，由c决定，c其实也就是递归深度。
				System.out.print("    ");
			System.out.println("|--空");
		}
		for(int i=0;i<files.length;i++)
		{
			for(int j=0;j<c;j++)//每一行打印几个\t是不确定的，由c决定，c其实也就是递归深度。
				System.out.print("    ");
				//System.out.print("\t");
			if(files[i].isFile())
				System.out.println("|--"+files[i].getName());
			if(files[i].isDirectory())
			{
				printDir(files[i],c+1);
			}
		}
	}
}

运行图：

删除一个有内容的目录（递归）：

思路：windows规定，不能直接删除一个有内容的文件夹，而是需要先将里面的所有文件都删除，这里我们就来使用递归来删除里面的所有内容。

//删除带内容的目录
/*
原理：从内往外删除
*/
import java.io.*;
class FileTest2 
{
	public static void main(String[] args) 
	{
		
		//System.out.println(new File("E:\\listFilesTest\\").delete());
		//直接删除失败，因为windows规定，如果文件夹不为空，不能直接删除
		//而是将其中内容全部删除后，再删除掉该文件夹

		deleteDir(new File("E:\\listFilesTest\\"));
	}
	private static void deleteDir(File dir)
	{
		if(dir.isHidden())return;//隐藏文件不删除
		for(File f : dir.listFiles())
		{
			if(f.isDirectory())
				deleteDir(f);//如果为文件夹，那么就调用本方法，传入该文件夹
			else
				f.delete();//删除一个文件夹中的文件
		}
		dir.delete();//删掉已经删掉所有内容的空文件夹，如果没有这句，那么删掉的只是文件，而文件夹被保留了下来
	}
}

运行图：

我们可以看到，listFilesTest文件夹已经不存在了，删除成功。

2.Properties类

HashTable的子类。
集合中与IO技术相结合的集合容器。该集合特点：可以用于操作硬盘上的键值对形式的配置文件 。

用法：与流结合，操作配置文件。从流中获取键值对，或者将一堆键值对存放到流中。

常用方法：

setProperty(),getProperty();这里的设置只是改变了内存中的键值对内容，而不是硬盘上的，如果也要改变硬盘上的，那么需要使用store方法。
load(InputStream)从流中获取键值对。
list(PrintStream)将键值对写入打印流中。
store(OutputStream,String注释)
store(Writer,String注释)将集合中键值对写入输出流中。

Properties类小练习：

//测试Properties常用方法
import java.io.*;
import java.util.*;
class PropertiesTest2 
{
	public static void main(String[] args)throws IOException 
	{
		method();
	}
	private static void method()throws IOException
	{
		//获取配置信息，更改后，打印，并将更改内容作用于硬盘的配置文件上
		Properties prop=new Properties();
		prop.load(new FileReader("info.txt"));
		prop.list(System.out);

		prop.setProperty("helong","22");//修改了helong的值
		prop.setProperty("zhaoliu","77");//增加了一对键值对

		prop.list(System.out);//我们发现，改变并没有体现在info.txt文件上，这是因为setProperty的修改只是针对内存而言

		prop.store(new FileWriter("info.txt"),"修改");//将集合内容写到输出流中，也就是硬盘上的文件上，"修改"为注释，不影响配置内容
		//会自动加上时间为注释
		//以#开头的一行在配置文件中为注释行，不会被加载到集合中
		//发现：无法识别中文
	}
}

运行图：

//将info.txt文件中的键值对存放到集合中
/*
思路：
1.使用流与info关联
2.使用=切割info
3.将切割后数据存放到Properties中
*/
import java.io.*;
import java.util.*;
class PropertiesTest 
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));
		Properties prop=new Properties();
		for(String line=bufr.readLine();line!=null;line=bufr.readLine())
		{
			String[] strs=line.split("=");
			if(strs.length==2)
				prop.setProperty(strs[0],strs[1]);
			else
				prop.setProperty(strs[0],"");
		}
		System.out.println(prop);

		Properties prop2=new Properties();
		prop2.load(new FileInputStream("info.txt"));//load用于从流中取出键值对
		prop2.list(System.out);//将集合中键值对写入流中
	}
}

运行图：

记录程序运行次数，如果达到10次，则给出注册信息，并不能使用程序：

/*
需求：记录程序运行次数，如果达到10次，则给出注册信息，并不能使用程序
*/
import java.io.*;
import java.util.*;
class PropertiesTest3 
{
	public static void main(String[] args) throws IOException
	{
		Properties prop=new Properties();//用于操作配置文件
		File file=new File("count.ini");//ini后缀名为windows配置文件后缀名
		if(!file.exists())//第一次运行程序时，配置文件不存在
		{
			file.createNewFile();
			prop.load(new FileReader(file.toString()));
			prop.setProperty("times","1");
			prop.store(new FileWriter(file.toString()),"used");
			System.out.println("程序正常运行.....");
		}
		else
		{
			prop.load(new FileReader(file.toString()));
			int value = Integer.parseInt(prop.getProperty("times"));
			if(value>=10)
				register();
			else
			{<span style="white-space:pre">	</span>System.out.println("您还能试用"+(10-value-1)+"次！");
				prop.setProperty("times",value+1+"");
				prop.store(new FileWriter(file.toString()),"used");
				System.out.println("程序正常运行.....");
			}
		}
	}
	private static void register()
	{
		System.out.println("请前往官网注册，获取注册码！！www.helong.com");
		System.out.println("注册码：......");
	}
}

运行图：

3.打印流

该流提供打印方法，可以将各种类型数据原样打印。
PrintStream:
构造函数接收参数类型：File,String字符串路径,OutputStream字节输出流。
非常常用PrintWriter:
构造函数接收参数类型：File,String字符串路径,OutputStream字节输出流，Reader字符输出流。

4.序列流

合并流--多个读取流对应一个输出流：
SequenceInputStream：从第一个串联的流文件开头读取，知道串联的最后一个流文件的结尾为止。
两个构造函数，如果合并两个流，使用SequenceInputStream(InputStream,InputStream)
如果合并多个流，使用SequenceInputStream(Enumeration<? extends InputStream> en)通常使用这个，由于使用到了Enumeration，因此是使用集合中的Vector类来存放多个流。

序列流练习：

//测试使用SequenceInputStream来将多个文件合并到一个新文件中
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("1.txt"));
		v.add(new FileInputStream("2.txt"));
		v.add(new FileInputStream("3.txt"));

		SequenceInputStream sis=new SequenceInputStream(v.elements());

		FileOutputStream fos=new FileOutputStream("123.txt");
		for(int b=sis.read();b!=-1;b=sis.read())
		{
			fos.write(b);
		}
		fos.close();
		sis.close();

	}
}

运行图：

5.切割组合文件

可以自己指定大小，每当读到足够大小时，写入文件，然后打开一个新的文件，这就是切割的原理。

/*
需求：切割一个bmp文件，按照1M，放到parts文件夹中
以碎片文件形式存放。
将多个碎片文件合并成原来的bmp文件，也放到parts文件夹中，
并能使用。
*/
import java.io.*;
import java.util.*;
class SplitMergeTest 
{
	public static void main(String[] args) throws IOException
	{
		//splitDemo();
		merge();
	}
	private static void merge()throws IOException
	{
		/*//使用Vector效率太低，因为它线程同步
		Vector<FileInputStream> v=new Vector<FileInputStream>();
		File f=new File("parts");
		for(File temp : f.listFiles())//取出文件夹中所有文件，放到集合中
			v.add(new FileInputStream(temp.getAbsolutePath()));
		SequenceInputStream sis=new SequenceInputStream(v.elements());
		*/
		
		ArrayList<FileInputStream> arr=new ArrayList<FileInputStream>();
		File f=new File("parts");
		for(File temp : f.listFiles())//取出文件夹中所有文件，放到集合中
			arr.add(new FileInputStream(temp.getAbsolutePath()));
		final Iterator<FileInputStream> it=arr.iterator();//it作为局部变量，被内部类访问，需要final修饰，当然JDK1.8后会自动加上final
		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("merge.jpg");
		byte[] by=new byte[1024];
		for(int len=sis.read(by);len!=-1;len=sis.read(by))
		{
			fos.write(by,0,len);
		}
		fos.close();
		sis.close();
	}
	private static void  splitDemo()throws IOException
	{
		FileInputStream fis=new FileInputStream("split.jpg");
		FileOutputStream fos=null;
		byte[] by=new byte[1024];
		out:for(int count=0,len=0;len!=-1;)
		{
			fos=new FileOutputStream("parts\\"+(++count)+".part");
			for(int i=0;i<300;i++)
			{
				len=fis.read(by);
				if(len==-1){fos.close();break out;}
				fos.write(by,0,len);
			}
			fos.close();
		}
		fis.close();
	}
}<strong style="color: rgb(0, 0, 153);">
</strong>

运行图：

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