IO流-数据流、对象流(序列化与反序列化)、打印流

简介:

数据流:DataOutputStream

 
 
  1. public class TestDataStream 
  2.     public void writeData() 
  3.     { 
  4.         double[] arrays = new double[1000]; 
  5.         Arrays.fill(arrays, Math.PI); 
  6.          
  7.         String fileName = "F:/java/test2.txt"
  8.         FileOutputStream out; 
  9.         DataOutputStream dos = null
  10.         try 
  11.         { 
  12.             out = new FileOutputStream(fileName); 
  13.             dos = new DataOutputStream(out); 
  14.             for (int i = 0; i < arrays.length; i++) 
  15.             { 
  16.                 dos.writeDouble(arrays[i]); 
  17.             } 
  18. //            dos.write(123); 
  19. //            dos.writeBoolean(true); 
  20. //            dos.writeChar('Z'); 
  21. //            dos.writeDouble(Math.PI); 
  22.             dos.flush(); 
  23.         } 
  24.         catch (FileNotFoundException e) 
  25.         { 
  26.             e.printStackTrace(); 
  27.         } 
  28.         catch (IOException e) 
  29.         { 
  30.             e.printStackTrace(); 
  31.         } 
  32.         finally 
  33.         { 
  34.             if (dos != null
  35.             { 
  36.                 try 
  37.                 { 
  38.                     dos.close(); 
  39.                 } 
  40.                 catch (IOException e) 
  41.                 { 
  42.                     e.printStackTrace(); 
  43.                 } 
  44.             } 
  45.         } 
  46.     } 
  47.      
  48.     public static void main(String[] args) 
  49.     { 
  50.         TestDataStream tds = new TestDataStream(); 
  51.         tds.writeData();      
  52.     } 
  53.      

 

数据流:DataInputStream

 
 
  1. public class TestDataInputStream 
  2.     public static void main(String[] args) 
  3.     { 
  4.         String fileName = "F:/java/test2.txt"
  5.         FileInputStream in = null
  6.         DataInputStream dis = null
  7.         try 
  8.         { 
  9.             in = new FileInputStream(fileName); 
  10.             dis = new DataInputStream(in); 
  11.             for (int i = 0; i < 1000; i++) 
  12.             { 
  13.                 System.out.println(dis.readDouble() + "i: " + i); 
  14.             } 
  15. //            System.out.println(dis.read()); 
  16. //            System.out.println(dis.readBoolean()); 
  17. //            System.out.println(dis.readChar()); 
  18. //            System.out.println(dis.readDouble()); 
  19.         } 
  20.         catch (FileNotFoundException e) 
  21.         { 
  22.             e.printStackTrace(); 
  23.         } 
  24.         catch (IOException e) 
  25.         { 
  26.             e.printStackTrace(); 
  27.         } 
  28.         finally 
  29.         { 
  30.             if (dis != null
  31.             { 
  32.                 try 
  33.                 { 
  34.                     dis.close(); 
  35.                 } 
  36.                 catch (IOException e) 
  37.                 { 
  38.                     e.printStackTrace(); 
  39.                 } 
  40.             } 
  41.         } 
  42.     } 

 

对象流:ObjectOutputStream(unserializable)、ObjectInputStream(serializable)

 
 
  1. public class TestSerializable 
  2.     public static void main(String[] args) 
  3.     { 
  4.         TestSerializable ts = new TestSerializable(); 
  5.         ts.serializable(); 
  6.         ts.unserializable(); 
  7.     } 
  8.     public void serializable()//序列化,写入 
  9.     { 
  10.         String filename = "F:/java/stu.txt"
  11.         Student s1 = new Student("haoyouduo",1987); 
  12.          
  13.         FileOutputStream fis =null
  14.         ObjectOutputStream ois = null
  15.         try 
  16.         { 
  17.             fis = new FileOutputStream(filename); 
  18.             ois = new ObjectOutputStream(fis); 
  19.             ois.writeObject(s1); 
  20.             ois.flush(); 
  21.         } 
  22.         catch (FileNotFoundException e) 
  23.         { 
  24.             e.printStackTrace(); 
  25.         } 
  26.         catch (IOException e) 
  27.         { 
  28.             e.printStackTrace(); 
  29.         } 
  30.         finally 
  31.         { 
  32.             if(null != ois) 
  33.             { 
  34.                 try 
  35.                 { 
  36.                     ois.close(); 
  37.                 } 
  38.                 catch (IOException e) 
  39.                 { 
  40.                     e.printStackTrace(); 
  41.                 } 
  42.             } 
  43.         } 
  44.          
  45.     } 
  46.     public void unserializable()//反序列化,读取 
  47.     { 
  48.         String filename = "F:/java/stu.txt"
  49.         FileInputStream fis = null
  50.         ObjectInputStream ois = null
  51.         try 
  52.         { 
  53.             fis = new FileInputStream(filename); 
  54.             ois = new ObjectInputStream(fis); 
  55.             Student s = (Student)ois.readObject(); 
  56.             System.out.println(s); 
  57.              
  58.         } 
  59.         catch (FileNotFoundException e) 
  60.         { 
  61.             e.printStackTrace(); 
  62.         } 
  63.         catch (IOException e) 
  64.         { 
  65.             e.printStackTrace(); 
  66.         } 
  67.         catch (ClassNotFoundException e) 
  68.         { 
  69.             e.printStackTrace(); 
  70.         } 
  71.         finally 
  72.         { 
  73.             if(ois != null
  74.             { 
  75.                 try 
  76.                 { 
  77.                     ois.close(); 
  78.                 } 
  79.                 catch (IOException e) 
  80.                 { 
  81.                     e.printStackTrace(); 
  82.                 } 
  83.             } 
  84.         } 
  85.          
  86.     } 
  87.  
  88. class Student implements Serializable//对象类必须实现可序列化的 
  89.     String name; 
  90.     int age; 
  91.     public Student(String name,int age) 
  92.     { 
  93.         this.name = name; 
  94.         this.age = age; 
  95.     } 
  96.     @Override 
  97.     public String toString() 
  98.     { 
  99.         return "Student [name=" + name + ", age=" + age + "]"
  100.     } 
  101.  
  102.      

 

打印流:PrintStream

 
 
  1. public class Test 
  2.     public static void main(String[] args) 
  3.     { 
  4.         boolean flag = 2 > 1
  5.         if (flag) 
  6.         { 
  7.             System.out.println("sss"); 
  8.         } 
  9.         else 
  10.         { 
  11.             System.out.println("aaa"); 
  12.         } 
  13.          
  14.         System.out.println("使用printStream之前"); 
  15.  
  16.         /** 
  17.          * 上面部分的内容将打印在控制台里 
  18.          * 下面部分的内容不会打印在控制台里,而是文件里 
  19.          */ 
  20.          
  21.         String filename = "f:/java/log.txt"
  22.         FileOutputStream fos; 
  23.         PrintStream ps = null
  24.         try 
  25.         { 
  26.             fos = new FileOutputStream(filename); 
  27.             ps = new PrintStream(fos); 
  28.             System.setOut(ps); 
  29.             System.out.println("这将打印在文件里"); 
  30.             System.out.println("使用printStream之后"); 
  31.         } 
  32.         catch (FileNotFoundException e) 
  33.         { 
  34.             e.printStackTrace(); 
  35.         } 
  36.         finally 
  37.         { 
  38.             if (ps != null
  39.             { 
  40.                 ps.close(); 
  41.             } 
  42.         } 
  43.     } 

 





本文转自 glblong 51CTO博客,原文链接:http://blog.51cto.com/glblong/1191874,如需转载请自行联系原作者
目录
相关文章
|
1月前
|
存储 安全 Java
Java一分钟之-Java序列化与反序列化
【5月更文挑战第14天】Java序列化用于将对象转换为字节流,便于存储和网络传输。实现`Serializable`接口使类可被序列化,但可能引发隐私泄露、版本兼容性和性能问题。要避免这些问题,可使用`transient`关键字、控制`serialVersionUID`及考虑使用安全的序列化库。示例代码展示了如何序列化和反序列化对象,强调了循环引用和未实现`Serializable`的错误。理解并妥善处理这些要点对优化代码至关重要。
28 1
|
5天前
|
网络协议 Java API
【Java】序列化和反序列化
【Java】序列化和反序列化
15 4
|
9天前
|
Java 数据安全/隐私保护 Android开发
Java基础21-读懂Java序列化和反序列化(二)
Java基础21-读懂Java序列化和反序列化(二)
8 1
|
9天前
|
XML 存储 Java
Java基础21-读懂Java序列化和反序列化(一)
Java基础21-读懂Java序列化和反序列化(一)
11 1
|
15天前
|
JSON 缓存 Java
【Java基础】 序列化和反序列化
Java中的序列化(Serialization)和反序列化(Deserialization)是将对象和字节流之间进 行相互转换的过程。这两个过程用于保存对象的状态并能够在需要时恢复这些状态。
12 1
|
2天前
|
存储 安全 网络协议
【JAVA反序列化】序列化与反序列化&Java反射&URLDNS链
【JAVA反序列化】序列化与反序列化&Java反射&URLDNS链
|
30天前
对象数组序列化和反序列化
对象数组序列化和反序列化
21 1
|
18天前
|
Java
文件操作与IO(3) 文件内容的读写——数据流
文件操作与IO(3) 文件内容的读写——数据流
13 0
|
29天前
使用序列化和反序列化函数archivedDataWithRootObject和unarchivedObjectOfClasses的使用和遇到问题及解决方案
使用序列化和反序列化函数archivedDataWithRootObject和unarchivedObjectOfClasses的使用和遇到问题及解决方案
23 0
|
30天前
|
前端开发 数据库
省市区三级联动数据本地序列化和反序列化
省市区三级联动数据本地序列化和反序列化
22 0