黑马程序员—java基础学习--IO ( Input Output )流（二）

之前的学习已经深入的了解到了IO流中的读取及写入的常用操作，但是单单有这些操作是不够的，还需要文件的信息，java的io包中当然也提供了文件或者文件夹的信息，通过这些类能让我们更加深入的探讨IO流的神奇。

*File类

File类用来将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作。

File对象可以作为参数传递给流的构造函数。

File类的常见方法：

1，创建

boolean creatNewFile ( ) ; 在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立就会创建文件，而且文件已经存在会覆盖。

2，删除

boolean delete ( ) ; 删除失败，返回false

void deleteOnExit ( ) ; 在程序退出时删除指定文件

3，判断

boolean canExecute ( ) ; 判断是否可执行

boolean canRead ( ) ; 是否可读

boolean exists ( ) ; 文件是否存在

boolean mkdir ( ) ; 创建文件夹

boolean mkdirs ( ) ;创建多级文件夹

boolean isDirectory ( ) ; 判断是否为文件夹。记住，在判断文件是否是文件或者目录时，必须要判断该文件对象封装的内容是否存在

boolean isFile ( ) ;判断是否为文件。记住，在判断文件是否是文件或者目录时，必须要判断该文件对象封装的内容是否存在

boolean isHidden ( ) ; 判断是否为隐藏文件。

boolean isAbsolute ( ) ; 判断是否为绝对路径 

4，获取信息

getName ( ) ; 获取名称

getPath ( ) ; 获取路径

getParent ( ) ; 获取父目录。该方法返回的是绝对路径中的文件父目录，如果获取的是相对路径则返回null

getAbsolutePath ( ) ; 获取绝对路径 

long lastModified ( ) ; 获取最后一次修改时间

long length ( ) ; 获取文件大小

File入门方法演示代码：

import java.io.*;

class  FileDemo
{
	public static void main(String[] args) 
	{
		method_3();
		
	}
	public static void method_5()
	{
		File f1 = new File("c:\\a.txt");
		File f2 = new File("c:\\b.txt");	

		System.out.println("rename:"+f1.renameTo(f2));	//修改名称或者剪切文件
	}

	public static void method_4()
	{
		File f = new File("a.txt");
		System.out.println("path:"+f.getPath());	//获取相对路径
		System.out.println("abspath:"+f.getAbsolutePath());	//获取绝对路径
		System.out.println("parent:"+f.getParent());	//该方法返回的是绝对路径中的文件父目录，如果获取的是相对路径则返回null
														//如果相对路径中有上一层目录，那么该目录就是返回结果。
	}

	public static void method_3()
	{
		File f = new File("file.txt");
		
		//记住，在判断文件是否是文件或者目录时，必须要判断该文件对象封装的内容是否存在
		System.out.println("dir:"+f.isDirectory());
		System.out.println("file:"+f.isFile());
		System.out.println(f.isAbsolute());	//判断是否为绝对路径
	}

	public static void method_2()
	{
		File f = new File("file.txt");
		System.out.println("execute:"+f.canExecute());
		//创建文件夹
		File dir = new File("abc\\aa\\bb\\cc\\dd\\ee");
		System.out.println("mkdir:"+dir.mkdir());	//创建单级目录
	}

	public static void method_1()
	{
		File f = new File("file.txt");
		f.deleteOnExit();
		System.out.println("creat:"+f.creatNexFile());
		System.out.println("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");
		
		System.out.println("f1:"+f1);
		System.out.println("f2:"+f2);
		System.out.println("f3:"+f3);
	}
}

例题：使用File类遍历文件夹。包含子目录中的内容，也就是列出指定目录下的所有的内容。

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

递归要注意：

1，限定条件，如果不限定条件，则有可能成为死递。

2，要注意递归的次数，否则会出现内存溢出等情况。

import java.io.*;

class FileDemo3 
{
	public static void main(String[] args) 
	{
		File dir = new File("f:\\java");
		
		//将dir文件夹传入到遍历文件夹方法中
		listDirs(dir);


	}
	public static void listDirs(File dir)
	{
		//注意，直接打印dir对象，File对象的toString方法返回的是文件的路径名字符串
		System.out.println(dir);

		//使用文件数组接受传入的文件夹中的文件
		File[] files = dir.listFiles();

		//对数组进行遍历。
		for(File file : files)
		{
			if(file.isDirectory())
			{
				//使用到递归，如果是文件夹便重新走此流程
				listDirs(file);
			}
			else
				//如果不是目录，打印其路径
				System.out.println(file);
		}
	}
}

如下图代码所示，解释递归原理。

练习：

将一个指定目录下的java文件的绝对路径，储存到一个文本文件中。

建立一个java文件列表文件

思路：

1，对指定的目录进行递归

2，获取递归过程中所有的java文件的路径

3，将这些路径存储到集合中

4，将集合中的数据写入到一个文件中

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

class  javaFileList
{
	public static void main(String[] args) 
	{
		File dir = new File("f:\\java");
		File file = new File(dir,"java.txt");
		List list = new ArrayList();

		fileToList(dir,list);

		writeToFile(list,file.toString());//此处file的toString方法返回的为File对象的路径字符串形式
	}
	
	//结合IO流将集合中的对象遍历并使用字符流写入到文件中
	public static void writeToFile(List list,String javaListName)
	{

		BufferedWriter bufw = null;
		try
		{
			bufw = new BufferedWriter(new FileWriter(javaListName));
			for (File f: list )
			{
				String path = f.getAbsolutePath();
				bufw.write(path);
				bufw.newLine();
				bufw.flush();
			}

		}
		catch (IOException e)
		{
			throw new RuntimeException("文件读写失败");
		}
		finally
		{
			try
			{
				if(bufw!=null)
					bufw.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("关闭流失败");
			}
			
		}
	}
	
	//遍历文件夹，并向集合中添加文件对象
	public static void fileToList(File dir,List list)
	{
		File[] files = dir.listFiles();
		for(File file : files)
		{
			if(file.isDirectory())
			{
				fileToList(file,list);
			}
			else
			{
				if(file.getName().endsWith(".java"))
				{
					list.add(file);
				}
			}
		}
	}
}

*Properties

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

此对象是集合和IO技术相结合的集合容器。

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

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

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

class  PropertiesDemo
{
	public static void main(String[] args) throws IOException
	{
		loadDemo();
	}
	
	//Properties中有自己特有的方法，使得读取文件并非method_1方法麻烦
	public static void loadDemo() throws IOException
	{
		FileInputStream fis = new FileInputStream("info.txt");
		Properties prop = new Properties();

		//将流中的数据加载进集合
		prop.load(fis);
		
		//修改流中的数据（内存）
		prop.setProperty("wangwu","39");

		FileOutputStream fos = new FileOutputStream("info.txt");
		//将修改的数据存入到文件中
		prop.store(fos,"aa");

		//将流中的数据列出来
		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("=");
			prop.setProperty(arr[0],arr[1]);
		}
		bufr.close();

		System.out.println(prop);
	}
	
	//Properties的基本使用方法
	public static void setAndGet()
	{
		Properties prop = new Properties();
		prop.setProperty("zhangsan","30");
		prop.setProperty("lisi","39");

		String value = prop.getProperty("lisi");
		System.out.println(value);
		
		Set names = prop.stringPropertyNames();
		for(String name:names)
		{
			System.out.println(name+":"+prop.getProperty(name));
		}
	}
}

Properties练习：

用于记录应用程序运行次数，如果使用次数已到，那么给出注册提示。
分析得知：需要定义计数器，如果将计数器定义在程序中，随着程序的运行而在内存中存在并自增，可是随着应用程序的退出，该计数器也在内存中小时了。

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

我们需要程序即使结束，该计数器的值也要存在，下次程序启动在会先加载该计数器的值并加1后的重新存储起来，所以要建立一个配置文件，用于记录该软件的使用次数。

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

键值对数据是Map集合，数据是以文件形式存储，使用io技术，那么Map加IO即为Properties。

配置文件可以实现应用程序数据的共享。

代码如下：

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.properties");
		
		//程序的健壮性，若文件不存在则创建配置文件
		if(!file.exists())
			file.createNewFile();
		
		FileInputStream fis = new FileInputStream(file);
		//将prop对象与流相关联
		prop.load(fis);
		
		//定义计数器
		int count = 0;
		String value = prop.getProperty("time");
		
		if(value!=null)
		{
			count = Integer.parseInt(value);
			if(count>=5)
				System.out.println("5次试用已到期");
				throws
		}
		count++;
		
		//将配置文件信息输入到文件中
		prop.setProperty("time",count+"");
		
		//建立输出流，需要与prop对象想关联
		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

打印流的应用如下：

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

*序列流

序列流的用途：将多个读取流合并成一个读取流。

例题：将c盘下的多个txt文件合并为一个文件。

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

class SequenceDemo 
{
	public static void main(String[] args) throws IOException
	{
		Vector v = new Vector();
		v.add(new FileInputStream("c:\\1.txt"));
		v.add(new FileInputStream("c:\\2.txt"));
		v.add(new FileInputStream("c:\\3.txt"));
		
		//使用Enumeration接受Vector集合中的数据
		Enumeration en = v.elements();
		
		//序列流接受Enumeration类型的对象
		SequenceInputStream sis = new SequenceInputStream(en);

		FileOutputStream fos = new FileOutputStream("c:\\4.txt");
		
		byte[] buf = new byte[1024];
		int len = 0;
		while((len = sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}
		
		//流的关闭动作
		sis.close();
		fos.close();
	}
}

*操作对象

ObjectInputStream 与ObjectOutputStream

被操作的对象需要实现Serializable（标记接口）

注意：此流必须成对出现使用，可以将对象存入到文件中长久保存。代码如下：

import java.io.*;

class  Person implements Serializable
{
	//自定义UID进行标记，而非使用默认的UID。
	//给类定义固定标示，为序列化方便,静态不能序列化。
	public static final long serialVersionUID = 42L;

	String name;
	//被transient修饰后便不可以序列化。
	transient int age;
	static String country = "cn";
	Person(String name,int age,String country)
	{
		this.name = name;
		this.age = age;
		this.country = country;
	}

	public String toString()
	{
		return name+":"+age+":"+country;
	}
}


class ObjectStreamDemo
{
	public static void main(String[] args) throws Exception
	{
	//	writeObj();
		readObj();
	}

	public static void readObj() throws Exception
	{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.obj"));
		
		//读取对象
		Person p = (Person)ois.readObject();

		System.out.println(p);

		//关闭流
		ois.close();
	}

	public static void writeObj() throws IOException
	{
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.obj"));
		
		//将对象存入文件中
		oos.writeObject(new Person("lisi",39));
		
		//关闭流
		oos.close();
	}

}

*管道流

PipedInputStream和PipedOutputStream

输入输出可以直接进行连接，通过结合线程使用。

import java.io.*;

class Read implements Runnable
{
	private PipedInputStream in;
	Read(PipedInputStream in)
	{
		this.in = in;
	}
	//将多线程代码写入到run方法中
	public void run()
	{
		try
		{
			byte[] buf = new byte[1024];
			
			//阻塞试方法，等待读取数据
			int len = in.read(buf);

			String s = new String(buf,0,len);
			System.out.println(s);
			
			//关闭管道流
			in.close();
		}
		catch (IOException e)
		{
			throw new RuntimeException("管道读取失败");
		}
	}
}

class Write implements Runnable
{
	private PipedOutputStream out;
	Write(PipedOutputStream out)
	{
		this.out = out;
	}
	
	//多线程技术将多线程代码写入到run方法中
	public void run()
	{
		try
		{
			//线程等待6s
			Thread.sleep(6000);
			//写入数据
			out.write("piped 来了".getBytes());
			out.close();
		}
		//因涉及到多线程，所以抛出的异常并非只有IOException
		catch (Exception e)
		{
			throw new RuntimeException("管道输出失败");
		}
	}
}

class  PipedStreamDemo
{
	public static void main(String[] args) 
	{
		//建立管道流对象
		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream();
		
		Read r = new Read(in);
		Write w = new Write(out);
		//开启线程
		new Thread(r).start();
		new Thread(w).start();

	}
}

*RandomAccessFile

此类文件的示例支持对随机文件的读取和访问，该类不算是IO体系中子类，而是直接继承自Object。

但是它是IO包中的成员，因为它具备读写功能，内部封装了一个数组，而且通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：只读 r   读写rw等

而且该对象的构造函数要操作的文件不存在，会自动创建。如果存在则不会覆盖。

如果模式为只读r，则不会创建文件，会读取一个已存在文件，如果文件不存在，则会出现异常。

如果模式为读写rw，操作文件不存在则会自动创建，如果文件存在则不会覆盖。

import java.io.*;

class  RandomAccessFileDemo 
{
	public static void main(String[] args) throws IOException
	{
		writeFile_2();
	}
	
	public static void readFile() throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","R");
		//此处出现异常，因为模式选择的为读取并非写入。
	//	raf.write("haha".getBytes());

		//调整对象中的指针。
		//raf.seek(8);

		//跳过指定的字节数
		raf.skipBytes(8);

		byte[] buf = new byte[4];
		raf.read(buf);
		String name = new String(buf);
		
		int age = raf.readInt();

		System.out.println(name+":"+age);

		raf.close();
	}

	public static void writeFile() throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

		raf.write("李四".getBytes());
		//使用write方法是写入的是对应的码
		raf.writeInt(97);
		
		raf.write("wangwu".getBytes());
		raf.writeInt(99);

		raf.close();
	}

	public static void writeFile_2() throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
		
		//调整指针位置，并可以对对象进行修改。
		raf.seek(8*3);

		raf.write("周七".getBytes());
		raf.write(103);
		raf.close();
	}


}

*DataInputStream和DataOutputStream

可以用于操作基本数据类型的数据的流对象

import java.io.*;

class  DataStreamDemo
{
	public static void main(String[] args) throws IOException,Exception
	{
		writeFile();
	//	readFile();
		writeUTFDemo();
		readUTFDemo();
	}

	public static void readUTFDemo() throws Exception
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("utfdate.txt"));
		//必须使用本方法才可读出writeUTF方法写入的字符串
		String s = dis.readUTF();
	
		System.out.println(s);
		
		//关闭流
		dis.close();
	}

	public static void writeUTFDemo()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));
		//此方法写入的是utf-8的修改版，使用utf-8的字符集读不出来需要指定的方法才能读出
		dos.writeUTF("你好");
		//关闭流
		dos.close();
	}

	public static void writeFile()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
		
		//对基本数据类型进行写入
		dos.write(123);
		dos.writeBoolean(true);
		dos.writeDouble(9228.223);
		
		//对流的关闭
		dos.close();

	}

	public static void readFile()throws IOException
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
		
		//对基本数据类型按照顺序读取
		int num = dis.readInt();
		boolean b = dis.readBoolean();
		double d = dis.readDouble();

		System.out.println(num);
		System.out.println(b);
		System.out.println(d);

		//流关闭
		dis.close();
	}
}

*操作数组的流对象

可以用于直接操作字节数组数据的流对象。

ByteArrayInputStream：在构造的时候，需要接受数据源，而且数据源是一个字节数组。

ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源，所以不用进行close关闭动作

在刘操作规律讲解时：

源设备：

键盘System.in  硬盘FileStream  内存ArrayStream

目的设备：

控制台System.out  硬盘FileStream  内存ArrayStream

用流的读写思想来操作数组。

操作字符数组的流：CharArrayReader和CharArrayWrite

操作字符串的流：StringReader与StringWriter

import java.io.*;

class  ByteArrayStream
{
	public static void main(String[] args) 
	{
		//数据源
		ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFG".getBytes());
		//数据目的
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		
		int by = 0;
		while((by = bis.read())!=-1)
		{
			bos.write(by);
		}
		System.out.println(bos.size());

		System.out.println(bos.toString());
		//无需关闭资源和异常处理，因为未调用系统资源。
	}
}

*字符编解码

编码：字符串变成字节数组。

解码：字节数组变成字符串。

String-->byte[]： str.getBytes()

byte[]-->String： new String(byte[ ] , charsetName);

解码选择错误如何修正？比如解码选择了iso8859-1时，但是需要注意的是，如若解码选择的UTF-8，则此方法行不通

代码如下：

import java.util.*;

class  EncodeDemo
{
	public static void main(String[] args) throws Exception
	{
		String s = "你好";
		byte[] b1 = s.getBytes("gbk");	//编码，不传入编码集时默认编码为gbk
		System.out.println(Arrays.toString(b1));	
	
		//解码操作
		String s1 = new String(b1,"iso8859-1");
		System.out.println(s1);
		
		//再次进行编码操作
		byte b2 = s1.getBytes("iso8859-1");
		System.out.println(Arrays.toString(b2));	

		//使用正确的解码集进行解码
		String s2 = new String(b2,"gbk");
		System.out.println(s2);

	}
}