Java对IO的操作

声明:来自尚学党马老师的教程代码

节点流类型(一根管直接插到下面的类型上,下面的管道指的是线程和线和之间的通讯) 
 

类型	字符流	字节流
File	FileReader	FileInputStream
	FileWriter	FileOutputStream
Memory Array	CharArrayReader	ByteArrayInputStream
	CharArrayWriter	ByteArrayOutputStream
Memory String	StringReader
	StringWriter
Pipe(管道)	PipedReader	PipedInputStream
	PipedWriter	PipedOutputStream

 

缓冲流要"套接"在相应的节点流之上,对读写的数据提供了缓冲的功能,提高了读写的效
对于输出的缓冲流,写出的数据会先在内存中缓存,使用flush方法将会使内在中的数据立刻写出

 

转换流
InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换
InputStreamReader需要和InputStream"套接"
OutputStreamReader需要和OutputStream"套接"

/**
 * 程序输出的时候会有乱码,原因是因为read()方法读取一个字节,中文字符
 * 是由两个字节构成,取一个字节(字符的一半)就转成一个字符,所以输出就会是乱码
 * @author DaHai
 *
 */
 public class TestFileInputStream{
     public static void main(String args[]){
             int b = 0;
             FileInputStream in = null;
             try{
                 in = new FileInputStream("c:\\TestFileInputStream.java");
             }catch(FileNotFoundException e){
                 System.out.println("找不到指定的文件");
                //终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非零的状态码表示异常终止。 
                System.exit(-1);    
            }
            try{
                long num = 0;
                //只有读到文件的结尾才为-1
                while((b=in.read())!=-1){
                    System.out.print((char)b);
                    num++;    
                }
                in.close();
                System.out.println();
                System.out.println("共读取了"+ num +"个字节");
            }catch(IOException e){
                System.out.println("文件读取错误");
                System.exit(-1);
            }
        }
}

import java.io.*;
 public class TestFileOutputStream{
     public static void main(String args[]){
         int b = 0;
         FileInputStream in = null;
         FileOutputStream out = null;
         try{
             in = new FileInputStream("c:\\TestFileInputStream.java");
             //如果这个时候C盘下面还没有Test.java,那么new FileOutputStream会创建一个空的Test.java文件,但不会创建目录
             out = new FileOutputStream("c:\\Test.java");
            while((b = in.read())!=-1){
                    out.write(b);
            }
            in.close();
            out.close();
        }catch(FileNotFoundException e){
            System.out.println("找不到指定文件");
            System.exit(-1);
        }catch(IOException e){
            System.out.println("文件复制错误");
            System.exit(-1);
        }
        System.out.println("文件已复制");
    }
}

从文件里读取字符数据

import java.io.*;
 public class TestFileReader{
     public static void main(String args[]){
         FileReader fr = null;
         int c = 0;
         try{
             fr = new FileReader("c:\\TestFileReader.java");
             while((c = fr.read())!=-1){
                 System.out.print((char)c);
            }
        }catch(FileNotFoundException e){
            System.out.println("系统找不到指定的文件");
        }catch(IOException e){
            System.out.println("文件读取错误");
        }
    }
}

向文件里写字符数据

import java.io.*;
public class TestFileWriter{
    public static void main(String args[]){
        FileWriter fw = null;
        int b = 0;
        try{
            fw = new FileWriter("c:\\Unicode.dat");
            for(int i=0;i);
        }
    }
}

带缓冲区功能的输入流

import java.io.*;
public class TestBufferStream{
    public static void main(String args[]){
        try{
        	//一个字节的输入流并且不带缓冲区
            FileInputStream fis = new FileInputStream("c:\\TestFileInputStream.java");
            //相当于在上面的fis流上又套了一层管道,实际上读取的是一样的数据,但是它有了带缓冲区的功能
            BufferedInputStream bis = new BufferedInputStream(fis);
            int c = 0;
            System.out.println(bis.read());
            System.out.println(bis.read());
            //mark一个标记,从第100个开始往外读
            bis.mark(100);
            for(int i=0;i<10 && (c=bis.read())!=-1;i++){
                System.out.print((char)c+" ");
            }
            System.out.println();
            //重置到上面的mark处
            bis.reset();
            for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
                System.out.print((char)c+" ");    
            }
            bis.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

import java.io.*;

public class TestBufferStream {
	public static void main(String args[]) {
		try {
			//在FileWriter写出一个字符外面套层BufferedWriter管道
			BufferedWriter bw = new BufferedWriter(new FileWriter("c:\\write.txt"));
			BufferedReader br = new BufferedReader(new FileReader("c:\\write.txt"));
			String s = null;
			for (int i = 0; i <= 100; i++) {
				s = String.valueOf(Math.random());
				bw.write(s);
				bw.newLine();
			}
			bw.flush();
			// readLine()方法为读一行数据
			while ((s = br.readLine()) != null) {
				System.out.println(s);
			}
			bw.close();
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("读取文件出错");
		}
	}
}

import java.io.*;
public class TestTransForm2{
    public static void main(String args[]){
        //等待从键盘的输入,System.in可以理解为一根管道直接插在了键盘上
    	//System.in字节流输入一个字节,外面套层InputStreamReader转换流
        InputStreamReader isr = new InputStreamReader(System.in);
        //isr转换流的外面又套层缓冲流,为了使用下面的readLine()方法,可以记取一行
        BufferedReader br = new BufferedReader(isr);
        String s = null;
        try{
            s = br.readLine();
            while(s!=null){
                if(s.equalsIgnoreCase("exit")) break;
                System.out.println(s.toUpperCase());
                s = br.readLine();
            }
            br.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

import java.io.*;
 public class TestDataStream {
   public static void main(String[] args) {
       //在内存中定义了一个空间,同时一根管道插在了上面
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
    //DataOutputStream直接写基础数据类型(boolean,double等),而且可以写UTF-8(省空间,网络上常用)
    DataOutputStream dos = new DataOutputStream(baos);
    try {
      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();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

import java.io.*;
public class TestPrintStream1 { 
  public static void main(String[] args) {
    PrintStream ps = null;
    try {
      FileOutputStream fos = new FileOutputStream("d:\\bak\\log.dat");
      ps = new PrintStream(fos);
    } catch (IOException e) {
      e.printStackTrace();
    }
    if(ps != null){
      System.setOut(ps);
    }
    int ln = 0;
    for(char c = 0; c <= 60000; c++){
      System.out.print(c+ " ");
      if(ln++ >=100){ System.out.println(); ln = 0;}
    }
  }
}

import java.io.*;
public class TestPrintStream2 {
  public static void main(String[] args) {
    String filename = args[0];
    if(filename!=null){list(filename,System.out);}
  }
  public static void list(String f,PrintStream fs){
    try {
      BufferedReader br = new BufferedReader(new FileReader(f));
      String s = null; 
      while((s=br.readLine())!=null){
        fs.println(s);            
      }
      br.close();
    } catch (IOException e) {
      fs.println("无法读取文件");
    }
  }
}

import java.util.*; 
import java.io.*;
public class TestPrintStream3 {
   public static void main(String[] args) {
     String s = null;
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    try {
      FileWriter fw = new FileWriter("d:\\bak\\logfile.log", true); 
      PrintWriter log = new PrintWriter(fw);
      while ((s = br.readLine())!=null) {
        if(s.equalsIgnoreCase("exit")) break;
        System.out.println(s.toUpperCase());
        log.println("-----");
        log.println(s.toUpperCase()); 
        log.flush();
      }
      log.println("==="+new Date()+"==="); 
      log.flush();
      log.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

import java.io.*;

public class TestObjectIO {
    public static void main(String args[]) throws Exception {
        T t = new T();
        t.k = 8;
        FileOutputStream fos = new FileOutputStream("d:/share/java/io/testobjectio.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(t);
        oos.flush();
        oos.close();
        
        FileInputStream fis = new FileInputStream("d:/share/java/io/testobjectio.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);
        T tReaded = (T)ois.readObject();
        System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);
   }
}

/**序列化
 *1.一个Object直接转换成为字节流写到硬盘或网络上去
 *2.标记作用
 *3.里面没有任何方法,给JDK看,JDK看到它就知道可以序列化了
 *4.直接实现这个接口,是JKD帮你控制这个对象
 *5.把一个对象直接写到硬或网络上应当把它序列化成一个字节流必须实现这个接口
 */
class T implements Serializable
{
    int i = 10;
    int j = 9;
    double d = 2.3;
    int k = 15;
    //transient透明的,它修饰的成员变量在序列化的时候不予考虑
    //transient int k = 15;  直行的时候,k为0
}