黑马程序员之JAVAIO(二)

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、File类

        示例一：

        

import java.io.File;
import java.io.IOException;

/*
 * File类常见方法
 * 1.创建
 *   boolean createNewFile()	//在指定的目录下创建文件, 如果这个文件存在, 则不会创建(返回false)
 *   							  和输出流不一样, 输出流对象一建立, 就会创建, 而且会覆盖已经有的文件
 *   boolean mkdir()	//在指定目录下创建文件夹, 如果这个文件夹存在则不会创建(返回false)
 *   boolean mkdirs()	//创建多级文件夹
 *   
 * 2.删除
 *   boolean delete()  //删除文件或者文件夹, 删除失败则返回false
 *   void deleteOnExit()   //交由JVM在程序结束的时候把文件删除
 * 
 * 3.判断
 *   boolean exists()	//文件是否存在
 *   boolean isDirectory()	//判断是否是目录
 *   boolean isFile()	//判断是否是文件
 *   boolean isHidden()	//判断是否是隐藏文件
 *   boolean isAbsolute()	//判断是否是绝对路径, "D:/a/a/a.txt", 
 *                          //是则返回true, 否则false, 即使文件不存在也可以判断, 只要封装到File对象中了
 * 
 * 4.获取
 *   String getAbsolutePath()	//获取文件的决定路径
 *   String getPath()	//获取文件的路径(封装的什么路径就获取到什么路径)
 *   String getName()	//获取文件的名字
 *   String getParent()	//返回绝对路径中的文件父目录, 如果获取的是相对路径则返回null, 如："a.txt", 则会返回null
 *   					//如果该相对目录中有上层目录, 则返回上层目录, 如： "b/a.txt", 则返回b
 *   long lastModified()	//返回文件最后一次修改的时间
 *   boolean renameTo()		//重命名(把以前的文件删除, 并建立新的文件, 把原文件的类容拷贝到新的文件下)
 *   
 * 
 */

public class FileDemo {

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

		fileMethod4();
	}

	public static void cos() {
		// 将d.txt封装成对象
		File file = new File("d.txt");

		File file2 = new File("D:/", "a.txt");

		File d = new File("D:/");
		File file3 = new File(d, "e.txt");

		// separator跨平台的目录分隔符
		File file4 = new File("D:" + File.separator + "d.txt");

		System.out.println(file);
		System.out.println(file2);
		System.out.println(file3);
		System.out.println(file4);
	}

	public static void fileMethod() throws IOException {

		File file = new File("D:" + File.separator + "file.txt");
		System.out.println("create : " + file.createNewFile());
		boolean b = file.delete();	//删除文件

		//判断文件是否存在
		System.out.println("exists : " + file.exists());
		
		File file2 = new File("D:" + File.separator + "a");
		System.out.println("mkdir : " + file2.mkdir());
		
		File file3 = new File("D:" + File.separator + "a" + File.separator + "b");
		System.out.println("mkdirs : " + file3.mkdirs());
	}
	
	public static void fileMethod2(){
		
		//判断文件对象是否是目录或者文件时, 一定要先判断该文件或者目录是否存在
		//用exists()方法进行判断是否存在
		File file = new File("D:" + File.separator + "fos.txt");
		boolean b = file.isFile();
		boolean d = file.isDirectory();
		System.out.println("isFile : " + b);
		System.out.println("isDirectory : " + d);
		
		boolean p = file.isAbsolute();	//判断是否是绝对路径
		
	}
	
	
	public static void fileMethod3(){
		
		File file = new File("D:/3.txt");
		
		//获取文件的决定路径
		String path = file.getAbsolutePath();
		//获取文件的路径(封装的什么路径就获取什么路径)
		String path2 = file.getPath();
		
		//获取文件的名字
		String name = file.getName();
		
		//返回绝对路径中的文件父目录
		String path3 = file.getParent();
		
		//返回文件最后一次修改的时间
		long lastTime = file.lastModified();
		
		//返回文件的大小
		long size = file.length();
		
		System.out.println("getAbsolutePath : " + path);
		System.out.println("getPath : " + path2);
		System.out.println("name : " + name);
		System.out.println("getParent : "+ path3);
		System.out.println("lastModified : " + lastTime);
		System.out.println("length : "+ size);
	}
	
	public static void fileMethod4(){
		File file = new File("D:/q.txt");
		File newFile = new File("D:/1.txt");
		
		//重命名文件(把以前的文件删除, 并拷贝到新的文件下)
		boolean b = file.renameTo(newFile);
		System.out.println(b);
	}

}

        示例二：

public static void listDemo(){
		File file = new File("C:/");
		
		//返回指定文件夹下所有文件和文件夹(包含隐藏文件)
		//调用list()方法的File对象必须是封装了一个目录, 该目录必须存在
		String[] strings = file.list();
		for (String string : strings) {
			
			System.out.println(string);
		}
	}
	
	
	public static void acceptFile(){
		
		File dir = new File("D:/");
		
		//文件名过滤
		String[] files = dir.list(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				
				return name.endsWith(".mp3");
			}
		});
		
		for (String string : files) {
			System.out.println(string);
		}
	}

        示例三：

import java.io.File;

//列出指定目录下所有的文件和文件夹, 包含子目录
//因为目录中还有目录, 只要使用同一个列出目录的函数即可.
//在列出过程中还有目录的话, 还可以使用该函数
//也就是函数自己调用自己, 这样的表现形式, 称为递归.

//递归需要注意的是:
//1.限定条件(出口)
//2.递归次数, 避免内存溢出

public class FileDemo3 {

	public static void main(String[] args) {

		showDir(new File("D:/"));
	}

	public static void showDir(File dir) {

		System.out.println(dir);
		File[] files = dir.listFiles();
		for (int i = 0; i < files.length; i++) {
			//隐藏文件不让访问, 不判断则会报异常, 程序终止
			if (files[i].isDirectory() && !files[i].isHidden())
				showDir(files[i]);
			else
				System.out.println(files[i]);
		}
	}
}

二、ObjectOutputStream和ObjectInputStream

        示例：

//序列化
//静态的, 不能被序列化
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectStreamDemo01 {

	public static void main(String[] args) throws Exception {
		readObj();
	}
	
	
	public static void writeObj() throws IOException{
		
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/p.txt"));
		oos.writeObject(new Person("tom", 2222));
		oos.flush();
		oos.close();
	}
	
	public static void readObj() throws Exception{
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/p.txt"));
		Person p = (Person)ois.readObject();
		ois.close();
		System.out.println(p);
		
	}
	
}

//Serializable标识该类要被序列化, 该Serializable接口中没有任何方法
@SuppressWarnings("serial")
class Person implements Serializable{
	private String name;
	
	//transient关键字, 表示不能被序列化
	private transient int age;
	
	//静态不能被序列化
	private static String cn;
	
	public Person(String name, int age) {
		this.age = age;
		this.name = name;
	}
	
	public String toString(){
		return name + " : " + age;
	}
}

三、PipedInputStream和PipedOutputStream

        示例：

//管道流
//管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。
//通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的 PipedOutputStream。
//不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。
//管道输入流包含一个缓冲区，可在缓冲区限定的范围内将读操作和写操作分离开。
//如果向连接管道输出流提供数据字节的线程不再存在，则认为该管道已损坏。

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedStreamDemo02 {

	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 Read implements Runnable{

	private PipedInputStream in;
	
	public Read(PipedInputStream in) {
		this.in = in;
	}
	
	@Override
	public void run() {
		
		try {
			
			byte[] b = new byte[1024];
			int len = in.read(b);
			String str = new String(b, 0, len);
			System.out.println(str);
			
		} catch (Exception e) {
			throw new RuntimeException("管道读取流失败");
		}
	}
}


class Write implements Runnable{
	
	private PipedOutputStream out;
	
	public Write(PipedOutputStream out) {
		this.out = out;
	}

	@Override
	public void run() {
		
		try {
			out.write("nadadadafafaffwgfwgs".getBytes());
			out.close();
		} catch (Exception e) {
			throw new RuntimeException("管道输出流失败");
		}
	}
}

四、PrintStream和PrintWriter

        示例：

/*
 * 打印流：
 * 该流提供了打印方法, 可以将各类型的数据都原样打印
 * 
 * 字节打印流：
 * 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));
		
		//参数二： 为true, 表示刷新输出, 只有println、printf 或 format 方法将刷新输出缓冲区
		//new FileWriter("D:/printWriter.txt")也会刷新输出的
		//这样就不用再写out.flush()
		//PrintWriter out = new PrintWriter(new FileWriter("D:/printWriter.txt"),true);
		
		PrintWriter out = new PrintWriter(System.out);
		String line = null;
		while(null != (line=bufr.readLine())){
			if("over".equals(line)) break;
			
			//打印数据
			out.println(line);
			out.flush();
		}
		
		bufr.close();
		out.close();
	}
}

五、Properties

        示例：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/*
 * Properties是Hashtable的子类
 * 也就是说它具备map集合的特点, 而且它里面存储的键值对都是字符串
 * 它是集合中和IO相结合的容器集合
 * 
 * 该对象的特点：用于存放键值对形式的配置文件
 * 
 */


public class PropertiesDemo {

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

		loadDemo();
	}
	
	
	public static void setAndGet(){
		Properties prop = new Properties();
		
		//设置
		prop.setProperty("tom", "男");
		prop.setProperty("Jerry", "女");
		
		//获取
		String value = prop.getProperty("tom");
		
//		System.out.println(value);
		
		//返回键的Set集合
		Set<String> key = prop.stringPropertyNames();
		for (String string : key) {
			System.out.println(string + " -> " + prop.getProperty(string));
		}
	}
	
	
	//将流中的数据存储到集合中
	public static void loadDemo() throws IOException{
		
		Properties prop = new Properties();
		FileInputStream fis = new FileInputStream("D:/1.txt");
		
		//将流中的数据加载进集合
		prop.load(fis);
		
		prop.setProperty("qeqeq", "33");
		FileOutputStream os = new FileOutputStream("D:/1.txt");
		
		//将数据写入到输出, 第二个参数为注释
		prop.store(os, null);
		
//		System.out.println(prop);
		
		//将列表属性输出到指定的输出流
		prop.list(System.out);
		
		
		os.close();
		fis.close();
		
		
	}

}