javase_16(其它流)

_kudy

浏览: 15102 次
性别:
来自: 广州

最近访客更多访客>>

Baby真卑鄙

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

1.javaSeBase

IO包中的其他流:

1.打印流

a)PrintWriter(写-->print打印) 与PrintStream (字符流)

PrintWriter用法一:其实它是对一个Writer进行了封装
 package com.javami.kudyTest; 
 import java.io.FileNotFoundException;
 import java.io.PrintWriter;
 public class PrintWriterTest {
     /*
      * PrintWriter 是对Writer 进行了一个封装
      */
     public static void main(String[]args) throws FileNotFoundException
     {
         PrintWriter pw = new PrintWriter("src/a.txt");
         int num = 98; //char类型占了一个类型
      //    pw.write(num); //输出了一个char类型的
         pw.print(num); //输出的是int类型的
         /*
          * 其实里面做的事情
          * String str = str.valueOf(int) //转换成字符串   再转换为字节 98 
          * 而我们系统默认的字节编码格式每一个字符是占了1位的,所以显示出来的结果为是2bytes
          * ---------------------------------
          * String str = str.valueOf(num);
          * byte[]buf = str.getBytes(); //转换成字节
          * for(byte ch :buf)
          *     while(ch);
          */
         pw.close();
 
     }
 }
 第二:PrintStream
 是继承于OutputStream(输出流(字节流))
 package com.javami.kudyTest;
 import java.io.FileNotFoundException;
 import java.io.PrintStream;
 public class PrintStreamTest {
     /*
      * PrintStream 的应用:
      * 这是一个字节流: 输出字节流
      * (写数据)
      * 继承于:OutputStream
      */
     public static void main(String[]args) throws FileNotFoundException
     {
         PrintStream ps = new PrintStream("src/b.txt");
 //        int num = 98;
 //        ps.write(num); 
         
         int num = 97;
         ps.print(num); //本质上是没有区别.但是内部实现原理就有区别 (占了2个字节)
         
         /*
          * 实现原理和PrintWriter很想:
          * String str = str.valueOf(num); //转换成字符
          * byte[] buf = str.getBytes();
          * for(byte b : buf)
          * {
          *       字节数现在为2  存入的是字节.之后系统会根据系统的编码格式进行了一个解码
          * }
          */
     }
 }

2.序列流

b)SequencelnputStream(假设我有多个文本.需要合并成一个文本)

package com.javami.kudyTest;
 
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.FileOutputStream;
 import java.io.SequenceInputStream;
 import java.util.Enumeration;
 import java.util.Vector;
 import java.util.Iterator;
 public class SequenceInputStreamTest {
     /*
      * 序列流
      */
     public static void main(String[]args) throws IOException
     {
         /*
          * 读取两个文本的方式
          */
         InputStream is1 = new FileInputStream("src/a.txt");
         InputStream is2 = new FileInputStream("src/b.txt");
         OutputStream os = new FileOutputStream("src/c.txt");
         //读取两个参数
         SequenceInputStream sis = new SequenceInputStream(is1,is2);
         byte[] buf = new byte[1024];
         int ch;
         while((ch=sis.read(buf))!=-1)
         {
             os.write(buf,0,ch);
         }
         
         //关流,由于SequenceInputStream 是一个包装类.但把这个流关闭.会把底层的两个流也关
         sis.close();
         os.close();
         
         /*
          * 如果我有很多文本需要合并内容的,但是构造方法只能传递进去.这时候如果用到带两个参数的构造方法来传递就不是太方便啦~~
          * 那么我可以使用使用到枚举+集合
          */
         InputStream isone = new FileInputStream("src/a.txt");
         InputStream istwo = new FileInputStream("src/b.txt");
         InputStream isthree = new FileInputStream("src/c.txt");
         OutputStream osone = new FileOutputStream("src/happy.txt");
         Vector<InputStream> v = new Vector<InputStream>();
         v.add(isone);
         v.add(istwo);
         v.add(isthree);
 /*        //枚举里面我需要使用的是InputStream 
         Enumeration<InputStream> e = v.elements();
         //读取枚举里面的内容.再写入到一个文本里面去
         //里面只能放一个枚举类型.并且这个枚举类型的泛型是继承于InputStream的
         SequenceInputStream sisone = new SequenceInputStream(e);     //读写集合里面的内容.已经合并在一起啦
         int len;
         while((len=sisone.read())!=-1)
         {
             osone.write(len);
         }
         //关流
         sisone.close(); //这个如果关流.已经把底层的三个流已经被关闭
         osone.close();*/
         
         //看第二种方式:  产生一个迭代器
         final Iterator<InputStream> it = v.iterator();
         SequenceInputStream sistwo = 
                 new SequenceInputStream(new Enumeration<InputStream>(){
 
                     @Override
                     //这里面是否有更多的元素呢?
                     public boolean hasMoreElements() {
                         
                         return it.hasNext();
                     }
 
                     @Override
                     //下一个元素为多少呢?
                     public InputStream nextElement() {
                         // TODO Auto-generated method stub
                         return it.next();
                     }
                     
                 });
         int len;
         //一个字符一个字符读取进去的方式啊?没有包装的.哥们.难道你忘记啦?
         //不读出来怎么写? 您教我.
         while((len=sistwo.read())!=-1)
         {
             osone.write(len); //读一个字节.写一个字节
         }
         
     }
 }

3.操作对象

c)ObjectinputStream与ObjectOutputStream(对象必须要实现Serializable这个接口,做为标记需要使用序列或者序列化

package com.javami.kudyTest;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.FileOutputStream;
 import java.io.Serializable;
 
 public class ObjectStreamTest {
     /*
      * 对象序列化:
      * 有的时候我们需要找一种数据对内存中的对象进行描述.便于保存.这时,可能每个程序员都有自己的想法.
      * 都会去使用自己习惯的方式,对象的序列化,就是按照java规定格式对对象转换成一种数据,编译保存.这个过程就是对象的序列化
      * 将数据的格式转换成对象就是叫做反序列化
      */
     public static void main(String[]args) throws FileNotFoundException, IOException, ClassNotFoundException
     {
 /*        Person p1 = new Person("张三",18);
         Person p2 = new Person("王五",19);
         Person p3 = new Person("李四",20);
         Person p4 = new Person("大毛",21);*/
         
         /*
         ObjectOutputStream  oos =
                     new ObjectOutputStream(new FileOutputStream("src/1.txt"));
         oos.writeObject(p1); //父类型的引用可以指向子类型的对象
         oos.writeObject(p2);
         oos.writeObject(p3);
         oos.writeObject(p4);
         oos.close();
         /1.对象的序列化的第一种方式
         */
         
         /*
          * 假设我们已经序列化:现在需要反序列化>需要把对象里面的内容输出去
          */
         ObjectInputStream ois = 
                     new ObjectInputStream(new FileInputStream("src/1.txt"));
         
     
 
         while(true)
         {
             try
             {
                 Person p =(Person)ois.readObject();
                 System.out.println(p);
             }catch(IOException e)
             {
                 return ;
             }
 　　
             //如果是异常的,咱们就不执行
         }
         
     }
 }
 
 
 
 /*
  * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
  * 由于我们希望序列化的是Person 这个类.所以我们要实现这个接口
  * 这个主要就是做一个下标识
  * 但异常出现的错误为:NotSerializableException 就是说明了: 有一个类还没有被标记即将要序列化
  */ 
 class Person implements Serializable  
 {
     private String name;
     private int age;
     Person(){}
     Person(String name,int age)
     {
         this.name = name;
         this.age = age;
     }
     @Override
     public String toString()
     {
         return this.name +"@"+this.age;
     }
 }
 
 第二种方式: 可以利用集合去做一个问题
 (输入数据 通过集合读 通过遍历集合写.)  建议使用哦
 package com.javami.kudyTest;
 
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.ArrayList;
 
 /*
  * 可以通过集合去写入数据  ... 之后再通过集合遍历数据..
  */
 public class ObjetcStreamTest2 {
     public static void  main(String[]args) throws FileNotFoundException, IOException, ClassNotFoundException
     {
         
 /*        
          * 1.序列化
          
         Person p1 = new Person("张三",18);
         Person p2 = new Person("王五",19);
         Person p3 = new Person("李四",20);
         Person p4 = new Person("大毛",21);
         ObjectOutputStream oos = 
                     new ObjectOutputStream(new FileOutputStream("src/Object.txt"));
         ArrayList<Person> al = new ArrayList<Person>();
         al.add(p1);
         al.add(p2);
         al.add(p3);
         al.add(p4);
         oos.writeObject(al);
         oos.close();*/
         
         /*
          * 反序列化
          */
         ObjectInputStream ois =
                     new ObjectInputStream(new FileInputStream("src/Object.txt"));
         //要把这个类型强制转换
         ArrayList<Person> al = (ArrayList<Person>)ois.readObject();
         for(Person p  : al)
         {
             System.out.println(p);
         }
         ois.close();
     }
 }
 
 /*
  * Person  实现一个接口,标记为即将序列化或者反序列化
  */
 class Person implements Serializable  
 {
     private String name;
     private int age;
     Person(){}
     Person(String name,int age)
     {
         this.name = name;
         this.age = age;
     }
     @Override
     public String toString()
     {
         return this.name +"@"+this.age;
     }
 }

将图片切割成若干份，每10k一个文件，再使用序列流组合成图片(为什么第一张图片可以看得到呢.特征码的问题)

小练习:

package com.javami.kudyTest; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.SequenceInputStream; import java.util.Enumeration; import java.util.Vector; public class PictureCut { public static void main(String[] args) { File file = new File("f:/a/1.jpg"); try { //cutPicture(file); splicePicture(); }catch (IOException e) { // TODO: handle exception e.printStackTrace(); } } /** * 将图片分成若干份,每10K一份,再使用序列流组合图片 * 思路: 需要定义一个FileinputStream 读取一个图片. 再写入到一个FileInputStream里面去 * 定义一个byte[] buf = new byte[1024]; //缓冲区定义成1k * int count = 0; //标记循环10次.也就是10K * int num = 1; //标记图片命名 * int len ; //返回的字符 * 循环读取一个图片.当读取到10K的时候.咱们就写入到一个新的字节流里面去.. * 注意count每一次标记一下.当count等于10的时候.咱们要重新清空一下. * * */ private static void cutPicture(File file) throws IOException { FileInputStream fis = null;//输入 FileOutputStream fos = null; //输出流 try { fis = new FileInputStream(file); fos = new FileOutputStream("f:/a/a1.jpg"); //写入到这个文本里面去 byte[] buf = new byte[1024]; //1K的大小 int count = 0; //标记如果是读到10K就是一个图片 int len; int num = 1; //等待给一个图片标号 while((len=fis.read(buf))!=-1) //意思: 从缓冲区读取10K的字节内容赋给len 0,len最大字符数 { //每次从缓冲区那里边读取1K if(count==10) { count=0; //清空一下. fos.close(); //关闭上一次的流 fos = new FileOutputStream("f:/a/a"+(++num)+".jpg"); } //从缓冲区里面写入buf 0 ,len的内容 .是不是刚好1K的内容 fos.write(buf,0,len); //把10K内容写入进去 //0-9 刚好10次 //标记是否是10次 0 - 9 刚好10次 10 -19 刚好10次 ... count++; } }finally { try { if(fis!=null) fis.close(); }finally { if(fos!=null) fos.close(); } } } /* * 并且一个图片,咱们可以先读取一个图片 * 可以所以用到枚举 */ private static void splicePicture() throws IOException { /* * Vector是一个集合 */ Vector<InputStream> v = new Vector<InputStream>(); //读取图片 SequenceInputStream sis = null; FileOutputStream fos = null; v.add(new FileInputStream("F:/a/a1.jpg")); v.add(new FileInputStream("F:/a/a2.jpg")); v.add(new FileInputStream("F:/a/a3.jpg")); v.add(new FileInputStream("F:/a/a4.jpg")); v.add(new FileInputStream("F:/a/a5.jpg")); v.add(new FileInputStream("F:/a/a6.jpg")); v.add(new FileInputStream("F:/a/a7.jpg")); v.add(new FileInputStream("F:/a/a8.jpg")); v.add(new FileInputStream("F:/a/a9.jpg")); Enumeration<InputStream> e = v.elements(); //枚举类型 try { sis = new SequenceInputStream(e); fos = new FileOutputStream("src/dj.jpg"); int ch; while((ch=sis.read())!=-1) { //写入字节流 fos.write(ch); } }finally { try { if(sis!=null) sis.close(); } finally { if(fos!=null) fos.close(); } } } }

4.操作基本数据类型

d)DataInputStream 与DataOutputStream

package com.javami.kudyTest; import java.io.DataOutputStream; import java.io.DataInputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class DataStreamTest { /** * 操作基本数据类型: * 格式化数据类型: int类型占了4个字节.写在文本里面也是占了4个字节 * @throws IOException */ public static void main(String[] args) throws IOException { /*DataInputStream dis = new DataInputStream(new FileInputStream("src.ohoh.txt")); int num = 98;*?里面有98给我读取吗?*/ /*DataOutputStream dos = new DataOutputStream(new FileOutputStream("src/ohoh.txt")); //写入数据 int num = 98; //dos.writeInt(num); 是以int类型所占的字节写入进去,4个字节 String str = "abc中国人"; dos.writeUTF(str);//是以UTF编码写入进去汉字占3个字节 */ //读 DataInputStream dis = new DataInputStream(new FileInputStream("src/ohoh.txt")); /* * 是与UTF编码写进去的,咱们就用相同的码表去解码 */ String datat = dis.readUTF(); System.out.println(datat); dis.close(); /* * 将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加 4。 * */ } }

5.操作内存缓冲数组

e)ByteArrayStream与CharArrayReader

package com.javami.kudyTest; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class ByteArrayStream { /* * ByteArrayInputStream 读取字节 * ByteArrayOutputStream 写入字节 */ public static void main(String[]args) throws IOException { String chinese = "我是中国人.钓鱼岛是咱们中国的同胞的.jb帝国主义滚~~~"; byte[] buf = chinese.getBytes(); //获取到字节数组 //读取字节包装流 ByteArrayInputStream bais = new ByteArrayInputStream(buf); int len = bais.available(); //获取到字节里面有多少个字节 byte[] bufs = new byte[len]; //自定义大小做缓冲区.为什么这样做.以为我们这样做.可以节省内存空间. bais.read(bufs); //我们把定义存储到自定义缓冲区里面去 String happy = new String(bufs); System.out.println(happy); bais.close(); //写入字节包装类 ByteArrayOutputStream bos = new ByteArrayOutputStream(); bos.write("jb滚出钓鱼钓".getBytes()); byte[] jbs = bos.toByteArray(); //获取里面的数据 System.out.println(new String(jbs)); bos.close(); } /* * 一般的用法: * DataoutputStream dos = new DataOutputStream(new ByteArrayOutputStream()); */ }

6.管道流

PipedinputStream与PipedOutputStream

package com.javami.kudyTest; import java.io.IOException; import java.io.PipedInputStream; import java.io.PipedOutputStream; public class PipedStreamTest { public static void main(String[]args) throws IOException { //1.输入流读 PipedInputStream pis = new PipedInputStream(); //2.输出流写 PipedOutputStream pos = new PipedOutputStream(); //3.输入流连接输出流 pis.connect(pos); //从服务器的角度来说:向用户发出信息发出的字节 pos.write("欢迎来到本站".getBytes()); int len = pis.available(); byte[] buf = new byte[len]; //获取到一个自定义缓冲区大小数组 //自定义一个缓冲区大小.把内容读取到这边来 pis.read(buf); //把内容读取到一个buf里面去 //已经被独到了buf里面去 String user = new String(buf); System.out.println(user); pis.close(); pos.close(); } }

7.RandomAccessFile 实现了该类的实例支持对随机文件的读取和写入

package com.javami.kudyTest; import java.io.IOException; import java.io.RandomAccessFile; public class RandomAccessFileTest { /** * 编写一个程序,记录该程序运行次数,运行满足30day.就提示软件到期 * @throws IOException * @throws NumberFormatException */ public static void main(String[] args) throws IOException { //打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。 //读一次.写一次.读一次.写一次. RandomAccessFile raf = new RandomAccessFile("src/count.txt","rw"); int count = Integer.parseInt(raf.readLine()); //转换成int类型 count++; if(count>10) { System.out.println("软件已经到期"); return ; //结束整个循环 } System.out.println("已经使用了"+count+"次,请马上续费~~"); String str = String.valueOf(count); //再写入进去.就是一读一些的概念啦 /* * 注意这个偏移量的问题.如果我们不设置偏移量的时候. * 他执行的顺序是: 012 那么程序判断成12就结束啦.. * 设置偏移量为零: * 位置是不会懂的0 * 1 * 2 * 3...这样 */ raf.seek(0); raf.write(str.getBytes()); //把字节写进去把字节写进去. raf.close(); } }

写道

这个学习的说好不好,说坏不坏.但是在休息中浪费的时间比较多..

希望以后好好努力..加油..

分享到：

javase_17(IO的总结) | javase_15(File类的应用)

2012-08-20 11:52
浏览 814
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论