Java基础<十六>---> IO之其他流对象

第一  File类

一、概述：File类是有文件或文件件封装而来的对象，可以操作其属性信息，这个类的出现弥补了流的不足，流只能操作数据

1、特点：

1）用来将文件或文件夹封装成对象

2）方便于对文件与文件夹的属性信息进行操作

3）File对象可以作为多数传递给流的构造函数

2、File类常见方法：
1、创建。
boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
2、删除。
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回false。
void deleteOnExit();在程序退出时删除指定文件。
3、判断。
boolean exists() :文件是否存在.
isFile():是否是文件
isDirectory();是否是目录
isHidden();是否是隐藏的对象
isAbsolute();//判断是否是绝对路径
4、获取信息。
getName():获取对象名字
getPath():获取路径，存的是什么路径就是什么路径
getParent():文件夹路径
getAbsolutePath() 获取绝对路径getpath()+getparent();
long lastModified() 文件最后一次被修改的时间
long length() 返回文件的长度

实例：

public class FileDemo {
	public static void main(String[] args) {
//		consMethod();
//		method();
//		listFilesDemo();
//		File dir = new File("E:\\develop\\eclipse space\\android workspace\\Test_java\\src");
//		showDir(dir);
//		method_1();
//		method_2(100);
	}
	
	/**
	 * 获取指定文件名称的文件名
	 */
	public static void method(){
		File dir = new File("C:\\");
		String[] names = dir.list(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
//				System.out.println("dir:" + dir + ".....name::" + name);
				return name.endsWith(".txt");
			}
		});
		
		System.out.println("list.len:::" + names.length);
		for(String name : names){
			System.out.println(name);
		}
	}

	
	/**
	 * listFiles()方法返回File对象
	 */
	public static void listFilesDemo(){
		File dir = new File("C:\\");
		File[] files = dir.listFiles();
		for(File f : files){
			System.out.println(f.getName() + "..." + f.length());
		}
	}
	
	/**
	 * 构造方法演示
	 */
	public static void consMethod(){
		//创建file对象，可以将已有的和未出现的文件或目录封装成对象
		File f1 = new File("C:" + File.separator + "a.txt");//File.separator跨平台的目录分隔符
		File f2 = new File("c:\\abc","b.txt");//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类的一些常用方法
	 */
	public static void method_1(){
		File f = new File("file.txt");
		//exists()方法查看文件或目录是否存在
		System.out.println("exists:" + f.exists());
		//测试应用程序是否可以执行此抽象路径名表示的文件。
		System.out.println("canExecute:" + f.canExecute());
		//创建文件夹
//		File dir = new File("C:\\ab\\c\\v\\g");
//		System.out.println("mkdir:" + dir.mkdir());//最多只能创建两级目录,已经存在或失败返回false
//		System.out.println("mkdirs:" + dir.mkdirs());//创建多级目录
		
		File f1 = new File("c:\\ab\\d.java");
		try {
			f1.createNewFile();//createNewFile创建新文件
		} catch (IOException e) {
			e.printStackTrace();
		}
		//判断文件对象是否是文件或目录时，必须要先判断文件对象封装内容是否存在
		//通过exists方法
		System.out.println("isDir:" + f1.isDirectory());//是否是目录
		System.out.println("isFile:" + f1.isFile());//是否是文件
		
		//获取路径
		System.out.println("path: " + f1.getPath());
		System.out.println("abspath: " + f1.getAbsolutePath());
		System.out.println("parent: " + f1.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
		//如果相对路径中有上一层目录那么该目录就是返回结果。
		
		//重命名，其实就是远文件再创建一个新文件，再把内容写入文件
		File f2 = new File("c:\\ab\\d.java");
		File f3 = new File("c:\\d.java");
		System.out.println("rename:" + f2.renameTo(f3));
	}
}

二、递归：对于每次循环都是用同一个功能的函数，即函数自身调用自身，这种表现形式或手法，称为递归。

注意：

1、限定条件，是作为结束循环用的，否则是死循环

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

实例一：求和和求二进制

/**
	 * 递归方法演示
	 */
	public static int method_2(int num){
//		//求和
//		if(num == 1){
//			return 1;
//		}
//		return num + method_2(num - 1);
		
		//求二进制
		StringBuilder sb = new StringBuilder();
		if(num > 0){
			method_2(num/2);
			int i = num%2;
			sb.append(i);
		}
		System.out.println(sb.toString());
		return -1;
	}

实例二：显示所有目录下的文件，也就是说只要是目录就被循环

思路：既然要显示所有文件，就是要循环每一个文件夹，找出所有文件，这里操作文件夹的动作都是一样的，所有需要用到递归：

/**
	 * 显示所有目录下的文件，也就是说只要是目录就被循环
	 * 这里用到了递归调用
	 */
	public static void showDir(File dir){
		System.out.println(dir);
		File[] files = dir.listFiles();
		for(File f : files){
			if(f.isDirectory()){
				showDir(f);
			}else{
				System.out.println(f);
			}
		}
	}

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

思路：
  1、对指定目录进行递归
  2、获取递归过程中所有的java文件
  3、把路径存放在集合中
  4、把集合中的数据写入文件

/*
 * 将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
 * 
 * 思路：
 * 1、对指定目录进行递归
 * 2、获取递归过程中所有的java文件
 * 3、把路径存放在集合中
 * 4、把集合中的数据写入文件
 */
public class JavaFileList {
	public static void main(String[] args) {
		// 指定查找路径
		File dir = new File(
				"E:\\develop\\eclipse space\\android workspace\\Test_java");
		// 定义集合用于存储取到的java路径
		List<File> list = new ArrayList<File>();
		fileToList(dir, list);// 调用查找文件方法
		// System.out.println(list.size());

		// 指定写入文件路径
		File file = new File("c:\\", "javalist.txt");
		writeToFile(list, file.toString());// 调用写入文件的方法
	}

	/*
	 * 获取指定目录下的java文件
	 */
	public static void fileToList(File dir, List<File> list) {
		File[] files = dir.listFiles();// 返回该目录下的文件对象
		for (File f : files) {
			if (f.isDirectory()) {
				fileToList(f, list);
			} else {
				if (f.getName().endsWith(".java"))
					;// 找出java文件
				list.add(f);
			}
		}
	}

	/*
	 * 将数据写入文件中
	 */
	public static void writeToFile(List<File> list, String filepath) {
		BufferedWriter bfw = null;
		try {
			bfw = new BufferedWriter(new FileWriter(filepath));

			for (File f : list) {
				String path = f.getAbsolutePath();// 获取文件绝对路径
				bfw.write(path);
				bfw.newLine();
				bfw.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (bfw != null) {
				try {
					bfw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

第二  Properties类

一、概述：

1、Properties是Hashtable的子类，也就是map集合的子类，所有具备Map集合的特点，而且它里面还有存储的键值对，都是字符串，无泛型定义。是集合中和IO技术相结合的集合容器。

2、特点：

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

2）在加载时，需要数据有固定的格式，常用的是：键=值

二、特有方法：

1、设置和获取元素：

Object setProperty(String key,String value)调用Hashtable 的方法put，将键和值存入到properties对象中

String getProperty(String key)用指定的键在此属性列表中搜索属性

Set<String> stringPropertyName()返回此属性列表中的键集

void load(InputStream ism)从输入流中读取属性列表（键和元素对）。

void load(Reader reader)按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

实例：

/*
 * Properties是hashtable的子类
 * 也就是说它具备map集合的特点，而且它里面存放的键值对都是字符串
 * 是集合和IO技术相结合的集合容器
 * 该对象的特点可以用于键值对形式的配置文件
 * 那么在加载时需要数据有固定的格式：键=值
 * 
 */
public class ProPertiesDemo {
	public static void main(String[] args) {
		getAndSet();
//		method();
		loadDemo();
	}
	
	/*
	 * 设置和获取元素。
	 */
	public static void getAndSet(){
		Properties pro = new Properties();
		
		pro.setProperty("zhangsan", "20");
		pro.setProperty("lisi", "30");
		System.out.println(pro);
		
		String value = pro.getProperty("lisi");
		System.out.println("getProperty: " + value);
		pro.setProperty("lisi", "90");
		
		Set<String> names = pro.stringPropertyNames();
		for(String name : names){
			System.out.println(name + "::" + pro.getProperty(name));
		}
		
	}
	
	/*
	 * 演示如何将流中的数据存储到集合中
	 * 想要将info.txt中的数据存放在集合中进行操作
	 * 
	 * 思路：
	 * 1、用流关联info.txt文件
	 * 2、读取一行数据，将改行数据用“=”切割
	 * 3、将等号左边作为键，右边作为值存放到properties集合中
	 */
	public static void method(){
		BufferedReader bfr = null;
		Properties pro = null;
		try {
			bfr = new BufferedReader(new FileReader("info.txt"));
			pro = new Properties();
			
			String line = null;
			while((line=bfr.readLine()) != null){
//				System.out.println(line);
				String[] arr = line.split("=");
				pro.setProperty(arr[0], arr[1]);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bfr != null){
				try {
					bfr.close();
					System.out.println(pro);
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	/*
	 * 用Properties对象提供的方法加载文件中的键值对
	 */
	public static void loadDemo(){
		Properties pro = new Properties();
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("info.txt");
			//用properties的load方法把流中的数据加载进集合
			pro.load(fis);
			System.out.println(pro);
			
			//修改
			pro.setProperty("wangwu", "90");//这里修改只是在内存中，而没有修改文件
			fos = new FileOutputStream("info.txt");
			//通过store方法将修改的数据修改到文件中区
			pro.store(fos, "change comments");
			
			pro.list(System.out);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

练习：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。

/*
 * 练习：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。
 */
public class RunCountTest {

	public static void main(String[] args) {
		// method();
		tMethod();
	}

	/*
	 * 我的思路： 程序没运行一次，就在相应的文件中写入一次记录，每次运行都去读取文件记录， 当文件中的记录达到五条是，就限制程序再运行
	 */
	public static void method() {
		Properties pro = new Properties();
		FileOutputStream fos = null;
		FileInputStream fis = null;
		int i = 0;
		try {
			// 读取数据
			fis = new FileInputStream("info.txt");
			pro.load(fis);
			Set<String> names = pro.stringPropertyNames();
			i = names.size() + 1;
			System.out.println(names.size());
			if (names.size() == 5) {
				throw new RuntimeException("请您注册");
			}

			// 写入数据
			i++;
			fos = new FileOutputStream("info.txt", true);
			pro.setProperty(i + "", "key");
			pro.store(fos, "comments");

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/*
	 * 老师的思路 很容易想到的是:计数器。 可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
	 * 可是随着该应用程序的退出，该计数器也在内存中消失了。
	 * 
	 * 下一次在启动该程序，又重新开始从0计数。 这样不是我们想要的。
	 * 
	 * 程序即使结束，该计数器的值也存在。 下次程序启动在会先加载该计数器的值并加1后在重新存储起来。
	 * 
	 * 所以要建立一个配置文件。用于记录该软件的使用次数。
	 * 
	 * 该配置文件使用键值对的形式。 这样便于阅读数据，并操作数据。
	 * 
	 * 键值对数据是map集合。 数据是以文件形式存储，使用io技术。 那么map+io -->properties.
	 * 
	 * 配置文件可以实现应用程序数据的共享。
	 */
	public static void tMethod() {
		Properties pro = new Properties();

		// 需要操作文件，用File对象判断文件是否存在
		File file = new File("count.ini");
		FileInputStream fis = null;
		FileOutputStream fos = null;

		if (!file.exists()) {
			try {
				file.createNewFile();// 不存在就创建一个
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		try {
			fis = new FileInputStream(file);
			pro.load(fis);// 将流中的数据加载进文件

			// 定义计数器
			int count = 0;
			// 获取计数器
			String value = pro.getProperty("time");

			if (value != null) {
				count = Integer.parseInt(value);
				if (count >= 5) {
					System.out.println("请您注册");
					return;
				}
			}

			count++;
			pro.setProperty("time", count + "");

			fos = new FileOutputStream(file);
			pro.store(fos, null);// 写入文件
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

第三  打印流

一、概述：

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

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

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

实例：

public class PrintStreamDemo {
	public static void main(String[] args) {
		method();
	}

	public static void method() {
		BufferedReader bfr = new BufferedReader(
				new InputStreamReader(System.in));

		// PrintWriter out = new
		// PrintWriter(System.out);//PrintStream(OutputStream out)
		// PrintStream(OutputStream out, boolean autoFlush)
		// autoFlush - boolean 变量；如果为 true，则每当写入 byte 数组、调用其中一个 println
		// 方法或写入换行符或字节 ('\n') 时都会刷新缓冲区
		// PrintWriter out = new PrintWriter(System.out, true);//输出到控制台

		// 输出到文件
		PrintWriter out = null;
		try {
			// PrintStream(File file)和PrintStream(OutputStream out, boolean
			// autoFlush)结合
			out = new PrintWriter(new BufferedWriter(new FileWriter("a.txt")),
					true);
		} catch (IOException e1) {
			e1.printStackTrace();
		}

		String line = null;
		try {
			while ((line = bfr.readLine()) != null) {
				if (line.equals("over")) {
					break;
				}
				out.println(line.toUpperCase());
				// out.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (bfr != null) {
				try {
					bfr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (out != null) {
				out.close();
			}
		}
	}
}

第四  合并流

一、概述：

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

二、如何合并多个文件：

1、创建集合，并将流对象添加进集合或者SequenceInputStream(InputStream s1,InputStream s2)加入两个输入流

2、创建Enumeration对象，将集合元素加入。

3、创建SequenceInputStream对象，合并流对象

4、创建写入流对象，FileOutputStream，将数据写入流资源

5、定义数组，将读取流数据存入数组，并将数组中元素写入文件中。

实例：

/*
 * SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，
 * 直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。 
 */
public class SequenceInputStreamDemo {
	public static void main(String[] args) {
		Vector<FileInputStream> vector = new Vector<FileInputStream>();
		
		//sequenceinputstream操作多个对象
		SequenceInputStream sequence = null;
		BufferedOutputStream bfos = null;
		try {
			vector.add(new FileInputStream("1.txt"));
			vector.add(new FileInputStream("2.txt"));
			vector.add(new FileInputStream("3.txt"));
			
			//通过vector获取枚举Enumeration
			Enumeration<FileInputStream> enumeration = vector.elements();
			
			sequence = new SequenceInputStream(enumeration);
			
			FileOutputStream fos = new FileOutputStream("4.txt");
			bfos = new BufferedOutputStream(fos);
			byte[] byf = new byte[1024];
			
			int len = 0;
			while((len = sequence.read(byf)) != -1){
				bfos.write(byf,0,len);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(sequence != null){
				try {
					sequence.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bfos != null){
				try {
					bfos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

6、切割文件

重点，定义一个你需要把文件切成多大的数组，然后把数据读到数组中，读满后写出到文件中，这样就完成了切割：

/*
 * 文件的切割和合并
 */
public class SplitFile {
	public static void main(String[] args) throws IOException {
//		splitFile();
		sequence();
	}
	
	/*
	 * 切割文件
	 */
	public static void splitFile() throws IOException
	{
		FileInputStream fis = new FileInputStream("0.jpg");
		FileOutputStream fos = null;
		
		byte[] byf = new byte[1024*1024];//定义需要切割大小的空间
		
		int len = 0;
		int count = 1;//为文件取名用的数字
		while((len=fis.read(byf)) != -1){
			fos = new FileOutputStream((count++) + ".patch");//创建指定的文件
			fos.write(byf,0,len);//把读取到的数据写入指定的文件中
			fos.close();//关闭资源
		}
		fis.close();//关闭资源
	}
	
	/*
	 * 合并文件
	 */
	public static void sequence() throws IOException{
		ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();
		list.add(new FileInputStream("1.patch"));
		list.add(new FileInputStream("2.patch"));
		list.add(new FileInputStream("3.patch"));
		
		//通过迭代器方法获取枚举
		final Iterator<FileInputStream> it = list.iterator();//内部类使用的成员变量必须是final修饰的
		
		//通过内部类实现枚举
		Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {
			
			@Override
			public FileInputStream nextElement() {
				return it.next();
			}
			
			@Override
			public boolean hasMoreElements() {
				return it.hasNext();
			}
		};
		
		SequenceInputStream sequence = new SequenceInputStream(en);
		
		FileOutputStream fos = new FileOutputStream("10.jpg");
		
		byte[] byf = new byte[1024];
		int len = 0;
		while((len=sequence.read(byf)) != -1){
			fos.write(byf,0,len);
		}
		sequence.close();
		fos.close();
	}
}

第五  Objectstream

一、概述：

ObjectStream是可以操作对象的流。它的写方法是ObjectOutputStream，读方法是ObjectInputStream。它主要操作的是对象，而对象中也能封装数据，所以它也具备操作基本数据类型的方法。被它操作的对象必须是实现了序列化的对象也就是Serializable接口，但是输入流还多支持一种Externalizable 接口的对象。

实例：

/*
 * 对对象进行读写操作
 */
public class ObjectstreamDemo {
	public static void main(String[] args) throws Exception {
//		writeObj();
		readObj();
	}
	
	/*
	 * 写对象
	 */
	public static void writeObj() throws Exception{
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.object"));
		
		oos.writeObject(new Person("zhangsan", 23, "ASC"));
		oos.close();
	}
	
	/*
	 * 读取对象
	 */
	public static void readObj() throws Exception{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.object"));
		
		Person p = (Person) ois.readObject();
		System.out.println(p);
		ois.close();
	}
}

用作被操作的类：

/*
 * 用作对象的持久化存储，也就是用流存放到硬盘上
 * 
 * 静态不能被序列化
 * transient关键字修饰的不能被序列化
 */
public class Person implements Serializable//实现这个接口，让该类被序列化
{
	//给类指定一个序列化标识，方便序列化，不定义会自动生成一个
	private static final long serialVersionUID = 42L;
	
	private String name;
	private int age;
	private static String country = "cn";
	
	Person(String name, int age, String country){
		this.name = name;
		this.age = age;
		Person.country = country;
	}
	
	public String toString(){
		return name+":"+age+":"+country;
	}
}

第六  管道流

一、概述：

可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。通常，数据由某个线程写入PipedOutputStream 对象，并由其他线程从连接的PipedInputStream 读取。不建议对这两个对象尝试使用单个线程，因为这样可能会造成该线程死锁。如果某个线程正从连接的管道输入流中读取数据字节，但该线程不再处于活动状态，则该管道被视为处于毁坏状态

二、使用步骤：

1、要先创建一个读和写的两个类，实现Runnable接口，因为是两个不同的线程，覆盖run方法，注意，需要在内部处理异常，因为重写run方法

2、创建两个管道流，并用connect()方法将两个流连接

3、创建读写对象，并传入两个线程内，并start执行

实例：

/*
 * 管道流
 * 用多线操作，单线程容易造成死锁
 */
public class PipedStreamDemo {
	public static void main(String[] args) throws IOException {
		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream();
		in.connect(out);

		Read r = new Read(in);
		Write w = new Write(out);

		new Thread(r).start();
		new Thread(w).start();
	}

}

class Write implements Runnable {
	private PipedOutputStream out;

	Write(PipedOutputStream out) {
		this.out = out;
	}

	@Override
	public void run() {
		try {
			Thread.sleep(4000);
			out.write("piped stream come".getBytes());
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

class Read implements Runnable {
	private PipedInputStream in;

	Read(PipedInputStream in) {
		this.in = in;
	}

	@Override
	public void run() {
		byte[] byf = new byte[1024];
		int len = 0;

		try {
			while ((len = in.read(byf)) != -1) {
				String str = new String(byf, 0, len);
				System.out.println(str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

第七  RandomAccessFile

一、概述：

1、RandomAccessFile称之为随机访问文件的类，自身具备读写方法。

2、该类不算是IO体系中的子类，而是直接继承Object，但是它是IO包成员，因为它具备读写功能，内部封装了一个数组，且通过指针对数组的元素进行操作，同时可通过seek改变指针的位置。

3、可以完成读写的原理：内部封装了字节输入流

4、构造函数：RandomAccessFile(File file,String mode)，可已从它的构造函数中看出，该类只能操作文件（也有字符串），而且操作文件还有模式。

模式传入值：”r“：以只读方式打开；”rw“：打开以便读写

如果模式为只读，则不会创建文件，会去读一个已存在的文件，若文件不存在，则会出现异常，如果模式为rw，且该对象的构造函数要操作的文件不存在，会自动创建，如果存在，则不会覆盖，也可通过seek方法修改。

二、特有方法：

1、seek(int n)：设置指针，可以将指针设置到前面或后面

2、skipBytes(int n)：跳过指定字节数，不可往前跳

实例：

/*
 * 随机访问文件的类
 * 该类不算是IO体系中子类。而是直接继承自Object。
 * 但是它是IO包中成员。因为它具备读和写功能。
 * 内部封装了一个数组，而且通过指针对数组的元素进行操作。
 * 可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。
 * 
 * 其实完成读写的原理就是内部封装了字节输入流和输出流。
 * 通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式：只读r，，读写rw等。
 * 如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
 * 如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。
 */
public class RandomAccessFileDemo {
	public static void main(String[] args) throws IOException {
		writeFile();
//		readFile();
	}
	
	public static void writeFile() throws IOException{
		RandomAccessFile raf = new RandomAccessFile("random.txt","rw");
		
		raf.write("张三".getBytes());
		raf.writeInt(97);//write方法只读取最低8位
		raf.write("李四".getBytes());
		raf.writeInt(98);
		
		//********往指定位置上存储数据,也可以修改数据
		raf.seek(8*4);
		raf.write("王五".getBytes());
		raf.writeInt(103);
		
		raf.close();
	}
	
	public static void readFile() throws IOException{
		RandomAccessFile raf = new RandomAccessFile("random.txt","r");
		
		//调整对象中的指针
//		raf.seek(8*1);//根据数组定，数组大小*跳几个
		
		//跳过指定的字节数，只能向前不能向后
		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();
	}
}

第八  DataStream

一、概述：

DataStream是可以用于操作基本数据类型的数据的流对象：DataInputStream与DataOutputStream，它主要的特点就是操作基本数据类型。

实例：

/*
 * DataInputStream与DataOutputStream
 * 
 * 可以用于操作基本数据类型的数据的流对象。
 */
public class DataStreamDemo {
	public static void main(String[] args) throws IOException {
//		write();
//		read();
//		writeUTF();
		readUTF();
		
		//一般加入编码的方法
//		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");
//		osw.write("你好");
//		osw.close();
	}
	
	public static void write() throws IOException{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
		
		dos.writeInt(236);
		dos.writeBoolean(false);
		dos.writeDouble(2323.02154);
		
		dos.close();
	}
	
	public static void read() throws IOException{
		DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
		
		int i = dis.readInt();
		boolean b = dis.readBoolean();
		double d = dis.readDouble();
		
		System.out.println("int: " + i);
		System.out.println("boolean: " + b);
		System.out.println("double: " + d);
		
		dis.close();
	}
	
	//加入了改编后的UTF-8编码，所以只有它自己能读
	public static void writeUTF() throws IOException{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
		
		dos.writeUTF("你家婆");
		
		dos.close();
		
	}
	
	public static void readUTF() throws IOException{
		DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));
		
		String s = dis.readUTF();
		System.out.println(s);
		
		dis.close();
		
	}
	
}

第九  ByteArraytStream

一、概述：

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

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

注：因为这两个流对象都操作的数组，并没有使用系统资源。所以，不用进行close关闭，而且关闭也是无效的。

源设备，
  键盘 System.in，硬盘 FileStream，内存 ArrayStream
  目的设备：
   控制台 System.out，硬盘FileStream，内存 ArrayStream。

/*
 * ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。
 * ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。
 * 这就是数据目的地。
 * 
 * 因为这两个流对象都操作的数组，并没有使用系统资源。
 * 所以，不用进行close关闭，而且关闭也是无效的。
 * 
 * 源设备，
 * 	键盘 System.in，硬盘 FileStream，内存 ArrayStream
 * 目的设备：
 * 	控制台 System.out，硬盘FileStream，内存 ArrayStream。
 */
public class ByteArrayStreamDemo {
	public static void main(String[] args) {
		//数据源
		ByteArrayInputStream bis = new ByteArrayInputStream("defef".getBytes());
		
		//目的地
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		
		int ch = 0;
		
		while((ch=bis.read()) != -1){
			bos.write(ch);
		}
		
		System.out.println(bos.size());
		System.out.println(bos.toString());
		
		try {
			//将此 byte 数组输出流的全部内容写入到指定的输出流参数中
			bos.writeTo(new FileOutputStream("b.txt"));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

第十  字符编码

一、‘常见的编码表：

1、ASCII：美国标准信息交换码表。用一个字节的7位表示

2、IOS8859-1：拉丁码表；欧洲码表。用一个字节的8位表示

3、GB2312：中国的中文编码表

4、GBK：中国的中文编码表升级，融合了更多的中文文字字符。打头的是两个高位为1的两个字节编码。为负数

5、Unicode：国际标准码，融合了多种文字

6、UTF-8：升级版国际码表，是可变长度的码表。最多用三个字节表示一个字符的编码表，包括：一位、两位、三位表示的字符

      UTF-8有自己的字节码：

一个字节：0开头

两个字节：字节一  ---> 110     位数：10 ~ 6

                    字节二  --->  10      位数：5 ~ 0

三个字节：字节一  ---> 1110     位数：15 ~ 12

                    字节二  --->  10      位数：11 ~ 6

                    字节三 --->  10       位数：5 ~ 0

二、编码和解码：

1、编码：字符串变成字节数组

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

2、转换：

1）默认字符集：

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

      byte[]   --->  String  ：new String(byte[])

2）指定字符集：

      String  --->  byte[]   ：srt.getBytes(charsetName)

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

三、对于编码和解码的字符集转换

1、如果编码失败，解码就没意义了。

2、如果编码成功，解码出来的是乱码，，则需对乱码通过再次编码（用解错码的编码表），然后再通过正确的编码表解码。针对于IOS8859-1是通用的。

3、如果用的是GBK编码，UTF-8解码，那么再通过2的方式，就不能成功了，因为UTF-8也支持中文，在UTF-8解的时候，会将对应的字节数改变，所以不会成功。

特别注意：对于中文的”联通“，这两个字比较特别，它的二进制位正好是和在UTF-8中两个字节打头的相同，可以找到对应的符号，但不再是”联通“了。但是只要他前面还有其他汉字就不会被被UTF-8解码了，也就不会出现乱码了。

实例：

/*
 * 编码：字符串变成字节数组。
 *  解码：字节数组变成字符串。
 *   String-->byte[];  str.getBytes(charsetName);
 *   byte[] -->String: new String(byte[],charsetName);
 */
public class EncodeDemo {
	public static void main(String[] args) {

		method();
	}

	public static void show() {
		String s = "你好";
		try {
			byte[] b = s.getBytes("GBK");
			System.out.println(Arrays.toString(b));
			String str = new String(b, "iso8859-1");// 编码正确，解码错误
			System.out.println(str);

			// 对str进行iso8859-1编码。以这样的方式解决乱码
			byte[] b1 = str.getBytes("iso8859-1");
			System.out.println(Arrays.toString(b1));
			String str1 = new String(b1, "GBK");
			System.out.println(str1);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	}

	/*
	 * 联通
	 */
	public static void method() {
		String s = "联通";
		try {
			byte[] bs = s.getBytes("GBK");

			for (byte b : bs) {
				// Integer.toBinaryString将其转换为二进制，&255取出前面多余的1，保留最低8位
				// 联通的二进制是110...10...110...10...这个刚好符合utf-8的读取两个字节的编码形式，
				// 所以当度存在会被默认为utf-8编码来解读，从而造成乱码
				/*
				 * '\u0001' 到 '\u007F' 范围内的所有字符都是用单个字节表示的：
				 * 
				 * 位值 字节一 0 位 6-0
				 * 
				 * 
				 * null 字符 '\u0000' 以及从 '\u0080' 到 '\u07FF' 的范围内的字符用两个字节表示：
				 * 
				 * 位值 字节一 1 1 0 位 10-6
				 * 
				 * 字节二 1 0 位 5-0
				 * 
				 * 
				 * 
				 * '\u0800' 到 '\uFFFF' 范围内的 char 值用三个字节表示：  字节一  1 1 1 0 位
				 * 15-12
				 * 
				 * 字节二 1 0 位 11-6
				 * 
				 * 字节三 1 0 位 5-0
				 */
				System.out.println(Integer.toBinaryString(b & 255));
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	}
}

练习

五个学生，每个学生有3门课程的成绩，从键盘输入以上数据（姓名，三门课成绩），

输入格式：如：zahngsan，30,40,60计算出总成绩，并把学生的信息和计算出的总分数高低按顺序存放在磁盘文件stud.txt中

步骤：
1、描述学生对象
2、定义一个可操作学生对象的工具类

思路：
1、通过获取键盘录入一行的数据，并将该行数据的信息取出，封装成学生对象
2、因为学生对象很多，则需要存储，使用集合，因为要对学生总分排序
所以可以使用TreeSet
3、将集合中的信息写入到一个文件中

public class StudentInfoTest {
	public static void main(String[] args) {
		try {
			Comparator<StudentInfo> cmp = Collections.reverseOrder();// 强行反正比较顺序
			// Set<StudentInfo> stus = StudentInfoTool.getStudents();//默认比较
			Set<StudentInfo> stus = StudentInfoTool.getStudents(cmp);// 自定义比较器
			StudentInfoTool.write2File(stus);//调用写方法，将数据写文件中去
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

class StudentInfo implements Comparable<StudentInfo> {

	private String name;// 姓名
	private int ma, cn, en;// 数学、语文、英语成绩
	private int sum;// 总分

	//初始化就需要具备姓名，数学、语文、英语成绩
	StudentInfo(String name, int ma, int cn, int en) {
		this.name = name;
		this.ma = ma;
		this.cn = cn;
		this.en = en;

		sum = ma + cn + en;//计算出总成绩
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMa() {
		return ma;
	}

	public void setMa(int ma) {
		this.ma = ma;
	}

	public int getCn() {
		return cn;
	}

	public void setCn(int cn) {
		this.cn = cn;
	}

	public int getEn() {
		return en;
	}

	public void setEn(int en) {
		this.en = en;
	}

	public int getSum() {
		return sum;
	}

	public void setSum(int sum) {
		this.sum = sum;
	}

	@Override
	public int compareTo(StudentInfo o) {//建立自己的比较方法
		int num = new Integer(this.sum).compareTo(new Integer(o.sum));//比较分数
		if (num == 0) {
			return this.name.compareTo(o.name);//主条件相同判定次要条件
		}
		return num;//返回比较的值，大于正数，相同0，小于负数
	}

	@Override
	public int hashCode() {//重写hashcode方法是因为数据有可能存到hashtable中
		return name.hashCode() + sum * 23;//尽可能保证hashcode值不相同，减少比较次数
	}

	@Override
	public boolean equals(Object obj) {//建立自己独有的判断相同方式
		if (!(obj instanceof StudentInfo)) {
			throw new ClassCastException("类型不匹配");
		}

		StudentInfo si = (StudentInfo) obj;
		return this.name.equals(si.name) && this.sum == si.sum;//姓名和总分相同视为同一人
	}

	@Override
	public String toString() {//建立自己的toString方法
		return "studentinfo[" + name + ", " + ma + ", " + cn + ", " + en + "]";
	}
}

class StudentInfoTool {
	//定义默认比较顺序
	public static Set<StudentInfo> getStudents() throws IOException {

		return getStudents(null);
	}

	//定义自定义的比较顺序
	public static Set<StudentInfo> getStudents(Comparator<StudentInfo> cmp)
			throws IOException {
		BufferedReader bfr = new BufferedReader(
				new InputStreamReader(System.in));

		Set<StudentInfo> stus = null;
		if (cmp == null) {
			stus = new TreeSet<StudentInfo>();
		} else {
			stus = new TreeSet<StudentInfo>(cmp);
		}
		String line = null;
		while ((line = bfr.readLine()) != null) {
			if ("over".equals(line)) {
				break;
			}
			String[] info = line.split(",");//将数据以“，”切开，形成新的数据

			StudentInfo si = new StudentInfo(info[0],
					Integer.parseInt(info[1]), Integer.parseInt(info[2]),
					Integer.parseInt(info[3]));

			stus.add(si);
		}

		bfr.close();
		return stus;
	}

	public static void write2File(Set<StudentInfo> stus) throws IOException {
		BufferedWriter bfw = new BufferedWriter(new FileWriter("stuinfo.txt"));

		for (StudentInfo si : stus) {
			bfw.write(si.toString() + "\t");
			bfw.write(si.getSum() + "");
			bfw.newLine();
			bfw.flush();
		}

		bfw.close();
	}
}