CORE JAVA (十) 之 IO
http://blog.csdn.net/yuchen2008/archive/2006/12/21/1451180.aspx
知识点： IO
什么是 IO ？输入输出 input output, 这是指以程序为中心，就是站在程序的角度说的，程序其实是 JVM, 例如：写程序将一些信息存储到文件中，这叫输出（写入）；如果程序从文件得到信息，就叫输入（读取）
文件：
什么是文件？指计算机中的文件和目录
文件的作用就是存取查看
文件和 java 中的 File 类： File 相当于指向文件的指针，它本身并不是文件，如果我们想通过程序来操作和使用文件，就需要使用 File 类
/**
* 知识点：
* File 类：文件和目录的创建
* 程序目标：
* 测试 File 类和常用的方法
*/
package MY.module10.File;
import java.io.*;
public class TestFile {
public static void test1(){
File file1=new File("h://mytest//test1");
if(!file1.exists()){// 如果没有创建该对象指向的目录，就创建它
file1.mkdirs();//mkdirs 和 mkdir 的区别在于， mkdirs 创建整个目录
}
File file2=new File(file1,"test2");
if(!file2.exists()){
file2.mkdir();
}
File file3=new File("h://mytest//test1","test3");
if(!file3.exists()){
file3.mkdir();
}
File file4=new File(file3,"text.txt");
if(!file4.exists()){
try {
file4.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// file1.delete();//error 必须先删除子目录或文件
System.out.println(file4.getAbsolutePath());
System.out.println(file4.getPath());
System.out.println(file4.getParent());
System.out.println(file4.canRead());
System.out.println(file4.isDirectory());
System.out.println(file1.isDirectory());
System.out.println(file4.length());
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test1();
}
}
发现问题：如果让我们连接服务器，在服务器远程建立一个文件，该怎么做呢？
需要处理跨平台性：
对于命令：File f2=new file(“d://abc//789//1.txt”)
这个命令不具备跨平台性，因为不同的 OS 的文件系统的分隔符是不相同。
使用 file 类的 separtor 属性，返回当前平台文件分隔符。
File newD = new File("aa"+File.separator+"bb"+File.separator+"cc");
File newF = new File(newD,"mudi.txt");
try{
newD.mkdirs();
newF.createNewFile();
}catch(Exception e){}
I/O 框架：
什么是输入流？从外界流向程序，程序从外界得到资源
什么是输出流？从程序到外界的过程
比如：我们从文件中得到内容，并且显示在屏幕上，从文件得到内容，是输入（读取），将内容显示在屏幕上，显示到终端上是输出（写入），始终以程序为中心
什么是字节流？以字节为单位的数据传输方法进行传输
什么是字符流？以字符为单位的数据传输方法进行传输
什么是节点流？就是在输入输出两端建立一个管道
什么是处理流？给管道增加功能，比如加粗，过滤功能等等
| 字节流 |
字符流 |
||
| 输入流 |
节点流 |
FileInputStream |
FileReader |
| 处理流 |
BufferedInputStream |
BufferedReader |
|
| 输出流 |
结点流 |
FileOutStream |
FileWriter |
| 处理流 |
BufferedOutStream |
BufferedWriter |
|
字节流的作用？当我们处理的是二进制文件的时候，需要用字节流来进行传输，不能用字符流
什么是二进制文件？里面都是机器码， 010101 的机器码，他们需要按字节方式传输
未处理问题：什么情况下我们需要传输一个二进制文件呢？二进制文件对我们来说有什么用？
字符流的作用？以字符为单位传输数据，处理文本文件，里面的方法比较好用，简单
字节流：
父类： InputStream OutputStream
InputStream:
Int Read() ：一个一个字节的读取流中的数据，读一个，指针指向下一个，再读，再指向下一个，返回为整数，这个整数是编码，比如，文档有 h 这个字符，那么返回的是这个字符的编码 104 ，那么，如果我想打印出 h ，需要强制转换 , 如果为 -1 ，说明没有读取到内容
Int read(byte[] b): 读取流中的内容，一个一个读，把读的内容存到数组中，返回 int 型，也就是数组的长度
int available(): 返回可从流中读取的字节数。
skip(long): 丢弃了流中指定数目的字符。
boolean markSupported()
void mark(int)
void rese()
OutputStream:
三个基本的write()方法
void write():
void write(byte[]) ：
void write(byte[], int , int) ：
其它方法
void close(): 关闭流，如使用过滤器流，关闭栈顶部的流，会关闭其余的流。
void flush(): 允许你强制执行写操作。
注：在流中 close() 方法由程序员控制。因为输入输出流已经超越了 JVM 的边界，所以有时可能无法回收资源。
原则：凡是跨出虚拟机边界的资源都要求程序员自己关闭，不要指望垃圾回收。
FileInputStream:
/**
* 知识点：
* FileInputStream: 字节流中的管道，节点流，输入
* read()
* 程序目标：
* 从一个目录中的文件里得到里面的内容，显示在终端上
*/
package MY.module10.inputstreams;
import java.io.*;
public class TestFileInputStream {
public static void test(){
File f=new File("h://mytest//test1//test3","hello.txt");
if(!f.exists()){
try {
f.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
try {
FileInputStream fs=new FileInputStream(f);
int i=0;
while((i=fs.read())!=-1){
System.out.print((char)i);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test();
}
}
/**
* 知识点：
* 使用 read(byte[] b)
* 程序目标：
* test1 ：使用字节数组方式显示读取的内容
* 发现问题：字节数组大小，开多大呢？两种解决办法
* test2: 第一种：定义一个小一些的数组，通过循环显示所有内容，因为
* read() 方法是一个一个读，跟指针一样，第一次写 read() 后，再写一次
* 就会从上次结尾后开始读
* test3: 第二种：先得到目录文件中的内容大小，然后开这么大的空间
*/
package MY.module10.inputstreams;
import java.io.*;
public class TestFileInputStream2 {
public static void test1(){
FileInputStream fs=null;
try {
fs=new FileInputStream("h://mytest//test1//test3//hello.txt");
byte[] b=new byte[32];
int length=fs.read(b);
System.out.println(length);
System.out.println(new String(b,0,length));
fs.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void test2(){
FileInputStream fs=null;
try {
fs=new FileInputStream("h://mytest//test1//test3//hello.txt");
byte[] b=new byte[10];
int length=fs.read(b);
while(length==10){
System.out.println(new String(b,0,length));
length=fs.read(b);
}
System.out.println(new String(b,0,length));
fs.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void test3(){
File file=new File("h://mytest//test1//test3//hello.txt");
long length=file.length();
FileInputStream fs=null;
try {
fs=new FileInputStream(file);
byte[] b=new byte[(int)(length)];
int x=fs.read(b);
System.out.println(new String(b,0,x));
fs.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// test1();
// test2();
test3();
}
}
FileOutputStream:
/**
* 知识点：
* 输出和输入输出
* 程序目标：
* test1: 将一个字符串写入一个文件中
* test2: 从一个文件读取字符串，并将这些内容写入到另一个文件中
*/
package MY.module10.outputstreams;
import java.io.*;
public class TestFileOutputStream {
public static void test1(){
FileOutputStream fs=null;
try {
fs=new FileOutputStream("h://mytest//test1//test3//hello.txt");
String s="JAVA I LOVE YOU!";
fs.write(s.getBytes());
fs.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void copyFile(String file1,String file2){
File f1=new File(file1);
File f2=new File(file2);
FileInputStream fis=null;
FileOutputStream fos=null;
try {
fis=new FileInputStream(f1);
fos=new FileOutputStream(f2);
int i=0;
while((i=fis.read())!=-1){
// fos.write((char)i);// 写入文件就不用转换为 char 了，文档可以辨别出来数字的含义
fos.write(i);
}
fis.close();
fos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// test1();
String file1="h://mytest//test1//test3//hello.txt";
String file2="h://mytest//test1//test3//text.txt";
copyFile(file1,file2);
}
}
在文件中追加一些字符：
FileOutputStream outfile = new FileOutputStream(“results.dat”,true);
参数为 true 时输出为添加，为 false 时为覆盖。
FileOutputStream 类代码： ( 为什么能建文件 )
Public FileOutputStream(String name){
This(name!=null ？ new File(String):null,false);
}
BufferedInputStream ：
输入：字节流中的处理流
/**
* 知识点：
* BufferedInputStream
* 程序目标：
* 读取文件中的内容显示在终端上，把管道的功能加强
*/
package MY.module10.inputstreams;
import java.io.*;
public class BufferInputStream {
public static void test1(){
FileInputStream fis=null;
BufferedInputStream bis=null;
try {
fis=new FileInputStream("h://mytest//test1//test3//hello.txt");
bis=new BufferedInputStream(fis);
// int j=fis.available();
byte[] b=new byte[5];
int i=0;
i=bis.read(b);
while(i==5){
System.out.print(new String(b));
i=bis.read(b);
}
System.out.println(new String(b,0,i));
bis.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test1();
}
}
BufferedOutputStream:
/**
* 知识点：
* BufferedOutputStream: 输出：字节流中的处理流
* 程序目标：
* 在文件中写入一句话
*/
package MY.module10.outputstreams;
import java.io.*;
public class TestBufferedOutputStream {
public static void test1(){
BufferedOutputStream bos=null;
try {
bos=new BufferedOutputStream(new FileOutputStream("h://mytest//test1//test3//hello.txt",true));
String s="zhen de ma?";
bos.write(s.getBytes());
bos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test1();
}
}
字符流：
抽象父类： Reader Writer
FileReader:
/**
* 知识点：
* 字符流：输入：结点流： FileReader
* 程序目标：
* 从文件中得到字符并输出到终端上
*/
package MY.module10.Reader;
import java.io.*;
public class TestFileReader {
public static void test(){
FileReader fr=null;
try {
File file=new File("h://mytest//test1//test3//hello.txt");
fr=new FileReader(file);
long length=file.length();
char[] c=new char[(int)(length)];
fr.read(c);
System.out.println(c);
fr.close();
// char[] c=new char[5];
// int i=0;
// i=fr.read(c);
// while(i==5){
// System.out.println(new String(c));
// i=fr.read(c);
// }
// System.out.println(new String(c,0,i));
// fr.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test();
}
}
FileWriter ：
/**
* 知识点：
* FileWriter,FileReader
* 程序目标：
* 使用字符流，从一个文件得到内容并复制到另一个文件
*/
package MY.module10.FileWriter;
import java.io.*;
public class TestFileWriter {
public static void test(){
FileWriter fw=null;
try {
fw=new FileWriter("h://mytest//test1//test3//hello.txt",true);
String s="I Love Java!";
fw.write(s);
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void copyFile(String file1,String file2){
FileReader fr=null;
FileWriter fw=null;
try {
fr=new FileReader(file1);
fw=new FileWriter(file2);
int i=0;
while((i=fr.read())!=-1){
fw.write(i);
}
fr.close();
fw.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// test();
String file1="h://mytest//test1//test3//hello.txt";
String file2="h://mytest//test1//test3//text.txt";
copyFile(file1,file2);
}
}
BufferedReader:
/**
* 知识点：
* BufferedReader 字符流 - 输入 - 处理流
* 程序目标：
* 测试 BufferedReader
* 注意： readLine() ，比较好用
*/
package MY.module10.Reader;
import java.io.*;
public class TestBufferedReader {
public static void test(){
BufferedReader br=null;
try {
br=new BufferedReader(new FileReader("H://mytest//test1//test3//hello.txt"));
String s=null;
while((s=br.readLine())!=null){
System.out.println(s);
}
br.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test();
}
}
BufferedWriter:
/**
* 知识点：
* BufferedWriter: 输出流 - 字符流 - 处理流
* 程序目标：
* 使用 BufferedWriter 输出内容到文件
*/
package MY.module10.Writer;
import java.io.*;
public class TestBufferedWriter {
public static void test(){
FileWriter fw=null;
BufferedWriter bw=null;
try {
fw=new FileWriter("h://mytest//test1//test3//hello.txt" );
bw=new BufferedWriter(fw);
String s="China";
bw.write(s);
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test();
}
}
字节数组流： ByteArrayInputStream,ByteArrayOutStream
/**
* 知识点：
* 字节数组 ByteArrayInputStream,ByteArrayOutStream
* 程序目标：
* 将一个字符串转换为大写，使用字节数组流
* 注意： ByteArrayOutStream 的 write 方法是将内容写入字节数组中
*/
package MY.module10.TestArray;
import java.io.*;
public class TestArray {
public static void test(){
ByteArrayInputStream bis=null;
ByteArrayOutputStream bos=null;
String s="hello world";
bis=new ByteArrayInputStream(s.getBytes());
bos=new ByteArrayOutputStream();
toDaxie(bis,bos);
String jieguo=bos.toString();
System.out.println(jieguo);
try {
bis.close();
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void toDaxie(ByteArrayInputStream bis,ByteArrayOutputStream bos){
int i;
while((i=bis.read())!=-1){
int j;
j=Character.toUpperCase(i);
bos.write(j);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test();
}
}
PipedInputStream,PipedOutputStream:
/**
* 知识点：
* Piped 流
* 用于线程间的通讯
* 程序目标：
* 一个线程控制输出，一个控制输入
*/
package MY.module10;
import java.io.*;
public class piped {
public static void test(){
send s=new send();
gend g=new gend();
PipedOutputStream pos=s.getPos();
PipedInputStream pis=g.getPis();
try {
pos.connect(pis);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
s.start();
g.start();
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test();
}
}
class send extends Thread{
PipedOutputStream pos=new PipedOutputStream();
public PipedOutputStream getPos() {
return pos;
}
public void run(){
String s="hello world!";
try {
pos.write(s.getBytes());
pos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class gend extends Thread{
PipedInputStream pis=new PipedInputStream();
public PipedInputStream getPis() {
return pis;
}
public void run(){
byte[] b=new byte[32];
try {
int length=pis.read(b);
System.out.println(new String(b,0,length));
pis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
转换流： OutputStreamWriter,InputStreamReader:
/**
* 知识点：
* 转换流
* 程序目标：
* 将字节流转换为字符流进行输入输出
*/
package MY.module10.bytetochar;
import java.io.*;
public class TestByteToChar {
public static void test1() throws IOException{
FileOutputStream fos=null;
fos=new FileOutputStream("h://mytest//test1//test3//hello.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos);
BufferedWriter bw=new BufferedWriter(osw);
String s="hello world!";
bw.write(s);
bw.close();
}
public static void test2() throws IOException{
BufferedReader br=null;
br=new BufferedReader(new InputStreamReader(new FileInputStream("h://mytest//test1//test3//hello.txt")));
String s=null;
while((s=br.readLine())!=null){
System.out.println(s);
s=br.readLine();
}
br.close();
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
test1();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
test2();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
System.in:
/**
* 知识点：
* System.in
* 程序目标：
* 从键盘得到输入的字符，然后打印到屏幕上，并且保存在一个文件中
*/
package MY.module10.bytetochar;
import java.io.*;
public class TestSystemin {
public static void test1() throws IOException{
InputStreamReader isr=new InputStreamReader(System.in);
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("h://mytest//test1//test3//hello.txt",true));
BufferedReader br=new BufferedReader(isr);
BufferedWriter bw=new BufferedWriter(osw);
String s=br.readLine();
while(!s.equals("goodbye")){
System.out.println(s);
s=br.readLine();
bw.write(s);
}
bw.close();
br.close();
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
test1();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
PrintWriter:
/**
* 知识点：
* printWriter
* 程序目标：
* 将信息输出到一个文件中
*/
package MY.module10.printWriter;
import java.io.*;
public class printWriter {
public static void test(){
PrintWriter pw=null;
try {
pw=new PrintWriter(new FileWriter("h://mytest//test1//test3//hello.txt"));
pw.println("asdkfjlakjdsflkj");
pw.println("hello world");
pw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
test();
}
}
对象序列化： ObjectOutputStream
什么是对象序列化？就是将对象输出到文件中，属于对象流，可以对对象进行文件输入输出，作用就是可以将一个类中对象的信息输出到远程（或本地）文件中，并可以从里面读取这些对象信息
这个对象的类需要实现 Serializable 接口：这个接口只是一个标识
/**
* 知识点：
* 对象序列化： ObjectOutputStream,ObjectInputStream
* Serializable 接口：要想让一个类的对象序列化，必须让该类实现
* Serizlizable 接口
* transient: 如果不想让对象中的一个属性序列化，就使用这个修饰属性
* 程序目标：
* 将一个类的对象写入到一个文件中，并从这个文件中得到这个对象，
* 并且打印出来
*/
package MY.module10.serializables;
import java.io.*;
public class TestObject {
public static void test1() throws FileNotFoundException, IOException{
ObjectOutputStream oos=null;
oos=new ObjectOutputStream(new FileOutputStream("h://mytest//hello.txt"));
Person p=new Person("luzhen",23);
oos.writeObject(p);
oos.close();
}
public static void test2() throws FileNotFoundException, IOException, ClassNotFoundException{
ObjectInputStream ois=null;
ois=new ObjectInputStream(new FileInputStream("h://mytest//hello.txt"));
Person p1=(Person)ois.readObject();
System.out.println(p1.getName()+":"+p1.getAge());
System.out.println(p1);
ois.close();
}
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
// TODO Auto-generated method stub
// test1();
test2();
}
}
class Person implements Serializable{
private String name;
private transient int age;
Person(String name, int age) {
super();
// TODO Auto-generated constructor stub
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
// TODO Auto-generated method stub
StringBuffer sb=new StringBuffer();
sb.append(name+":");
sb.append(age);
return sb.toString();
}
}