io流

 1 package Io;
 2 import java.io.*;
 3 public class TestFileInputStream {
 4         
 5         public static void main(String[] args) {
 6             int b=0;
 7             FileInputStream in=null;
 8             try {
 9                 //初始化FileInputStream对象
10                 in=new FileInputStream("D:\\1.txt");
11             } catch (FileNotFoundException e) {
12                 System.out.println("文件不存在");
13                 System.exit(-1);
14             }
15             try {
16                 long num=0;
17                 //每次读取一个字符，并且把字符赋给b
18                 while((b=in.read())!=-1){
19                     System.out.print((char)b);
20                     num++;
21                 }
22                 //每次读取必须关闭
23                 in.close();
24                 System.out.println("共输出"+num+"个字节");
25             } catch (IOException e) {
26                 System.out.println("文件读取错误");
27                 System.exit(-1);
28             }
29         }
30 }

 1 package Io;
 2 import java.io.*;
 3 public class TestFileOutputStream {
 4     public static void main(String[] args)  {
 5         int b;
 6     try {
 7         FileInputStream in=new FileInputStream("D:\\1.txt");
 8         FileOutputStream out=new FileOutputStream("D:\\2.txt");
 9         while((b=in.read())!=-1){
10             out.write(b);
11         }
12         in.close();
13         out.close();
14     } catch (FileNotFoundException e) {
15         System.out.println("文件不存在");
16         System.exit(-1);
17     }catch (IOException e) {
18         System.out.println("文件复制失败");
19         System.exit(-1);
20     }
21     System.out.println("复制成功");
22         
23     }
24 
25 }

 1 package Io;
 2 import java.awt.image.BufferStrategy;
 3 import java.io.*;
 4 public class TestBufferStream {
 5     public static void main(String[] args) {
 6         int b;
 7         try {
 8             BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\3.txt"));
 9             BufferedReader br=new BufferedReader(new FileReader("D:\\3.txt"));
10             
11             for(int i=0;i<100;i++){
12                 bw.write(String.valueOf( Math.random()));
13                 bw.newLine();
14             }
15             bw.flush();
16             while ((br.readLine())!=null) {
17                 System.out.println(br.readLine());
18                 
19             }
20             bw.close();
21             br.close();
22         } catch (FileNotFoundException e) {
23             System.out.println("文件不存在");
24         }catch (IOException e) {
25             System.out.println("文件读写错误");
26         }
27         System.out.println("文件读写成功");
28     }
29 }

 1 package Io;
 2 import java.io.*;
 3 public class TestTransform1 {
 4     public static void main(String[] args) {
 5         try {
 6             //OutputStreamWriter为转换流，把FileOutputStream转换为字符输出
 7             OutputStreamWriter ow=new OutputStreamWriter(new FileOutputStream("D:\\4.txt"));
 8             ow.write("Java come on");
 9             //getEncoding获得内容的编码
10             System.out.println(ow.getEncoding());
11             ow.close();
12             //FileOutputStream的第二个参数为true，则在原文件后添加内容
13             //OutputStreamWriter第二个参数为以什么字符编码进行写入
14             ow=new OutputStreamWriter(new FileOutputStream("D:\\4.txt",true),"iso8859_1");
15             ow.write("Java come on");
16             ow.close();
17         } catch (IOException e) {
18             System.out.println("文件读取错误");
19         }
20          
21     }
22 }

 1 package Io;
 2 import java.io.*;
 3 public class TestTransForm {
 4     public static void main(String[] args) {
 5         InputStreamReader ir=new InputStreamReader(System.in);
 6         //使用BufferedReader是便于使用readLine方法
 7         BufferedReader br=new BufferedReader(ir);
 8         String s=null;
 9         try {
10             //readLine按行读入
11             s=br.readLine();
12             while(s!=null){
13                 //toUpperCase将字母转换为大写输出
14                 System.out.println(s.toUpperCase());
15                 //忽略大小写判断输入的是否是exit
16                 if(s.equalsIgnoreCase("exit")){break;};
17                 s=br.readLine();
18                 
19             }
20         } catch (IOException e) {
21             e.printStackTrace();
22         }
23     }
24 }

 1 import java.io.*;
 2 public class TestDataStream {
 3     public static void main(String[] args) {
 4         ByteArrayOutputStream bs=new ByteArrayOutputStream();
 5         //DataOutputStream可以直接读取各种类型数据
 6         DataOutputStream ds=new DataOutputStream(bs);
 7         try {
 8             //把double类型数据写入
 9             ds.writeDouble(Math.random());
10             //把布尔类型数据写入
11             ds.writeBoolean(true);
12             ByteArrayInputStream bis=new ByteArrayInputStream(bs.toByteArray());
13             //输出可用的数据
14             System.out.println(bis.available());
15             //DataInputStream可以直接读出数据
16             DataInputStream dis=new DataInputStream(bis);
17             //直接读出double类型数据
18             System.out.println(dis.readDouble());
19             //直接读出Boolean类型数据
20             System.out.println(dis.readBoolean());
21         } catch (IOException e) {
22             e.printStackTrace();
23         }
24     }
25 
26 }

 1 package Io;
 2 import java.io.*;
 3 import java.util.Date;
 4 public class TestPrintStream1 {
 5     public static void main(String[] args) {
 6         String s=null;
 7         //普通的输入流上嵌套BufferedReader，以使用readLine，System.in是从屏幕中获取输入
 8         BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
 9         try {
10             //和文件连接
11             FileWriter fw=new FileWriter("D:\\5.log",true);
12             //在普通文件流上嵌套print流
13             PrintWriter pw=new PrintWriter(fw);
14             //按行阻塞式读取
15             while((s=br.readLine())!=null){
16                 //忽略大小写判断是否是exit
17                 if(s.equalsIgnoreCase("exit"))break;
18                 //将其转换为大写输出
19                 System.out.println(s.toUpperCase());
20                 //输出到日志文件中
21                 pw.println(s.toUpperCase());
22                 pw.println("--------");
23                 //把缓冲区中的所有文件全部添加到文件中
24                 pw.flush();
25             }
26             //new Date()获取当前时间
27             pw.println("-----"+new Date()+"------");
28             pw.flush();
29             pw.close();
30         } catch (IOException e) {
31             e.printStackTrace();
32         }
33     }
34 
35 }

 1 package Io;
 2 import java.io.*;
 3 public class TestPrintStream2 {
 4     public static void main(String[] args) {
 5         //print字节流
 6         PrintStream pw=null;
 7         try {
 8             FileOutputStream fs=new FileOutputStream("D:\\5.txt");
 9                  pw=new PrintStream(fs);
10             
11         } catch (IOException e) {
12             e.printStackTrace();    
13         }
14             if (pw!=null) {
15                 //将输出到pw中
16                 System.setOut(pw);
17             }
18             int l=0;
19             //把60000个字符全部输出
20             for(char c=0;c<=60000;c++){
21                 l++;
22                 System.out.print(c);
23                 if(l==100){System.out.println();l=0;}
24             }
25     }
26 }

 1 import java.io.*;
 2 public class TestObject {
 3     public static void main(String[] args)throws Exception {
 4         T t=new T();
 5         t.a=7;
 6         FileOutputStream fo=new FileOutputStream("D:\\5.dat");
 7         //加上ObjectOutputStream就可以在原来的基础上直接往文件中存对象
 8         ObjectOutputStream os=new ObjectOutputStream(fo);
 9         os.writeObject(t);
10         FileInputStream fs=new FileInputStream("D:\\5.dat");
11         //加上ObjectOutputStream就可以在原来的基础上直接从文件中读对象
12         ObjectInputStream oi=new ObjectInputStream(fs);
13         //读出对象，并且强制转换为T 对象
14         T newT=(T)oi.readObject();
15         System.out.println(newT.a+" "+newT.j+" "+newT.i);
16     }
17     
18 }
19 class T implements Serializable{
20     int j=4;
21     int i=2;
22     int a=9;
23 }