有了这些，java IO就不愁了

IO的总结:

• java中相对路径和绝对路径的问题:
  • 在web项目中，如果生成的文件前面没有 / 开头的话，表示的是生成的文件在当前项目的根目录下如student.txt在项目中刷新就能看到。
  • 如果是以/开头的话，如/student.txt则表示文件存放在磁盘根目录下(D://student.txt)。（好像也有可能在eclipse的根目录下）
  • 也可以将文件写在绝对路径下，如C://user/student.txt则表示文件在C盘的user目录下。

1. 基本流： InputStream、OutputStream、Reader、Writer等基本的输入输出，在使用的时候通过这些抽象方法的实现类（FileInputStream、FileOutputStream、FileReader、FileWriter）等来进行读取的读取和写入主要是通过 int b = fis.read() 或fos.write(b) 这种方式来读取或者写入的。

2. BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter等带有Buffer关键字的，通常情况下是在1的情况下再套一层Buffer流，原理就是先将数据写入到缓存中，再从缓存中将数据取出来。

• Buffer读取流的时候，使用的是bis.Reader()来读取的而BufferedReader则是使用br.readLine()来读取一行。
• 当使用BufferedWriter来写入数据的时候有一个bw.flush()方法，主要目的是将缓存中的数据强制写出去。

3. Data流： 主要是可以对基本数据类型进行写入写出等操作

• Data流写数据：
  创建一个字节数组输出流 ByteArrayOutputStream。
  创建 DataOutputStream 对象来对ByteArrayOutputStream进行数据的写入操作。
  可通过 dos.writeBoolean() writeString() writeDouble() ... 。
• Data流读数据：
  创建一个字节数组输入流 ByteArrayInputStream();
  创建 DataInputStream对象来对上述字节流读取。
  可以通过dis.readBoolean() readString() ....

4. Print流： 常见的是System.out.print()来输出

• PrintStream可以指定输出对象，并不一定要输出在控制台，可以输出在文件中等。
  创建输出文件（FileOutputStream fos = new FileOutputStream("txt/unicode.txt");）、设置输出位置（System.setOut(ps);）、打印输出对象（System.out.println(i);）即可完成指定输出。
• PrintWriter对象，可以指定将数据输出到文件中。
• 使用PrintStream读取文件数据。

5. ObjectOutputStream/ObjectInputStream 利用这两个对象可以存放序列化的数据。

6. 随机读取File文件:RandomAccessFile提供了seek()方法，用来定位将要读写文件的指针位置，我们也可以通过调用getFilePointer()方法来获取当前指针的位置。

7. 管道：管道主要用来实现同一个虚拟机中的两个线程进行交流。因此，一个管道既可以作为数据源媒介也可作为目标媒介。需要注意的是java中的管道和Unix/Linux中的管道含义并不一样，在Unix/Linux中管道可以作为两个位于不同空间进程通信的媒介，而在java中，管道只能为同一个JVM进程中的不同线程进行通信。和管道相关的IO类为：PipedInputStream和PipedOutputStream。

1.文件输入输出流

/* 使用文件输入输出流的方式将sa图片输出到另一个位置*/
public class Test1FileInputStream {
private static FileInputStream in = null;
private static FileOutputStream out = null;

public static void main(String[] args) {

int b = 0;

try {
in = new FileInputStream("pic/sa.jpg");
out = new FileOutputStream("output/pic/sb.jpg");

while ((b = in.read()) != -1) {
System.out.print((char) b);
out.write(b);
}

in.close();
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
System.out.println("over");
}

}
}

2.文件读取类

/从文件中读取数据/
public class Test3FileReader {

public static void main(String[] args) {

int c = 0;
try {
FileReader reader = new FileReader("a.txt");
while ((c = reader.read()) != -1) {
System.out.print((char) c);
}
} catch (Exception e) {
e.printStackTrace();
}

}

}

3.文件写入类

/* 将数据写入文本中*/
public class Test4FileWriter {

public static void main(String[] args) {
try {
FileWriter writer = new FileWriter("a.txt");
for (int i = 0; i < 65535; i++) {
writer.write((char) i);
}
writer.close();
System.out.println("success");
} catch (IOException e) {
e.printStackTrace();
System.out.println("err");
System.exit(-1);
}

}

}

4.使用流的方式读取文件

/读取并输出文件内容/
public class Test5BufferStream {
public static void main(String[] args) {

try {
FileInputStream inputStream = new FileInputStream("mark.log");
BufferedInputStream bis = new BufferedInputStream(inputStream);
// System.out.println(bis.read());
// System.out.println(bis.read());
int c = 0;
while ((c = bis.read()) != -1) {
System.out.print((char) c);
}
bis.close();
} catch (Exception e) {
e.printStackTrace();
}

}
}

5.使用缓存的方式读取和写入文件

/向一个文件中写入缓存数据并读取出来/
public class Test6BufferStream1 {

public static void main(String[] args) {

try {
// 通过缓存区向文件中写入数据
BufferedWriter bw = new BufferedWriter(new FileWriter("txt/a.txt"));
String s = null;
for (int i = 0; i < 100; i++) {
s = String.valueOf(Math.random());
bw.write(s);
bw.newLine();
}
bw.flush();

// 从文件中将数据读取到缓冲区在读取出来
BufferedReader br = new BufferedReader(new FileReader("txt/a.txt"));
while ((s = br.readLine()) != null) {
System.out.println(s);
}
bw.close();
br.close();

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

}

}

6.将输入的内容打印出来

/将数据从console中读出/
public class Test7TransForm {
public static void main(String[] args) {

InputStreamReader reader = new InputStreamReader(System.in);
BufferedReader reader2 = new BufferedReader(reader);

String s = null;

try {
s = reader2.readLine();
while (s != null) {
if (s.equalsIgnoreCase("exit")) {
System.exit(0);
}
System.out.println(s);
s = reader2.readLine();
}
reader2.close();
reader.close();
} catch (IOException e) {
e.printStackTrace();
}

}
}

7.使用OutputStreamWriter类将数据写入到文件中

/OutputStreamWriter类/
public class Test8TransForm1 {

public static void main(String[] args) {
try {
// 如果为true表示在原来的基础上追加 数据而不是覆盖
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("txt/b.txt", true), "utf-8");
osw.write("abcdefghijklmnopqrst ");
osw.flush();// 将缓存中的数据强制发送出去
System.out.println(osw.getEncoding());

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

8.ByteArrayOutputStream类

/利用dataStream可以向文件中写入各种类型的数据/
public class Test9DataStream {

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

// 创建字节数组
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 创建数据输出流
DataOutputStream dos = new DataOutputStream(baos);

dos.writeDouble(Math.random());
dos.writeBoolean(true);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
System.out.println(bais.available());// 八个字节
DataInputStream dis = new DataInputStream(bais);
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
dos.close();
dis.close();

}

}

9.使用PrintStream将数据输出到文件中

/将输出输出到文件中/
public class TestPrintStream1 {

private static PrintStream ps = null;

public static void main(String[] args) throws Exception {
// 创建输出的文件
FileOutputStream fos = new FileOutputStream("txt/unicode.txt");
// 创建输出流
ps = new PrintStream(fos);

if (ps != null) {
// 指定输出的位置
System.setOut(ps);
}
int in = 0;
// 将数据输出
for (char i = 0; i < 60000; i++) {
System.out.print(i + " ");
in++;
if (in >= 50) {
System.out.println();
in = 0;
}
}
System.out.println("over");
}

}

10.日志的基本原理

/将输入的内容记录到日志中/
public class TestPrintStream2 {

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

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = null;

FileWriter writer = new FileWriter("mark.log", true);

PrintWriter log = new PrintWriter(writer);
while ((s = br.readLine()) != null) {
if (s.equalsIgnoreCase("exit")) {
break;
}
System.out.println(s);
log.println("--------------");
log.println(s);
log.flush();
}
log.print("" + new Date() + "");
log.flush();
log.close();
}

}

11.使用缓存区文件读取

/使用输出流读取文件内容，显示在console中/
public class TestPrintStream3 {

public static void main(String[] args) {
String fileName = "mark.log";
if (fileName != null) {
list(fileName, System.out);
}
}

private static void list(String file, PrintStream ps) {

try {
// 创建缓冲区读取对象
BufferedReader br = new BufferedReader(new FileReader(file));
String s = null;
// 循环读取缓冲区的内容
while ((s = br.readLine()) != null) {
// 将数据读取到控制台上
ps.println(s);
}
br.close();
} catch (Exception e) {
e.printStackTrace();
ps.print("读取错误");
}
}

}

12.对象输入输出流

/* transient 修饰的成员变量在序列化的时候不予考虑*/
public class TestObjectIO {
public static void main(String[] args) {
T t = new T();
t.i = 6;
try {
// 将对象写到文本中
FileOutputStream fos = new FileOutputStream("txt/object.io");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(t);
oos.flush();
oos.close();

// 将对象从文本中读出来
FileInputStream fis = new FileInputStream("txt/object.io");
ObjectInputStream ois = new ObjectInputStream(fis);
T t1 = (T) ois.readObject();
System.out.println(t1.d + " " + t1.i + " " + t1.j + " " + t1.k);

} catch (Exception e) {
e.printStackTrace();
}

}
}

class T implements Serializable {
double d = 2.3;
int i = 10;
int j = 9;
transient int k = 2;
}

13. 随机读写

/随机读写文件/
public class TestAccessFile {

public static void randomAccessFileWrite() throws IOException {
// 创建一个RandomAccessFile对象
RandomAccessFile file = new RandomAccessFile("d:/test.txt", "rw");
// 通过seek方法来移动读写位置的指针
file.seek(10);
// 获取当前指针
long pointerBegin = file.getFilePointer();
// 从当前指针位置开始写
file.write("hehe 你好牛鞭".getBytes());
long pointerEnd = file.getFilePointer();
System.out.println("pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n");
file.close();
}

public static void randomAccessFileRead() throws IOException {
// 创建一个RandomAccessFile对象
RandomAccessFile file = new RandomAccessFile("d:/test.txt", "rw");
// 通过seek方法来移动读写位置的指针
file.seek(10);
// 获取当前指针
long pointerBegin = file.getFilePointer();
// 从当前指针开始读
byte[] contents = new byte[1024];
file.read(contents);
long pointerEnd = file.getFilePointer();
System.out.println(
"pointerBegin:" + pointerBegin + "\n" + "pointerEnd:" + pointerEnd + "\n" + new String(contents));
file.close();
}

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

randomAccessFileWrite();
randomAccessFileRead();
}

}

14. 管道Demo

public class TestPipe {

public static void main(String[] args) throws IOException {
// 实现在不同线程中对同一对象进行读写操作
final PipedOutputStream pos = new PipedOutputStream();
final PipedInputStream pis = new PipedInputStream(pos);

// 在第一个线程中对管道进行写入操作
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
pos.write("Hello world, pipe!".getBytes());
} catch (IOException e) {
}
}
});

// 在第二个线程中对管道数据进行读取操作
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
int data = pis.read();
while (data != -1) {
System.out.print((char) data);
data = pis.read();
}
} catch (IOException e) {
} finally {
try {
pis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
});
t1.start();
t2.start();
}
}