java(25) - I/O操作

一.I/O操作：

先看一下File类的构造方法：

看一下输入输出流的层次：

从例子直接入手能更好的理解io：

1).创建文件：

public class IOTest {
	public static void main(String[] args) {
		File file = new File("E:/lzr.txt");
		try {
			System.out.println(file.createNewFile());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

打印：true     

我们在E盘下就会看到有一个lzr.txt文件。

在这里先说明一下\,在windows中使用\可以，但是在linux中就不可以了，因为不识别这个符号什么意思了，这时就要用/来替代了。为了更好地跨平台性，那么File类给我们提供了两个常量File.separator和File.separatorChar分别表示\和：，那么我就应该这样使用了。

public class IOTest {
	public static void main(String[] args) {
		File file = new File("E:"+File.separator+"lzr.txt");
		try {
			System.out.println(file.createNewFile());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

2).创建文件夹：

public class IOTest {
	public static void main(String[] args) {
		
		File file = new File("E:"+File.separator+"lzr"+File.separator+"lzr");
		
		System.out.println(file.mkdir());
		System.out.println(file.mkdirs());
	}
}

打印： false  true   因为中间的一层的文件夹lzr没有创建，所以第一个方法失败，第二个成功。

这两个方法的区别是：

mkdir()只能创建最后一层的文件夹，如果父目录其中一个不存在则会失败。

mkdirs()包括不存在的父目录也一块创建出来。

3).删除文件：

public class IOTest {
	public static void main(String[] args) {
		
		File file = new File("E:"+File.separator+"lzr");
		System.out.println(file.delete());
		
	}
}

打印：true 

递归实现删除目录下文件：

public class IOTest2 {
	public static void deleteFile(File file){
		if(file.isFile() || file.list().length == 0){
			file.delete();
		}else{
			File[] files = file.listFiles();
			for(File f:files){
				deleteFile(f);
				f.delete();
			}
		}
	}
	public static void main(String[] args) {
		File file = new File("E:"+File.separator+"lzr");
		deleteFile(file);
	}
}

会删除指定目录下的所有文件。

4).列出目录下的全部文件：

public class IOTest {
	public static void main(String[] args) {
		
        File f=new File("E:"+File.separator);
        //获得目下文件的名称
        String[] fileName=f.list();
        for (String name:fileName) {
            System.out.println(name);
        }
        //获得目下的文件
        File[] fileNames = f.listFiles();
        for(File files :fileNames){
        	System.out.println(files.getName());
        }
	}
}

打印：此处省略

打印的就是你文件目录下的所有文件。

比如我们可以筛选目录下的文件打印出来，就比如找.txt：

public class IOTest {
	public static void main(String[] args) {
        File f=new File("E:"+File.separator);
        //获得目下文件的名称
        String[] fileName=f.list(new FilenameFilter(){

			@Override
			public boolean accept(File dir, String name) {
                //判断后缀是否是.txt结尾
				if(name.endsWith(".txt")){
					return true;
				}
				return false;
			}
        });
        for (String name:fileName) {
            System.out.println(name);
        }
	}
}

打印：此处省略。。。

打印出的结果只是结尾是.txt的文件。

5).输入输出流：

    输入输出是相对程序来说的，程序在使用数据时所扮演的角色有两个：一个是源,一个是目的。若程序是数据流的源，即数据的提供者，这个数据流对程序来说就是输出流。若程序是数据流的目的地，则就是输入流。

   从流的结构上可以分为字节流（以字节为处理单位）和字符流（以字符为处理单位）。

   字节流的输入流和输出流基础是InputStream和OutpurStream这两个抽象类，字节流的输入输出操作由这两个类的子类实现。字符流输入输出基础是Reader和Writer。在底层的所有输入输出流都是字节流形式的。

   流的分类有节点流和过滤类。

     a).节点类：从特定的地方读写的流类。

     b).过滤流：使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或输出流连接创建的。主要特点是在输入输出数据的同时能对所传输的数据做指定类型或格式的转换，即可实现对二进制字节数据的理解和编码转换。

实现一个简单的读文件(输入流)例子：

public class InputStreamTest {

	public static void main(String[] args) throws Exception {
		
		InputStream is = new FileInputStream("E:"+File.separator+"lzr.txt");
		
		byte[] buffer = new byte[100];
		
		int length = 0;
		
		while(-1 != (length=(is.read(buffer,0,100)))){
			
			String str = new String(buffer,0,length);
			System.out.println(str);
			
		}
		is.close();
	}
	
}

打印：

asdf

zxcv

qwer

tyui
实现一个写入文件的（输出流）例子：

public class OutputStreamTest {

	public static void main(String[] args) throws Exception {
		
        File f=new File("E:"+File.separator+"hello.txt");

        OutputStream out =new FileOutputStream(f);

        String str="你好!";

        byte[] b=str.getBytes();

        out.write(b);

        out.close();
	}
	
}

打开流之后一定要记得关闭，否则会一直占资源。

包装一个输出流（缓冲流）：

public class BufferedOutputStreamTest {

	
	public static void main(String[] args) throws Exception {
		
		OutputStream os = new FileOutputStream("lzr.txt");
		//缓冲流
		BufferedOutputStream bos = new BufferedOutputStream(os);
		
		bos.write("www.baidu.com".getBytes());
		
		bos.close();
		
	}
}

刷新下项目，在目录上会多一个lzr.txt文件打开就会看到内容了。

当写满缓冲区或关闭输出流时，它在一次性输出到流，或者用flush()方法主动将缓冲区输出到流。

6).字节数组输出流：

public class ByteArrayOutputStreamTest {

	public static void main(String[] args) throws Exception {
		
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		
		String str = "hello world welcome";
		
		byte[] b = str.getBytes();
		
		baos.write(b);
		
		byte[] b2 = baos.toByteArray();
		
		for(int i = 0;i<b2.length;i++){
			
			System.out.println((char)b2[i]);
			
		}
		
		OutputStream os = new FileOutputStream("test.txt");
		
		baos.writeTo(os);
		
		baos.close();
		
		os.close();
	}
}

7).基本类型输出流：

public class DataStreamTest {

	public static void main(String[] args) throws Exception {
		
		DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("data.txt")));
		
		
		int i = 10;
		char ch = 'a';
		byte b = 1;
		
		dos.writeByte(b);
		dos.writeInt(i);
		dos.writeChar(ch);
		
		dos.close();
		
	}
}

带缓冲的基本类型输出流。显示的是一堆乱码，因为保存的不是字符串。
8).基本类型输入流：

public class DataStreamTest {

	public static void main(String[] args) throws Exception {
		
//		DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("data.txt")));
//		int i = 10;
//		char ch = 'a';
//		byte b = 1;
//		dos.writeByte(b);
//		dos.writeInt(i);
//		dos.writeChar(ch);
//		dos.close();
		
		DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("data.txt")));
		
		//要按存储数据一样读取数据
		System.out.println(dis.readByte());
		System.out.println(dis.readInt());
		System.out.println(dis.readChar());
		
		
		dis.close();
	}
}

输出：1 10 a

其他的输入输出流在jdk上都可以查到，这只是写了部分的。懂一个其他的基本也差不多了。