Java学习笔记10

2017-12-28

day11

I/0

###目录列表


import java.util.*;
import java.util.regex.*;
import java.io.*;
class DirFilter implements FilenameFilter{//这个接口只有一个方法accept
	private Pattern pattern;
	public DirFilter(String regex){
		pattern=Pattern.compile(regex);
	}
	public boolean accept(File dir,String name){
		return pattern.matcher(name).matches();
	}
}
public class DirList {
	public static void main(String[] args){
		File path=new File("src/io");
		String[] list;
		//list=path.list();
			list=path.list(new DirFilter("D.*.java"));
			Arrays.sort(list,String.CASE_INSENSITIVE_ORDER);
			for(String dirItem:list){
				System.out.println(dirItem);
		}
	}
}

File的list()方法可以返回当前目录下的所有文件，FilenameFilter接口的accept方法供list()调用，可以起到过滤器的作用，其中传一个正则表达式用来过滤不符合表达式的文件名。

获取文件集


package io;
import java.util.regex.*;
import java.io.*;
import java.util.*;
//用来打印的格式
class PPrint{
	public static String pformat(Collection<?>c){
		if(c.size()==0)return "[]";
		StringBuilder result= new StringBuilder("[");
		for(Object obj:c){
			if(c.size()!=1)
				result.append("\n ");
			result.append(obj.toString());
		}
		if(c.size()!=1){
			result.append("\n");
		}
		result.append("]");
		return result.toString();
	}
}
//用来递归获取目录中文件夹和文件的名字
public class Directory {
	public static File[]
			local(File dir,final String regex){
		return dir.listFiles(new FilenameFilter(){
			private Pattern pattern =Pattern.compile(regex);
			public boolean accept(File dir,String name){
				return pattern.matcher(name).matches();
			}
		});
	}
	public static File[] local(String path,final String regex){
		return local(new File(path), regex);
	}
	//
	public static class TreeInfo implements Iterable<File>{
	//用来存放文件和文件夹的名称。
	public List<File> files=new ArrayList<File>();
	public List<File> dirs=new ArrayList<File>();
	public Iterator<File> iterator(){
		return files.iterator();
	}
	public void addFile(File file){
		files.add(file);
	}
	public void addDir(File dir){
		dirs.add(dir);
	}
	public void addAll(TreeInfo other){
		this.files.addAll(other.files);
		this.dirs.addAll(other.dirs);
	}
	public String toString(){
		return "dirs"+PPrint.pformat(dirs)+"\n\nfiles:"+PPrint.pformat(files);
	}
	}
	public static TreeInfo walk(String start,String regex){
		return recurseDirs(new File(start), regex);
	}
	public static TreeInfo walk(String start){
		return recurseDirs(new File(start), ".*");
	}
	public static TreeInfo walk(File start,String regex){
		return recurseDirs(start, regex);
	}
	public static TreeInfo walk(File start){
		return recurseDirs(start, ".*");
	}
	//
	static TreeInfo recurseDirs(File startDir,String regex){
		TreeInfo result=new TreeInfo();
		for(File file:startDir.listFiles()){
			if(file.isDirectory()){
				result.addDir(file);
				result.addAll(recurseDirs(file, regex));
			}
			else if(file.getName().matches(regex)){
				result.addFile(file);
			}
		}
		return result;
	}
	public static void main(String[] args){
		if(args.length==0){
			System.out.println(walk("."));
		}else{
			for(String arg:args){
				System.out.println(walk(arg));
			}
		}
	}
}

File类也可以用来创建新的目录或尚不存在的整个目录路径。我们还可以查看文件的特性(如：大小，最后修改日期，读写）类似于unix接口中的fcntl。


package io;
import java.io.*;
public class MakeDirectories {
	private static void usage(){
		System.err.println(
				"");
		System.exit(1);
	}
	private static void fileData(File f){
		System.out.println(
				"Absolute path: "+f.getAbsolutePath()+"\n"
				+ "Can read: "+f.canRead()+"\n"
				+"getName: "+f.getName()+"\n"
				+"getParent: "+f.getParent()+"\n"
				+"getPath: "+f.getPath()+"\n"
				+"length: "+f.length()+"\n"
				+"lastModified: "+f.lastModified()
						);//可以查看的一些信息
		if(f.isFile())
			System.out.println("It is a File");
		else if(f.isDirectory())
			System.out.println("It is a directory");
	}
	public static void main(String[] args){
		if(args.length<1)usage();
		if(args[0].equals("-r")){
			if(args.length!=3)usage();
			File old=new File(args[1]);
			File rname=new File(args[2]);
			old.renameTo(rname);//rename一个文件或者文件夹
			fileData(old);
			fileData(rname);
			return;
		}
		int count=0;
		boolean del=false;
		if(args[0].equals("-d")){
			count++;
			del=true;
		}
		count--;
		while(++count<args.length){
			File f=new File(args[count]);
			if(f.exists()){
				System.out.println(f+"exists");
			if(del){
				System.out.println("deleting..."+f);
				f.delete();
			}
			}
			else{
				if(!del){
					f.mkdirs();
					System.out.println("Created"+f);
				}
			}
			fileData(f);
		}
	}
}

输入输出

InputStream

作用是用来表示哪些从不同数据源产生的输入的类，这些数据源包括:

字节数组
String对象
文件
*“管道”，工作方式与实际管道相似。
一个由其他种类的流组成的序列，以便我们可以将它们手机合并到一个流内。
其他数据源，如Internet连接

outputStream

各种继承的类表示了要去往的目标：

ByteArrayOutputStream 字节数组
FileOutputStream 文件
PipedOutputStream 管道
FilterOutputStream 抽象基类，提供过滤功能

类库中各种类的模式基于装饰器模式，即一种IO核心类型加上所有的装饰器，组成一个IO对象。

Reader和Writer

为了国际化，老IO类库只能支持8位，Unicode需要支持16位。

实例

缓冲读文件(按行读）：


package io;
import java.io.*;
public class BufferedInputFile {
	public static String read(String filename)throws IOException{
		BufferedReader in =new BufferedReader(new FileReader(filename));
		String s;
		StringBuilder sb=new StringBuilder();
		while((s=in.readLine())!=null){
			sb.append(s+'\n');
		}
		in.close();
		return sb.toString();
	}
	public static void main(String[] args) throws IOException{
		System.out.println(new File(".").getAbsoluteFile());
	}
}

从内存读


public class MemoryInput {
	public static void main(String[] args)throws IOException{
		//先由BufferedInputFile读到内存，返回一个String给StringReader
		StringReader in=new StringReader(BufferedInputFile.read("Memory.java"));
		int c;
		while((c=in.read())!=-1){
			System.out.println(c);
		}
	}
}

格式化的内存输入

用DataInputStream，面向字节，而不是面向字符（char占两个字节）

基本文件输出


public class BasicFileOutput {
	static String file="BasicFileOutput.out";
	public static void main(String[] args)throws IOException{
		BufferedReader in=new BufferedReader(
				new StringReader(BufferedInputFile.read("./src/io/BasicFileOutput.java")));
		PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(file)));
		int linecount=1;
		String s;
		while((s=in.readLine())!=null){
			out.println(linecount+++":" +s);
		}
		out.close();//要显示调用close，刷新缓冲区
		System.out.println(BufferedInputFile.read(file));
	}
}

标准IO

重定向方法：

setIn(InputStream)

setOut(PrintStream)

setErr(PrintStream)


public class Redirecting {
	public static void main(String[] args)throws IOException{
		PrintStream console=System.out;
		BufferedInputStream in= new BufferedInputStream(
				new FileInputStream("./src/io/Redirecting.java")
				);
		PrintStream out=new PrintStream(
				new BufferedOutputStream(
				new FileOutputStream("test.out")
				)
				);
		System.setIn(in);
		System.setOut(out);
		System.setErr(out);
		BufferedReader br=new BufferedReader(
				new InputStreamReader(System.in)
				);
		String s;
		while((s=br.readLine())!=null){
			System.out.println(s);
		}
		out.close();
		System.setOut(console);
	}
}