Java IO基础知识(上)

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();
}
}

}