10.26的总结, 管道流用法, RandomAccessFile, DataStream 有待深入.

  1 package test;
  2 import java.io.*;
  3 import java.nio.channels.FileChannel;
  4 import java.util.*;
  5 public class Test10_26
  6 {
  7     public static void main(String[] args) throws Exception
  8     {
  9
 10     }
 11     public static void method_delete()
 12     {
 13         File dir = new File("D:\\testdir\\111");
 14         removeDir(dir);
 15     }
 16     private static void removeDir(File dir)
 17     {
 18         File[] files = dir.listFiles();
 19         for (File f : files)
 20         {
 21             if (f.isDirectory())
 22             {
 23                 removeDir(f);
 24             }
 25             else
 26             {
 27                 System.out.println(f.toString() + "-file-" + f.delete());
 28                 ;
 29             }
 30         }
 31         System.out.println(dir + "-dir-" + dir.delete());
 32         ;
 33     }
 34     public static void method_PrintWriter() throws IOException
 35     {
 36         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
 37         PrintWriter out = new PrintWriter(new FileWriter("d:/a.txt"), true); // 实时刷新好啊,
 38         for (String line = null; (line = bufr.readLine()) != null;)
 39         {
 40             if ("over".equals(line))
 41                 break;
 42             System.out.println(line.toUpperCase());
 43             out.println(line.toUpperCase());// 不用操心 写不写 flush()了
 44         }
 45         bufr.close();
 46         out.close();
 47     }
 48     public static void method_SequenceInputStream_ArrayList() throws IOException
 49     {
 50         ArrayList<InputStream> list = new ArrayList<InputStream>();
 51         File dir = new File("D:/splitfiles");
 52         for (int i = 0; i < 4; i++)
 53         {
 54             list.add(new FileInputStream(new File(dir, i + ".part")));
 55         }
 56         final Iterator<InputStream> it = list.iterator();
 57         Enumeration<InputStream> en = new Enumeration<InputStream>()
 58         {
 59             public InputStream nextElement()
 60             {
 61                 return it.next();
 62             }
 63             public boolean hasMoreElements()
 64             {
 65                 return it.hasNext();
 66             }
 67         };
 68         SequenceInputStream sis = new SequenceInputStream(en);
 69         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/splitfiles/1.mp4"));
 70         int len = 0;
 71         for (byte[] buf = new byte[1024 * 1024]; (len = sis.read(buf)) != -1;)
 72         {
 73             bos.write(buf, 0, len);
 74             bos.flush();
 75         }
 76         sis.close();
 77         bos.close();
 78     }
 79     public static void method_splitfile() throws IOException
 80     {
 81         File file = new File("D:/222.mp4");
 82         FileInputStream fis = new FileInputStream(file);
 83         FileOutputStream fos = null;
 84         int len = 0;
 85         int count = 0;
 86         q: while (true)
 87         {
 88             File f = new File("D:/splitfiles/" + (count++) + ".part");
 89             fos = new FileOutputStream(f);
 90             for (byte[] buf = new byte[1024 * 1024]; (len = fis.read(buf)) != -1;)
 91             {
 92                 fos.write(buf, 0, len);
 93                 if (f.length() >= 1024 * 1024 * 200)
 94                 {
 95                     continue q;
 96                 }
 97             }
 98             break;
 99         }
100     }
101     public static void method_ByteArrayOutputStream() throws Exception //
102     {
103         FileInputStream fis = new FileInputStream("D:/111.bmp");
104         BufferedInputStream bis = new BufferedInputStream(fis);
105         ByteArrayOutputStream baos = new ByteArrayOutputStream();
106         for (int ch = 0; (ch = bis.read()) != -1;)
107         {
108             baos.write(ch);
109         }
110         bis.close();
111         System.out.println(baos.size());
112         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/111_copy.bmp"));
113         baos.writeTo(bos); // baos里一直存着图片, 优点!!
114         byte[] retArr = baos.toByteArray(); // 可以用ByteArrayInputStream 读取呀.笨
115         System.out.println(retArr.length);
116     }
117     public static void method_SequenceInputStream() throws Exception
118     {
119         Vector<InputStream> vector = new Vector<InputStream>();
120         vector.add(new FileInputStream("D:/33.mp3"));
121         vector.add(new FileInputStream("D:/44.mp3"));
122         vector.add(new FileInputStream("D:/55.mp3"));
123         Enumeration<InputStream> et = vector.elements();
124         SequenceInputStream sis = new SequenceInputStream(et);
125         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/66.mp3"));
126         int len = 0;
127         for (byte[] buf = new byte[1024 * 1024]; (len = sis.read(buf)) != -1;)
128         {
129             bos.write(buf, 0, len);
130             bos.flush();
131         }
132         sis.close();
133         bos.close();
134     }
135     public static void method_FileChannel() throws Exception
136     {
137         FileChannel in = new FileInputStream("D:/171.bmp").getChannel();
138         FileChannel out = new FileOutputStream("D:/171_copy.bmp").getChannel();
139         out.transferFrom(in, 0, in.size());
140         in.close();
141         out.close();
142     }
143 }
时间: 2024-11-17 12:36:16

10.26的总结, 管道流用法, RandomAccessFile, DataStream 有待深入.的相关文章

黑马程序猿——25,打印流,合并流,对象序列化,管道流,RandomAccessFile

------<ahref="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- 黑马程序猿--25.打印流.合并流.对象序列化,管道流,RandomAccessFile /* IO流的打印流:专门用于打印的流 字节打印流PrintStream PrintStream的构造函数能够接收file对象,String型字符串路

IO包中的其他类 打印流,序列流,操作对象,管道流,RandomAccessFile,操作基本数据类型,操作字节数组

打印流,序列流,操作对象,管道流,RandomAccessFile,操作基本数据类型,操作字节数组 一.打印流: 该流提供了打印方法,可以将各种数据类型的数据都原样打印. 字节打印流PrintStream构造函数可以接收的参数类型1.File对象 File2.字符串路径 String3.字节输出流 OutputStream 字符打印流PrintWriter(更常用)1.File对象 File2.字符串路径 String3.字节输出流 OutputStream4.字符输出流 Writer publ

JAVA之旅(三十)——打印流PrintWriter,合并流,切割文件并且合并,对象的序列化Serializable,管道流,RandomAccessFile,IO其他类,字符编码

JAVA之旅(三十)--打印流PrintWriter,合并流,切割文件并且合并,对象的序列化Serializable,管道流,RandomAccessFile,IO其他类,字符编码 三十篇了,又是一个阳光明媚的周末,一个又一个的周末,周而复始,不断学习,前方的路你可曾看见?随我一起走进技术的世界,流连忘返吧! 一.打印流PrintWriter 打印流有PrintWriter和PrintStream,他的特点可以直接操作输入流还有文件 该流提供了打印方法,可以将各种数据类型原样打印 file对象

黑马程序员——25,打印流,合并流,对象序列化,管道流,RandomAccessFile

------<ahref="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- /* IO流的打印流:专门用于打印的流 字节打印流PrintStream PrintStream的构造函数可以接收file对象,String型字符串路径,字节输出流 字符打印流PrintWriter PrintWriter的构造函数可以接收

JAVA基础学习day22--IO流四-对象序列化、管道流、RandomAccessFile、DataStream、ByteArrayStream、转换流的字符编码

一.对象序列化 1.1.对象序列化 被操作的对象需要实现Serializable接口 1.2.对象序列化流ObjectOutputStream与ObjectInputStream ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化. ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时,可以为应用程序提供对对象图形的

黑马程序员——Java基础——IO流(三)—序列流、管道流、RandomAccessFile类、操作基本数据类型的流对象、操作数组和字符串、字符编码

第一讲 对象序列化(持久化) 一.概述:就是把对象封存在硬盘,可以保持数据:关键类:ObjectInputStream和ObjectOutpurStream 二. 关键字:ObjectOutputStream:方法有writerObject()读取 ObjectInputStream 方法有readObject() 被序列化的对象需要 implements Serializable关于被序列化的类需要实现Serializable它等于一个撮,标识用的,改变类里面的语句就变了.如果想固定一个撮,可

Java基础学习笔记【10】打印流、管道流

ByteArrayInputStream和ByteArrayOutputStream内存流,操作基本和文件流其他流差不多,主要使用在程序需要用临时文件,关闭内存流是无效的所以不用关闭 操作流,不管是什么流,最保险的方式,就是最后都close一下 内存流: ByteArrayInputStream.ByteArrayOutputStream.CharArrayReader. CharArrayWriter: 打印流: 1 2 3 4 5 6 PrintStream: print(Object o)

Java基础系列10:内存操作流,管道流,合并流,压缩流以及回退流

前言:这篇文章将对几个"非主流"的IO流进行简单的介绍 一 内存操作流 内存操作流的主要作用是完成内存的输入和输出.比如说在某些情况下需要生成一些临时信息,而将这些临时信息保存在文件中不仅要进行文件的读写而且在功能完成之后还需要删除这个临时文件,因此比较麻烦,这时或许就需要用到内存操作流了. 需要用到的API是:ByteArrayInputStream和ByteArrayOutputStream,分别表示输入流和输出流,示例代码如下: package javase.io; import

面试题:JavaIO流分类详解与常用流用法实例

Java流概念: Java把所有的有序数据都抽象成流模型,简化了输入输出,理解了流模型就理解了Java IO.可以把流想象成水流,里面的水滴有序的朝某一方向流动.水滴就是数据,且代表着最小的数据流动单位,在字节流中,水滴就是一字节(byte),在字符流中,水滴就是一字符(char). Java流的分类方法大致分为以下几种: 1.按流向划分,分为输入流.输出流 请注意,这里的流向是以程序的运行时内存为参照的. 输入流类名中包含关键字InputStream或Reader,输出流类名中包含关键字Out