标签：

Java IO概述

IO是整个人机交互的核心问题，因为IO是计算机获取和交换数据的主要渠道。
整个IO的流程就是 源数据--->程序--->目的地

IO的分类

• 基于字符操作的IO接口：Reader，Writer
• 基于字节操作的IO接口：InputStream，OutputStream
• 基于磁盘操作的IO接口：File
• 基于网络操作的IO接口：Socket(不在java.io包下面，但是socket的本质也是io操作)

一个程序需要InputStream或者Reader从数据源读取数据，需要OutputStream或者Writer将数据写入到目标媒介中。

InputStream和Reader与数据源相关联，OutputStream和writer与目标媒介相关联。

输入输出流的理解

输入流：可以理解为向内存输入

输出流：可以理解为从内存输出

IO类概述

基于字节的IO操作接口

基于字符的IO操作接口

字符与字节的转化接口 数据的持久化和网络传输都是以字节进行的，所以必须要有从字符到字节或从字节到字符的转化。 

InputStreamReader是字节到字符的转化桥梁，从InputStream到Reader的过程要指定编码字符集。StreamDecoder正是完成从字节到字符的解码的实现类 OutputStreamWriter类完成从字符到字节的编码过程，由StreamEncoder完成编码功能。

文件操作Demo

package com.weixuan.test;

import java.io.File;

/**
 * 学习File的相关操作 File类只能完成访问文件以及文件的元数据(指文件的属性信息)
 * 如果要读写文件内容，需要使用FileInputStream、FileOutputStream或者RandomAccessFile
 * 
 * @author Nicholas
 * 
 */
public class FileTest {
	public static void main(String[] args) {

		// 1、在使用File之前，必须拥有一个File对象
		File file = new File("D:\\CentOS-7.0-1406-x86_64-DVD.iso");

		// 2、检测文件是否存在
		boolean isExists = file.exists();
		System.out.println(isExists);

		// 3、文件长度
		long length = file.length();
		System.out.println(length);

		// 4、重命名或移动文件
		boolean isSuccess = file.renameTo(new File("test2.iso"));
		System.out.println(isSuccess);

		// 5、删除文件
		boolean isDelete = file.delete();
		System.out.println(isDelete);

		// 6、检测某个路径是文件还是目录
		boolean isDirectory = file.isDirectory();
		System.out.println(isDirectory);

		// 7、读取目录中的文件列表
		File file2 = new File("C:\\Users\\weixu_000\\Pictures");
		String[] filename = file2.list();

		for (String files : filename)
			System.out.println(files);
		
	}

}

package com.weixuan.test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 使用FileInputStream和FileOutputStream操作文件
 * 
 * @author Nicholas
 * 
 *         FileOutputStream可以往文件里写入字节流 (即从内存输出，写入到文件)
 *         FileInputStream可以以字节流的形式读取文件内容(从文件中读取，写入到内存)
 */
public class FileTest2 {

	private static OutputStream outputStream;
	private static InputStream inputStream;

	public static void main(String[] args) {
		try {
			// true表示追加文件,false表示覆盖
			outputStream = new FileOutputStream(
					"D:\\javawork\\JavaIOTest\\fileoutputStream.txt", false);
			//byte[] c = { 'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd' };
			outputStream.write("HelloWorld".getBytes());

			/**
			 * 当你往FileOutputStream里写数据的时候，这些数据有可能会缓存在内存中。
			 * 在之后的某个时间，比如，每次都只有X份数据可写，或者FileOutputStream关闭的时候，才会真正地写入磁盘。
			 * 当FileOutputStream没被关闭，而你又想确保写入到FileOutputStream中的数据写入到磁盘中，
			 * 可以调用flush()方法，该方法可以保证所有写入到FileOutputStream的数据全部写入到磁盘中。
			 */
			outputStream.flush();

			outputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

		// 读取文件的字节流
		try {
			inputStream = new FileInputStream(
					"D:\\javawork\\JavaIOTest\\fileoutputStream.txt");
			int data = inputStream.read();
			while (data != -1){
				System.out.println(inputStream.read());
				data = inputStream.read();
			}
			inputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

package com.weixuan.test;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * FileReader和FileWriter
 * 
 * @author Nicholas
 * 
 */
public class FileTest3 {

	public static void main(String[] args) {

		try {
			Reader reader = new FileReader(
					"D:\\javawork\\JavaIOTest\\fileoutputStream.txt");
			int data = reader.read();
			while (data != -1) {
				System.out.print((char) data);
				data = reader.read();
			}
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

		try {
			Writer writer = new FileWriter(
					"D:\\javawork\\JavaIOTest\\fileoutputStream.txt");

			// 直接写入字符串
			writer.write("Hello This is test ");
			writer.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

基于管道的线程通信

package com.weixuan.test;

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

/**
 * Java IO中的管道为运行在同一个JVM中的两个线程提供了通信的能力。所以管道也可以作为数据源以及目标媒介.
 * Java的管道不同于Unix/Linux系统中的管道。在Unix/Linux中，
 * 运行在不同地址空间的两个进程可以通过管道通信。在Java中，通信的双方应该是运行在同一进程中的不同线程。
 * 
 * 一个PipedInputStream流应该和一个PipedOutputStream流相关联。
 * 一个线程通过PipedOutputStream写入的数据可以被另一个线程通过相关联的PipedInputStream读取出来。
 * 
 * 请记得，当使用两个相关联的管道流时，务必将它们分配给不同的线程。
 * read()方法和write()方法调用时会导致流阻塞，这意味着如果你尝试在一个线程中同时进行读和写，可能会导致线程死锁.
 * 
 * @author Nicholas
 * 
 */
public class PipedTest {
	public static void main(String[] args) throws IOException {

		final PipedOutputStream pipedOutputStream = new PipedOutputStream();

		// pipedOutputStream.connect(pipedInputStream);
		// 可以调用pipedOutputStream初始化，也可以调用connect相关联
		final PipedInputStream pipedInputStream = new PipedInputStream(
				pipedOutputStream);

		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					pipedOutputStream.write("This is Thread1' input !"
							.getBytes());
					pipedOutputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		});

		Thread thread2 = new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					int data = pipedInputStream.read();
					while (data != -1) {
						System.out.print((char) data);
						data = pipedInputStream.read();
					}
					pipedInputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}

			}
		});

		thread1.start();
		thread2.start();
	}
}

字节流与字符流的转换

package com.weixuan.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

import com.sun.jndi.url.corbaname.corbanameURLContextFactory;

public class Convert {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 字节转换为字符

		File file = new File("D:\\javawork\\JavaIOTest\\fileoutputStream.txt");

		// 字符输出流
		Writer writer = null;

		try {
			writer = new OutputStreamWriter(new FileOutputStream(file));

			writer.write("Hello ");

			writer.flush();

			writer.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

		Reader reader = null;

		try {
			reader = new InputStreamReader(new FileInputStream(file));
			char[] c = new char[1024];
			int length = reader.read(c);

			System.out.println(length);

			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

Java IO基础知识(上)

标签：

原文地址：http://blog.csdn.net/weiyongxuan/article/details/46727833