Java IO操作的实例代码

Java IO操作的实例代码（部分来自网络源码）

//**
 * 程序输出的时候会有乱码,原因是因为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);
            }
        }
}

Java代码 复制文件
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("文件已复制");  
    }  
} 

 

从文件里读取字符数据
Java代码
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("文件读取错误");  
        }  
    }  
} 

向文件里写字符数据 下面这个小程序可以写出全世界所有的字符
Java代码
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(b=0;b<65536;b++) {

                fw.write(b);

                }

                fw.flush();

                fw.close();
        }   catch(FinleNotFoundException e) {

            e.printStackTrace();
           System.out.println(e.getMessage());
           System.exit(0);

        }  catch(IOException e) {

             e.printStackTrace();
           System.out.println(e.getMessage());
           System.exit(0);

        }
    }  
} 

带缓冲区功能的输入流
Java代码
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();  
        }  
    }  
} 

Java代码 修饰流的使用
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("读取文件出错");  
        }  
    }  
} 

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

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

Java代码
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;}  
    }  
  }  
} 

Java代码
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("无法读取文件");  
    }  
  }  
} 

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

Java代码
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  
}