javase_16(其它流)

最新推荐文章于 2022-05-16 20:34:35 发布

my_kudy

最新推荐文章于 2022-05-16 20:34:35 发布

阅读量1k

点赞数

分类专栏： 1.【—javase基础—】文章标签： import string byte class null file

本文链接：https://blog.csdn.net/my_kudy/article/details/7939099

版权

1.【—javase基础—】专栏收录该内容

24 篇文章 0 订阅

订阅专栏

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

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

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