黑马程序员java培训就业班笔记:IO流体系总结

合集下载

黑马程序员——IO(InputOutput)流总结(二)五篇范文

黑马程序员——IO(InputOutput)流总结(二)五篇范文

黑马程序员——IO(InputOutput)流总结(二)五篇范文第一篇:黑马程序员——IO(Input Output)流总结(二)IO(Input Output)流总结(二)刚开始观看毕老师的视屏的时候,感觉一会儿输出流,一会儿输入流的,一会儿System.out,一会儿又转换流的。

很晕。

最后毕老师给了一个总结,归纳出了IO操作的规律。

感觉总结的非常好,虽然刚看第一遍的时候还是很晕,不过现在终于融汇贯通。

下面我就用自己的理解,总结一下IO流操作的一般规律:在使用IO操作流之前,我们要问自己一下四个问题:A.源和目的都有吗?(初步确定体系)B.源和目的操作的是字符吗?(确定体系)C.源和目的的设备都是些什么?(辅助确定具体对象)D.需要提高输入和输出的效率吗?补充:源的设备:内存,硬盘,键盘目的的设备:内存,硬盘,控制台当明确了以上几点之后我们就可以确定到底应该使用那一个流对象。

Demo1:拷贝一个文本文件的副本。

分析:A.源和目的都有。

所以,源可以选择:Reader或者InputStream目的可以选择:Writer 或者 OutputStreamB.操作的都是字符数据。

所以,源应该选择:Reader目的应该选择:WriterC.源的设备是:硬盘。

目的的设备是:硬盘。

所以:源应该使用:FileReader目的应该使用:FileWriterD.需要提高输入和输出效率。

所以可以使用相应的装饰类。

源使用:BufferedReader目的使用:BufferedWriter具体代码如下:BufferedReader bufr = new BufferedReader(new FileReader(“1.txt”));BufferedWriter bufw = new BufferedWriter(new FileWriter(“copy_1.txt”));Demo2:将从键盘输入的数据存储到文件中。

分析:A.源和目的都有。

javaIO流学习总结

javaIO流学习总结

javaIO流学习总结java IO流学习总结近期学习了Java的IO流,尝试着总结⼀下。

java.io 包下的IO流很多:其中,以Stream结尾的为字节流,以Writer或者Reader结尾的为字符流。

所有的输⼊流都是抽象类IuputStream(字节输⼊流)或者抽象类Reader(字符输⼊流)的⼦类,所有的输出流都是抽象类OutputStream(字节输出流)或者抽象类Writer(字符输出流)的⼦类。

字符流能实现的功能字节流都能实现,反之不⼀定。

如:图⽚,视频等⼆进制⽂件,只能使⽤字节流读写。

1、字符流FileReader和FileWriterFileReader类构造⽅法摘要( file)在给定从中读取数据的File的情况下创建⼀个新FileReader。

( fd)在给定从中读取数据的FileDescriptor的情况下创建⼀个新FileReader。

( fileName)在给定从中读取数据的⽂件名的情况下创建⼀个新FileReader。

FileWriter类构造⽅法摘要( file)根据给定的 File 对象构造⼀个 FileWriter 对象。

( file, boolean append)根据给定的 File 对象构造⼀个 FileWriter 对象。

( fd)构造与某个⽂件描述符相关联的 FileWriter 对象。

( fileName)根据给定的⽂件名构造⼀个 FileWriter 对象。

( fileName, boolean append)根据给定的⽂件名以及指⽰是否附加写⼊数据的 boolean 值来构造 FileWriter 对象。

使⽤FileReader和FileWriter类完成⽂本⽂件复制:1import java.io.FileReader;2import java.io.FileWriter;3import java.io.IOException;45public class CopyFile {6public static void main(String[] args) throws IOException {7//创建输⼊流对象8 FileReader fr=new FileReader("C:\\Test\\copyfrom.txt");//⽂件不存在会抛出java.io.FileNotFoundException9//创建输出流对象10 FileWriter fw=new FileWriter("C:\\Test\\copyto.txt");11/*创建输出流做的⼯作:12 * 1、调⽤系统资源创建了⼀个⽂件13 * 2、创建输出流对象14 * 3、把输出流对象指向⽂件15 * */16//⽂本⽂件复制,⼀次读⼀个字符17 method1(fr, fw);18//⽂本⽂件复制,⼀次读⼀个字符数组19 method2(fr, fw);2021 fr.close();22 fw.close();23 }2425public static void method1(FileReader fr, FileWriter fw) throws IOException {26int ch;27while((ch=fr.read())!=-1) {//读数据28 fw.write(ch);//写数据29 }30 fw.flush();31 }3233public static void method2(FileReader fr, FileWriter fw) throws IOException {34char chs[]=new char[1024];35int len=0;36while((len=fr.read(chs))!=-1) {//读数据37 fw.write(chs,0,len);//写数据38 }2、字符缓冲流BufferedReader和BufferedWriter字符缓冲流具备⽂本特有的表现形式,⾏操作public class BufferedReader extends(1)从字符输⼊流中读取⽂本,缓冲各个字符,从⽽实现字符、数组和⾏的⾼效读取。

【黑马程序员】IO流总结

【黑马程序员】IO流总结

【黑马程序员】IO流总结学习经历:-File类--File类的作用:操作硬盘上的文件或者文件夹操作方式:创建、删除、判断、获取信息、剪切(renameTo())字符流和字节流--】使用区分:单纯的文字使用字符流,图片视频文档使用字符流【推荐全部使用字节流进行文乱码问题,需要进行特殊的处理,Reader的子类InputStreamReader的构造函数可以指定】基本使用:字符流-Reader、Writer、(字符流中Reader和Writer的子类FileReader、F -InputStream、OutputStream;【记忆方式:罗列的都是在io包下的直接类,其下属的子类组合进行扩展,并且常用的子类一般都是file+直接类名,如FileReader、FileWriter、Fi FileOutputStream都是常用的可实例化的子类】标准输入流和输出流--】标准的含义:也就是系统默认的键盘录入和系统打印在控制台使用的两个流】介绍:public static final InputStream in【System.in】;和public static final Print缓冲(高效)xx流--】好处:将基础的字符字节流进行缓冲优化,提升输入输出的效率】介绍:在流的前面加上Buffered就是对应的缓冲xx流,并且只有四种缓冲xx流,Buffered BufferedInputStream、BufferedOutputStream】特点方法:readLine()可以一行一行地读取字符串,但是只有缓冲字符输入流才有这个方转换流--】特点:只能从字节流转换成字符流,如Writer的直接子类InputStreamWriter和Reader InputStreamReader,而FileWriter和FileReader又是转换流的直接子类】特殊用法:转换流的构造方法可以指定字符编码,用来处理中文乱码问题】拓展:虽然没有专门的转换流来将字符流转换成字节流,但是我们可以直接在输出字符流的时候,将读取到流getBytes();就可以使用字节流进行输出了打印流--】特点:分为字符打印流和字节打印流,主要有两个特点,自动刷新和自动换行,自动刷新是将流写入硬盘,行只能使用println()对象操作流--】特点:顾名思义,用来操作对象的流,只有两个,ObjectInputStream和ObjectOutputStream】注意:在网络上传输的对象流必须被序列化才能传输,也就是必须实现序列化接口Serializable编码表--】思路:解决乱码问题的思路就是保持读写前后的编码一致性】应用:现在使用的编码一般就是UTF-8和GBK,但是有些外国的框架使用的是ISO-8859-1,所以有些时候需要统一编码表,解决乱码问题】说明:ANSI指的是系统编码,如果系统是简体中文,那么就是GBK的编码表,所以ANSI是根据系统语言进行JAVA中的String类型的字符串也是跟随系统语言进行变换的】注:只有需要保存在硬盘上的输出,才需要flush(),来刷新该流的缓冲,如果只需要打印在控制台就不需要打印流打印时可以直接创建新文件名词介绍--泛型:泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

java中的io流知识总结

java中的io流知识总结

java中的io流知识总结Java中的IO流是Java编程语言用于读写数据的核心部分。

它提供了一种统一的方法来处理不同类型的输入输出,包括文件、网络、键盘和内存等。

Java IO流分为字节流和字符流两种类型。

字节流用于处理二进制数据,而字符流用于处理文本数据。

字节流有两个基本的抽象类:InputStream和OutputStream,字符流有两个基本的抽象类:Reader和Writer。

Java IO流的基本操作是通过输入和输出流来完成的。

输入流用于从外部读取数据,输出流用于向外部写入数据。

在使用IO流之前,需要创建相应的输入和输出流对象,并使用它们来读写数据。

Java IO流提供了多种不同的实现类来处理不同的读写需求。

例如,FileInputStream和FileOutputStream用于读写文件,SocketInputStream和SocketOutputStream用于读写网络数据,ByteArrayInputStream和ByteArrayOutputStream用于读写内存数据。

Java IO流的操作过程是阻塞的。

当读取或写入操作发生时,程序会一直阻塞直到操作完成。

这种机制可以确保输入和输出的一致性和完整性,但也可能导致程序的性能下降。

Java IO流还提供了一些高级特性来方便开发人员进行更复杂的 IO 操作。

其中包括缓冲区流、过滤器流、对象流、序列化和反序列化等。

缓冲区流是用来提高 IO 性能的一种方式。

它们通过内部缓冲区来减少实际的读写操作次数,从而减少了对内存和硬盘的访问次数,提高了程序的执行效率。

过滤器流是对其他流的增强和扩展。

它们增加了对数据进行操作和处理的功能,使得程序可以更方便地对数据进行过滤、转换和加工。

对象流是用于读写 Java 对象的流。

它们使用了序列化和反序列化机制来将 Java 对象转换成二进制数据并写入流中,或者从流中读取二进制数据并将其转换成 Java 对象。

java中的io流知识总结

java中的io流知识总结

java中的io流知识总结Java中的IO流是我们编程过程中经常使用的一种重要工具。

它不仅可以实现数据的输入和输出,还可以用于文件的读写、网络通信以及各种其他操作。

在这篇文章中,我将对Java中的IO流进行知识总结,包括流的分类、基本的输入输出操作、字符流与字节流的区别以及常见的IO异常处理方法。

一、流的分类在Java中,流按照数据的流向可以分为输入流和输出流。

输入流用于从外部读取数据到程序中,输出流用于将程序中的数据写入到外部。

根据数据的类型,流又可以分为字符流和字节流。

字符流以字符为基本单位进行读写操作,而字节流以字节为基本单位进行读写操作。

二、基本的输入输出操作在Java中,我们可以通过使用InputStream和OutputStream类来实现输入输出操作。

InputStream用于从外部读取数据,OutputStream用于向外部写入数据。

它们都是抽象类,不能直接实例化,需要通过具体的子类来进行操作。

对于输入流,我们可以通过InputStream的子类FileInputStream来读取文件中的数据,通过InputStreamReader来读取字符流。

读取文件数据的基本操作是打开文件、读取数据、关闭文件。

打开文件可以使用FileInputStream的构造方法,读取数据可以使用read()方法读取单个字节,也可以使用read(byte[] b)方法读取多个字节。

读取字符流可以使用InputStreamReader的read()方法。

对于输出流,我们可以通过OutputStream的子类FileOutputStream来写入文件数据,通过OutputStreamWriter来写入字符流。

写入文件数据的基本操作是打开文件、写入数据、关闭文件。

打开文件可以使用FileOutputStream的构造方法,写入数据可以使用write()方法写入单个字节,也可以使用write(byte[] b)方法写入多个字节。

黑马程序员java培训就业班笔记集合体系地的总结

黑马程序员java培训就业班笔记集合体系地的总结

精彩文档
lhs.add( "A" );
lhs.add( "D" );
lhs.add( "E" );
lhs.add( "C" );
lhs.add( "F" ); System. out .println( "LinkedHashSet:" +lhs); TreeSet<String> ts= newTreeSet<String>();
实用标准文案
1、Collection :
集合框架的由来: 因为每个容器对象的自身的数据结构不同, 所以对它们进行单独的描
述和对象封装,并不断的向上抽取共性内容,这样变形成了集合框架。
定义: 集合就是一个容器、用来存储对象、长度可变。
理解: 其实班级就是一个容器, 班上的每一个学生都是单独封装了功能的对象, 因为班
重点掌握上述保证唯一性的方法以及哈希表内存原理实现。
|--linkedHashSet
以元素的插入顺序来维护集合的连接表,允许以插入的顺序的集合中迭代的
怎么去理解?
HashSet<String> hs= newHashSet<String>();
hs.add( "B" );hs.a来自d( "A" );
for (int i = 0; i < array.length; i++)
list.add(new Double(array[i])); } Collections.sort(list); for (int i = 0; i < array.length; i++)

黑马程序员java培训就业班笔记:day23(IO其他类)总结

黑马程序员java培训就业班笔记:day23(IO其他类)总结

Day23总结:1、打印流:就是输出流,可以直接操作输入流和文件printStream:字节流特点:1、构造函数接收File对象、字符路径、字符输出流、以为着打印的目的可以是很多。

2、该对象具有特有的方法,print println可以打印任何数据类型的数据。

3、特有的printf方法可以保持任意类型的数据表现形式的原样性,将数据输出到目的地,对于OutputStream父类中的write是将数据的最低字节写出去、API:为其他的输出流添加了功能,使他们能够方法便的打印各种数据值表示形式,它还提供了其他两项功能。

与其他输出流不同,printStream永远不会抛出IOException异常,而是异常情况仅设置可通过checkError方法测试的内部标识,另外,为了自动刷新,可以创建一个printStream,这以为着可在写入byte数组之后自动调用flush方法,可吊桶其中一个println方法,或者写入一个换行符或者字节(\r\n),printStream打印的所有字符都使用平台默认字符编码转换为字节,在需要写入字符而不是写入字节的情况下,应该使用printWriter 类。

注意:能写一个整数、还能打印一个整数为什么?Write(97);a0000-0000 0000-0000 0000-0000 0110-0001 97将最后一个八位写入到硬盘,也就是最后一个字节0110-0001记事本把这个二进制解析了,然后查表返回a;Print(97);你看到是什么?目的里面就是什么?97原理:先把97--->"97"--->"97".getBytes()(2个字节)printWriter字符流:使用频繁,因为需要将数据从服务端打印到客户端特点:1、当操作的数据是字符时,可以选择printWriter比printStream更方便。

2、它的构造函数可以接收File对象,字符串路径、字节输出流、字符流。

2019年JavaIO流学习总结报告

2019年JavaIO流学习总结报告

2019年JavaIO流学习总结报告一、什么是流?流就是字节序列的抽象概念,能被连续读取数据的数据源和能被连续写入数据的接收端就是流,流机制是Java及C++中的一个重要机制,通过流我们可以自由地控制文件、内存、IO设备等数据的流向。

而IO流就是用于处理设备上的数据,如:硬盘、内存、键盘录入等。

IO流根据处理类型的不同可分为字节流和字符流,根据流向的不同可分为输入流和输出流。

二、字节流和字符流的区别:字符流,因为文件编码的不同,就有了对字符进行高效操作的字符流对象,它的原理就是基于字节流读取字节时去查了指定的码表。

它和字节流的区别有两点:1.在读取数据的时候,字节流读到一个字节就返回一个字节,字符流使用了字节流读到一个或多个字节(一个中文对应的字节数是两个,在UTF-8码表中是3个字节)时,先去查指定的编码表,再将查到的字符返回;2.字节流可以处理所有类型的数据,如jpg、avi、mp3、wav等等,而字符流只能处理字符数据。

所以可以根据处理的文件不同考虑使用字节流还是字符流,如果是纯文本数据可以优先考虑字符流,否则使用字节流。

三、IO体系,所具备的基本功能就是读和写:1.字符流|--Reader(读)|--Writer(写)Reader|--InputStreamReader|--FileReader:用于处理文件的字符读取流对象Writer|--OutputStreamWriter|--FileWriter:用于处理文件的字符写入流对象其实很容易就可以看出来,IO体系中的子类名后缀绝大部分是父类名称,而前缀则是体现子类特有功能的名称。

Reader中常见的方法:|--intread()读取一个字符,并返回读到的这个字符,读到流的末尾则返回-1。

|--intread(char[])将读到的字符存入指定的数组中,返回的是读到的字符个数,读到流的末尾则返回-1。

|--close()读取字符其实用的是window系统的功能,就希望使用完毕后,进行资源的释放。

黑马程序员——IO(InputOutput)流总结(一)

黑马程序员——IO(InputOutput)流总结(一)

黑马程序员——IO(InputOutput)流总结(一)第一篇:黑马程序员——IO(Input Output)流总结(一)IO(Input Output)流总结(一)IO流是处理数据之间数据传输的。

Java对数据的操作是通过流的方式。

Java中用于操作IO流的对象都放在java.io包中。

流的分类:按照操作数据分为:字符流和字节流。

按照流向分为:输入流和输出流。

输入流:输出流:字符流:ReaderWriter|--BufferedReader|--BufferedWriter|--inputStreamReader|--OutputStreamWriter|--FileReader|--FileWriter字节流:InputStreamOutputStream|--FileInputStream|--FileOutputStreamInputStreamOutputStream|--FilterInputStream|--FilterOutputStream|--BufferedInputStream|--BufferedOutputStream在计算机中存储的都是1和0的序列。

也就是二进制的有序序列,不论是文本、音乐或者是视频。

那么为什么要在流中定义字节流和字符流呢?这个与我们的字符编码方式有关。

我们都知道世界上有很多种的语言,比如:ASCII、GB2312、GBK、UTF-8和Unicode等。

如果一个文本文件使用GB2312编码的方式存储的,如果我们用Unicode的编码方式来读取,那么就会出现乱码。

所以字符流是一种特殊的流,在java中就定义了专门处理字符的流对象。

当我们拿到一个API文档我们应该如何使用呢?1,确定要使用的功能。

2,查阅API看有没有相关的功能类。

3,如果没有,就分析需要如何自定义一个出来,并且要使用到那些相关功能的类,这些类在API中有没有定义。

4,不论有或者没有需要自定义一个,我们都要先查阅相关功能类的根类,那么查阅一个API的时候我们要注意一些什么呢?5,找到相关功能根类,先看一下它是一个类,还是接口,还是抽象类,如果是接口或者是抽象类我们就不能直接使用这个类,而要使用这个类的子类。

【黑马程序员】Java IO流学习总结

【黑马程序员】Java IO流学习总结

【黑马程序员】Java IO流学习总结Java流操作有关的类或接口:Java流类图结构:流的概念和作用流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。

即数根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。

IO流的分类•根据处理数据类型的不同分为:字符流和字节流•根据数据流向不同分为:输入流和输出流字符流和字节流字符流的由来:因为数据编码的不同,而有了对字符进行高效操作的流对象。

本质节流和字符流的区别:•读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映•处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能结论:只要是处理纯文本数据,就优先考虑使用字符流。

除此之外都使用字节流。

输入流和输出流对输入流只能进行读操作,对输出流只能进行写操作,程序中需要根据待传输数据Java IO流对象1.输入字节流InputStream IO 中输入字节流的继承图可见上图,可以看出:1 InputStream 是所有的输入字节流的父类,它是一个抽象类。

2 ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流,它本地文件中读取数据。

PipedInputStream 是从与其它线程共用的管道中读取数据,与P 3 ObjectInputStream 和所有FilterInputStream 的子类都是装饰流(装饰器模式的主角)。

2.输出字节流OutputStreamIO 中输出字节流的继承图可见上图,可以看出:1 OutputStream 是所有的输出字节流的父类,它是一个抽象类。

2 ByteArrayOutputStream、FileOutputStream 是两种基本的介质流,它们分别向Byte 数组、PipedOutputStream 是向与其它线程共用的管道中写入数据,3 ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

黑马程序员小鲁哥哥白话笔记-IO流

黑马程序员小鲁哥哥白话笔记-IO流

小鲁哥哥白话笔记-IO流大家在学到IO流的时候,向是突然见到了新世界一样,一下子多了好多不认识的类,各种名字和各种用法一下就把大家给绕晕了,不知道思路从何整理。

下边以小鲁哥哥的视角带大家去看看小鲁哥哥是怎么去理解这些复杂和繁多的知识的。

首先我们先给IO流定一个大的框架,在一点点去给他拆分,这样我们就容易理解了。

IO流的分类(我们只按数据类型分类,这是学生问的最多的问题,如何去区分数据类型):字节流:InputStream,OutputStream字符流:Reader,Writer有的同学就问了,是不是后缀带Stream的都是字节流,以(Reader或Writer)结尾的都是字符流?有的同学就问了OutputStreamWriter即带Stream又带Writer那这个是什么流?如果按我们同学说的只看后缀的话,那它是字符流,对,它就是一个字符流。

他是负责把字节流转换成字符流的一个桥梁,行家都叫它“转换流”。

给大家看一看IO流的一些例子:publicclass OutputStreamWriterDemo {publicstaticvoid main(String[] args) throws IOException {//method2();//创建输入流对象BufferedReaderbr = new BufferedReader(new FileReader("SystemInOutDemo.java"));//创建输出流对象//OutputStreamos = System.out;//Writer w = new OutputStreamWriter(System.out);//多态,父类型引用指向子类对象//BufferedWriterbw = new BufferedWriter(w);BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(System.out));//进行数据的读写String line;//用于存储读取到的数据while((line = br.readLine()) != null) {bw.write(line);bw.newLine();}//释放资源bw.close();br.close();}privatestaticvoid method2() throws FileNotFoundException, IOException { //创建输入流对象BufferedReaderbr = new BufferedReader(new FileReader("SystemInOutDemo.java"));//创建输出流对象//OutputStreamos = System.out;Writer w = new OutputStreamWriter(System.out);//多态,父类型引用指向子类对象//进行数据的读写String line;//用于存储读取到的数据while((line = br.readLine()) != null) {w.write(line);w.write("\r\n");}//释放资源w.close();br.close();}privatestaticvoid method() throws FileNotFoundException, IOException { //创建输入流对象BufferedReaderbr = new BufferedReader(new FileReader("SystemInOutDemo.java"));//创建输出流对象OutputStreamos = System.out;String line;//用于存储读取到的数据while((line =br.readLine()) != null) {os.write(line.getBytes());os.write("\r\n".getBytes());}//释放资源os.close();br.close();}}上述例子就是转换流的例子,其实大多数的流操作都是一样的,大家在写代码的时候,脑子里要有一个声音,IO流最后要关掉,释放资源。

javaio流学习总结

javaio流学习总结

javaio流学习总结人篇一:java_IO流总结********************************第19天 IO流*************************************************************基本内容*****************************字符流: Reader常用子类:InputStreamReader->(继承)FileReader,BufferedReader Writer常用子类:OutputStreamWriter->(继承)FileWriter,BufferedWriter 字节流: OutputStream常用子类:FileOutputStream,DataOutputStream,ObjectOutputStream, BufferedOutputStream,ByteArrayOutputStreamInputStream常用子类:FileInputStream,DataInputStream,ObjectOutputStream,BufferedInputStream,ByteArrayInputStream打印流: PrintStream常用子对象:System.out,System.in,System.err===================================================================== =========================********************************字节流:OutputStream,InputStream********************************一、字节流: FileInputStream,FileInputStream //文件读写import java.io.*;publicclass Text1 {publicstaticvoid main(String[] args) { FileInputStreamfis=null;FileInputStreamfos=null;try {fis=newFileInputStream("e:\\temp\\from.zip"); fos=newFileOutputStream("e:\\temp\\to.zip"); byte [] buffer=newbyte[1024];while (true) {inttemp = fis.read(buffer,0,buffer.length); if(temp==-1){break;}fos.write(buffer,0,temp);}} catch (Exception e) {e.printStackTrace();}try {//捕获io流关闭异常fis.close();fos.close();} catch (Exception e2) {}}}}二、字节缓冲流:BufferedInputStream,BufferedOutputStream--------------------------------------//文件读写publicclass Text2 {publicstaticvoid main(String[] args) {String fileName="e:\\老罗视频Android01-09.zip";String toName="e:\\temp\\老罗视频Android01-09.zip";FileInputStreamfis=null;FileOutputStreamfos=null;BufferedInputStreambis=null;BufferedOutputStreambos=null;try {fis=newFileInputStream(fileName);fos=newFileOutputStream(toName);bis=newBufferedInputStream(fis);bos=newBufferedOutputStream(fos);long time1=System.currentTimeMillis();//打印时间while (true) {byte[] buffer=newbyte[1024];int temp=bis.read(buffer,0,buffer.length);if (temp==-1) {break;}bos.write(buffer,0,temp);}long time2=System.currentTimeMillis();System.out.println((time2-time1)/60000);//求时间差} catch (IOException e) {e.printStackTrace();}finally {try {bis.close();bos.close();} catch (IOException e) {e.printStackTrace();}三、数据流: DataInputStream,DataOutputStreampublicclass Text3 {publicstaticvoid main(String[] args) throwsIOException {intx=8;charch='a';doublef=5.6;DataOutputStreamdos=newDataOutputStream(newFileOutputStream("e:\\ temp\\dis.txt"));DataInputStreamdis=newDataInputStream(newFileInputStream("e:\\tem p\\dis.txt"));dos.writeInt(x);dos.writeChar(ch);dos.writeDouble(f);dos.close();intgetx=dis.readInt();//8chargetch=dis.readChar();//'a'doublegetf=dis.readDouble();//5.6}}四、对象数据流:ObjectInputStream,ObjectDataOutputStream-------------------------------------- //写入对象数据publicclass Task4 {publicstaticvoid main(String[] args) throws Exception {ObjectOutputStreamobs=newObjectOutputStream(newFileOutputStream(" e:\\temp\\obs.txt"));ObjectInputStreamois=newObjectInputStream(newFileInputStream("e:\ \temp\\obs.txt"));obs.writeObject(new Student("杨过",20,99));obs.writeObject(new Student("小龙女",16,77));obs.writeObject(new Student("小小龙女",11,77));obs.writeObject(new Student("小小小龙女",7,77));while(true){try {Student stu=(Student)ois.readObject();System.out.println(stu);} catch (Exception e) {break;}class Student implementsSerializable{//实现序列化接口/*Externalizable*/String name;intage;doublescore;transient String id;//不希望属性被序列化,不会在写入文件时保存public Student(String name, intage, doublescore) { = name;this.age = age;this.score = score;}@Overridepublic String toString() {return"Student [name=" + name + ", age=" + age + ", score=" + score + "]"; }}/*class Student1 implements Externalizable{//自定义序列化String name;int age;double score;transient String id;//不希望属性被序列化,不会在写入文件时保存public Student1() {}public Student1(String name, int age, double score) { = name;this.age = age;this.score = score;}@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + ", score=" + score + "]"; }@Overridepublic void readExternal(ObjectInput in) throws IOException,ClassNotFoundException {System.out.println("反序列化");=(String)in.readObject();this.age=in.readInt();this.score=in.readDouble();}@Overridepublic void writeExternal(ObjectOutput out) throws IOException { System.out.println("序列化");out.writeInt(age);out.writeDouble(score);}}*/五、内存流ByteArrayOutputStream,ByteArrayInputStream-----------------------------------------publicclass Text5 {publicstaticvoid main(String[] args) throwsIOException {ByteArrayInputStreambis=newByteArrayInputStream("6217001820008037 164".getBytes());ByteArrayOutputStreambos=newByteArrayOutputStream();int m=0;while(true){intch=bis.read();//bis.read(byte[],0,len)if(ch==-1){break;}/*int retch;if (ch<='z'&&ch>='a') {retch=Character.toUpperCase((char)ch);}else{retch=ch;}*/bos.write(ch);//bis.write(byte[],0,len)m++;if (m==4) {bos.write(" ".getBytes());m=0;}}System.out.println(new String(bos.toByteArray()));}}================================================================= =============================********************************字符流:Reader,Writer********************************一、字符流:FileReaderFileWriter:--------------------------------------------------------//文本文件复制篇二:Java io 流小结篇三:java IO文件输入输出流总结文件输入与输出以流的形式进行,同时根据内容不同分为字节和字符两种字节流的读取与写入读取步骤:File→FileInputStream→f.read(bytes)写入步骤:File→FileOutputStream→f.write(bytes)演示:读取字节文件即把字节从文件读到内存中 File f=null;//定义文件类的变量,并为空f=new File(“”);//给变量赋值,表明指向某个文件因为File没有读写的能力,所以需要用个InputStreamTry{FileInputStream fis=null;//定义文件字节输入流变量fis=new FileInputStream(f);//给其赋值,指向目标文件Byte [] bytes=new byte[1024]; //定义数组,把字节流的字节读到数组中,相当于缓存 Int n=0;//记录读取的字节数While(n=fis.read(bytes)==-1){//以1024字节大小为单位每次读取字节,从fis字节流中,并放到bytes字节组中,读取字节个数为零即读到末尾,则返回数值-1.String s=new String(bytes,0,n);// 把字节转换成字符串,0代表:转换开始的下标;n代表:转换字节的长度。

黑马程序员java培训就业班笔记:IO流体系总结

黑马程序员java培训就业班笔记:IO流体系总结

IO流总结IO(Input Output)流●IO流用来处理设备之间的数据传输●Java对数据的操作是通过流的方式●Java用于操作流的对象都在IO包中●流按操作数据分为两种:字节流与字符流。

●流按流向分为:输入流,输出流。

输入流和输出流的流向的理解?流就是处理数据的一种方式或者一种手段,或者理解为一种数据流。

从硬盘已有的数据读取出来放内存里面的这个过程就是输入流。

把内存中的数据存储到硬盘中的这个过程就是输出流。

简单理解就是:以内存为中心。

什么时候使用流对象?操作设备上的数据或操作文件的时候可以使用。

字符流字符流的抽象基类:Read er ,Writer。

字符流的理解,由来和作用?由于很多国家的文字融入进来,比如说中文在编码表中默认占2个字节。

而为了按照文字的单位来处理,所以出现了字符流。

由来:早期的字节流+编码表,为了更便于操作文字数据。

作用:为了处理文字数据。

复制文件的原理和代码。

原理:首先用一个读取流对象和一个文件进行关联,然后用一个写入流对象作为目地的,为了把读取流中的文件传输到目的地流对象中,我们就提供了一个字符数组,为了关联这个数组,所以读取流对象有一个read()方法与这个字符数组进行关联,同理,写入流对象也有一个write()方法与这个字符数组进行关联,这样2个流对象就相连接了,而这个字符数组就相当于一个中转站。

import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;/** 对文本文件进行复制。

将c盘的文件复制到d盘中。

* 原理:其实就是一个最简单的读写过程。

* 从c盘源,读取数据,并将读到的数据,写入到目的d盘中。

*/public class CopyTextFileTest {public static void main(String[] args) {FileReader fr = null;FileWriter fw = null;try {//1,创建一个字符读取流读取与源数据相关联。

java io流学习总结

java io流学习总结

java io流学习总结java io流学习总结一、什么是流?流就是字节序列的抽象概念,能被连续读取数据的数据源和能被连续写入数据的接收端就是流,流机制是Java及C++中的一个重要机制,通过流我们可以自由地控制文件、内存、IO设备等数据的流向。

而IO流就是用于处理设备上的数据,如:硬盘、内存、键盘录入等。

IO流根据处理类型的不同可分为字节流和字符流,根据流向的不同可分为输入流和输出流。

二、字节流和字符流的区别:字符流,因为文件编码的不同,就有了对字符进行高效操作的字符流对象,它的原理就是基于字节流读取字节时去查了指定的码表。

它和字节流的区别有两点:1.在读取数据的时候,字节流读到一个字节就返回一个字节,字符流使用了字节流读到一个或多个字节时,先去查指定的编码表,再将查到的字符返回;2.字节流可以处理所有类型的数据,如jpg、avi、mp3、wav等等,而字符流只能处理字符数据。

所以可以根据处理的文件不同考虑使用字节流还是字符流,如果是纯文本数据可以优先考虑字符流,否则使用字节流。

三、IO体系,所具备的基本功能就是读和写:1.字符流-- Reader-- WriterReader--InputStreamReader--FileReader:用于处理文件的字符读取流对象Writer--OutputStreamWriter--FileWriter:用于处理文件的字符写入流对象其实很容易就可以看出来,IO体系中的子类名后缀绝大部分是父类名称,而前缀则是体现子类特有功能的名称。

Reader中常见的方法:--int read读取一个字符,并返回读到的这个字符,读到流的末尾则返回-1。

--int read将读到的字符存入指定的数组中,返回的是读到的字符个数,读到流的末尾则返回-1。

--close读取字符其实用的是window系统的功能,就希望使用完毕后,进行资源的释放。

FileReader除了自己的`构造函数外没有特有的方法:--用于读取文本文件的流对象。

黑马程序员Java教程:IO流

黑马程序员Java教程:IO流

IO流IO流用来处理设备之间的数据传输。

Java对数据的操作是通过流的方式。

Java用于操作流的对象都在IO包中。

输入流和输出流相对于内存设备而言。

将外设中的数据读取到内存中:输入。

将内存的数写入到外设中:输出。

流按操作数据分为两种:字节流与字符流。

字符流的由来:其实就是:字节流读取文字字节数据后,不直接操作而是先查指定的编码表,获取对应的文字。

再对这个文字进行操作。

简单说:字节流+编码表。

IO流常用基类-字符流字节流的抽象基类:InputStream,OutputStream。

字符流的抽象基类:Reader,Writer。

P.S.由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如:InputStream的子类FileInputStream。

如:Reader的子类FileReader。

需求:将一些文字存储到硬盘一个文件中。

记住:如果要操作文字数据,建议优先考虑字符流。

而且要将数据从内存写到硬盘上,要使用字符流中的输出流:Writer。

硬盘的数据基本体现是文件,希望找到一个可以操作文件的Writer:FileWriter。

示例1:1.import java.io.FileWriter;2.import java.io.IOException;3.4.public class FileWriterDemo{5. public static void main(String[] args) throws IOException{6. //创建一个可以往文件中写入字符数据的字符输出流对象7. //既然是往一个文件中写入文字数据,那么在创建对象时,就必须明确该文件(用于存储数据的目的地)8. //如果文件不存在,则会自动创建9. //如果文件存在,则会被覆盖10. FileWriter fw = new FileWriter("demo.txt" );11.12. //调用Writer对象中的write(string)方法,写入数据13. //其实数据写入到临时存储缓冲区中14. fw.write( "abcde");15.16. //进行刷新,将数据直接写入到目的地中17. fw.flush();18.19. //关闭流,关闭资源,在关闭前会先调用flush刷新缓冲中的数据到目的地。

JAVA中的IO流知识总结

JAVA中的IO流知识总结
1、Java 技术支持两种数据类型的流 InputStream 和 OutputStream:字节流。其它字节流都是 InputStream 或 OutputStream 的子类。 Reader 和 Writer:字符流。其它字符流都是 Reader 或 Writer 的子类。
2、节点流 Java 2 SDK 中有三种基本类型的节点:文件(file)、内存(memory)、管道(pipe)。
java.io.Reader 和 java.io.InputStream 区别 java.io.Reader 和 java.io.InputStream 组成了 Java 输入类。Reader 用于读入 16 位字符,也就是 Unicode 编码的字符;而 InputStream 用于读入 ASCII 字符和二进 制数据。 在 Java 中,有不同类型的 Reader 输入流对应于不同的数据源:
决定使用哪个类以及它的构造进程的一般准则如下(不考虑特殊需要):
第一,考虑最原始的数据格式是什么:是否为文本?
第二,是输入还是输出?
第三,是否需要转换流:InputStreamReader, OutputStreamWriter?
第四,数据来源(去向)是什么:文件?内存?网络?
第五,是否要缓冲:bufferedReader (特别注明:一定要注意的是 readLine()是否有定 义,有什么比 read, write 更特殊的输入或输出方法)
第六,是否要格式化输出:print?
总结二:
首先是 java 的 IO。这破东西可真费事,I/O 类库常使用”流(stream)”这种抽象。所谓” 流”是一种能生成或接受数据的,代表数据的源和目标的对象。流把 I/O 设备内部的具体操 作给隐藏起来了。 正如 JDK 文档所显示的,Java 的 I/O 类库分成输入和输出两大部分。 所有 InputStream 和 Reader 的派生类都有一个基本的,继承下来的,能读取单个或 byte 数组的 read( )方法。同理,所有 OutputStream 和 Writer 的派生类都有一个基本的,能 写入单个或 byte 数组的 write( )方法。但通常情况下,你是不会去用这些方法的;它们是 给其它类用的 —— 而后者会提供一些更实用的接口。因此,你很少会碰到只用一个类就能 创建一个流的情形,实际上你得把多个对象叠起来,并以此来获取所需的功能。Java 的流 类库之所以会那么让人犯晕,最主要的原因就是”你必须为创建一个流而动用多个对象”。

javaio流实验总结

javaio流实验总结

javaio流实验总结Java IO流是Java编程中非常重要的一部分,它提供了一种简单而灵活的方式来处理输入和输出。

在本次实验中,我学习了Java IO 流的基本概念、不同类型的IO流以及如何使用它们进行读写操作。

下面是我对实验内容的总结和感悟。

Java IO流是用于处理输入和输出的工具。

它通过提供一种抽象的方式来处理不同来源和目标的数据,如文件、网络连接和内存缓冲区。

在Java中,IO流分为两大类:字节流和字符流。

字节流以字节为单位进行读写,适用于处理二进制数据或字节流;字符流以字符为单位进行读写,适用于处理文本数据。

在实验中,我学习了四种基本的字节流:InputStream、OutputStream、FileInputStream和FileOutputStream。

InputStream用于从源读取数据,OutputStream用于向目标写入数据。

FileInputStream和FileOutputStream则是用于读写文件的特殊字节流。

通过使用这些流,我可以轻松地读取和写入文件中的数据。

除了字节流,我还学习了四种基本的字符流:Reader、Writer、FileReader和FileWriter。

Reader用于从源读取字符数据,Writer 用于向目标写入字符数据。

FileReader和FileWriter则是用于读写文件的特殊字符流。

字符流比字节流更适合处理文本数据,因为它们可以正确处理字符编码和换行符。

在实验中,我还学习了如何使用缓冲流来提高IO性能。

缓冲流是对基本的字节流和字符流的包装,它们使用内部缓冲区来减少对底层数据源的访问次数,从而提高读写的效率。

通过使用BufferedInputStream和BufferedOutputStream,我可以在读写大量数据时获得更好的性能。

类似地,通过使用BufferedReader 和BufferedWriter,我可以更快地读写文本文件。

传智播客黑马程序员javaIO流重点总结(必读)

传智播客黑马程序员javaIO流重点总结(必读)

IO流总结异常父类是Throwable,处理异常的两种方案,一种try--catch另外一种抛出熟练使用Try---catch---finally,注意:能和try一起使用的只有catch和finally关键字Try块里面存放的是有可能发生异常的代码,通常和catch块一起使用,catch块用于处理try块中抛出的异常,finally块不是必须的,通常将释放资源(例如IO流的close方法)的代码放到finally块里面注意:finally和Final还有Finalize的区别File类注意:File类封装的路径,而不一定是一个具体的文件,File类不能用于读写文件,File类只能用来处理和文件相关的操作构造方法*File(Stringpathname):根据一个路径得到File对象*File(Stringparent,Stringchild):根据一个目录和一个子文件/目录得到File对象*File(Fileparent,Stringchild):根据一个父File目录和一个子文件/目录得到File对象创建功能*publicbooleanmkdir():创建文件夹如果存在这样的文件夹,就不创建了*publicbooleanmkdirs():创建文件夹,如果父文件夹不存在,会帮你创建出来注意:mkdir只能创建单级目录,mkdirs用于创建多级目录判断功能,*publicbooleanisDirectory():判断是否是目录*publicbooleanisFile():判断是否是文件*publicbooleanexists():判断文件是否存在注意:判断功能返回的都是布尔类型的获取功能*publicStringgetName():获取名称*publiclonglength():获取长度。

字节数*publicFile[]listFiles():获取指定目录下的所有文件或者文件夹对象,返回的是File数组*publicFile[]listFiles(FilenameFilterfilter):注意:此方法需要传入筛选文件名的接口FileNameFilter,用于过滤文件概念*InputOutput流用来处理设备之间的数据传输,Java中输入输出功能是通过流来实现,把数据写入文件需要创建流对象*Java对数据的操作是通过流的方式*Java用于操作流的类都在IO包中*流按流向分为两种:输入流,输出流。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

IO流总结IO(Input Output)流●IO流用来处理设备之间的数据传输●Java对数据的操作是通过流的方式●Java用于操作流的对象都在IO包中●流按操作数据分为两种:字节流与字符流。

●流按流向分为:输入流,输出流。

输入流和输出流的流向的理解?流就是处理数据的一种方式或者一种手段,或者理解为一种数据流。

从硬盘已有的数据读取出来放存里面的这个过程就是输入流。

把存中的数据存储到硬盘中的这个过程就是输出流。

简单理解就是:以存为中心。

什么时候使用流对象?操作设备上的数据或操作文件的时候可以使用。

字符流字符流的抽象基类:Reader , Writer。

字符流的理解,由来和作用?由于很多国家的文字融入进来,比如说中文在编码表中默认占2个字节。

而为了按照文字的单位来处理,所以出现了字符流。

由来:早期的字节流+编码表,为了更便于操作文字数据。

作用:为了处理文字数据。

复制文件的原理和代码。

原理:首先用一个读取流对象和一个文件进行关联,然后用一个写入流对象作为目地的,为了把读取流中的文件传输到目的地流对象中,我们就提供了一个字符数组,为了关联这个数组,所以读取流对象有一个read()方法与这个字符数组进行关联,同理,写入流对象也有一个write()方法与这个字符数组进行关联,这样2个流对象就相连接了,而这个字符数组就相当于一个中转站。

import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;/** 对文本文件进行复制。

将c盘的文件复制到d盘中。

* 原理:其实就是一个最简单的读写过程。

* 从c盘源,读取数据,并将读到的数据,写入到目的d盘中。

*/public class CopyTextFileTest {public static void main(String[] args) {FileReader fr = null;FileWriter fw = null;try {//1,创建一个字符读取流读取与源数据相关联。

fr = new FileReader("demo.txt");//2,创建一个存储数据的目的地。

fw = new FileWriter("copyDemo.txt");//3,创建一个字符数组将读取流对象和写入流对象相连接。

char[] buf = new char[1024];//4,每次读取的长度不一样,所以定义一个变量.int len = 0;//5,用循环读取文件中的数据while((len= fr.read(buf)) != -1) //判断是否读取完没fw.write(buf,0,len); //为了只读取有效的数据} catch (Exception e) {}finally{try {fr.close();} catch (IOException e) {e.printStackTrace();}try {fw.close();} catch (IOException e) {e.printStackTrace();}}}}读取字符流对象的两种方式第一种读取方式一次读一个字符//1,创建一个文件读取流对象,和指定名称的文件相关联//2,要保证该文件时已经存在的。

如果不存在,会发生异常。

FileNotFoundExceptionFileReader fr = new FileReader("Demo.txt");//3,调用读取流的方法,read方法一次读一个字符,而且会自动往下读。

int line=0; //read返回时int型的数,即返回的是字符的ascII表对应的数字while ((line=fr.read())!=-1){sop((char)ch);}第二种读取方式//1,创建一个文件读取流对象,和指定名称的文件相关联//2,要保证该文件时已经存在的。

如果不存在,会发生异常。

FileNotFoundExceptionFileReader fr = new FileReader("Demo.txt"); //把Demo.txt中的数据读到控制台//3,定义一个字符数组,用于存储独到的字符该read(char[]) //返回的是读到字符的个数char[] buf = new char[1024];int len=0;while((len=fr.read(buf))!=-1) //把读到的字符暂时存到buf数组中{sop("num="+num+"...."+new String(buf,0,len));}缓冲区的基本思想?提高效率的原理。

缓冲区的基本思想就是对要处理的数据进行临时存储。

譬如购物车以及篮子。

原理:减少频繁的操作。

给读取流对象和写入流对象提供中转站。

相对于来回跑的麻烦,利用缓冲区的容量,可以一边先存储,满了后再写入的方式,这样就提高了效率。

BufferedReader ,BufferedWriter.高效的体现?部将数组进行封装。

变成对象后,方便于对缓冲区的操作。

提高效率。

并提供了对文本便捷操作的方法。

readLinenewLine。

自定义缓冲区,MyBufferedReaderimport java.io.IOException;import java.io.Reader;/** 模拟一个缓冲区* 基于已有的缓冲区思想,我们可以从源读取用read方法。

* 我们的缓冲区,应该是一个更高效的read读取方法。

*/public class MyBufferTest extends Reader{private Reader r;private char[] buf = new char[1024];private int count = 0,pos = 0;public MyBufferTest(Reader r){this.r = r;}/*** 一次从缓冲区中取一个* return 返回一个缓冲区中的字符* throws IOException*/public int myRead() throws IOException {//1,首先判断缓冲区中是否有数据,如果没有就从源中去拿。

if(count == 0){count = r.read(buf);pos = 0;}//2,当缓冲区中没数据了且源中也没有数据时,count自减1小于0时就返回-1结束.if(count < 0)return -1;//3,如果以上都不满足,那么从缓冲区中写入一个字符到新的文件中。

char ch = buf[pos];pos++;count--;return ch;}/*** 按照文本特点,提供一个特有的操作文本的方法。

* 一次读取一行文本,只要是到行结束符之前的文本即可。

* return 返回读取到的一行文本* throws IOException* 原理:* 就是从缓冲区中取出数据,并存储到一个临时容器中。

* 如果取到了回车符,就将临时容器中的数据转成字符串返回。

*/public String myReadLine() throws IOException{//1,定义一个临时容器,进行临时存储StringBuilder sb = new StringBuilder();//2,定义一个变量,接收读取到的字符,也就是转成ask码表后的一个int型数字int ch = 0;while((ch = myRead()) != -1){//3,当读取到\r时,直接跳出本次循环if(ch == '\r')continue;//4,当读取到\n时,直接跳出当前循环if(ch == '\n')return sb.toString();//5,当都没有读取到时,就将这些数据存储到临时容器中。

sb.append((char)ch);}//6,当临时容器中的长度不等于0时,就输出字符。

if(sb.length() != 0)return sb.toString();return null;}Overridepublic void close() throws IOException {}Overridepublic int read(char[] arg0, int arg1, int arg2) throws IOException {return 0;}}readLine方法的原理。

就是从缓冲区中获取数据,并进行临时存储,知道读取到了换行符,将临时存储的数据转成字符串返回。

它对于操作文本是毕竟方便,可以完成一行一行的读取文本。

装饰设计模式,以及和继承的区别?对原有类进行了功能的改变,增强。

区别:1,继承在对对象进行增强时,采用的是子类覆盖父类中的写方法,且这些子类使用的功能的原理都一样,这样就显得很臃肿。

而BufferWriter的出现避免了继承体系关系的臃肿,比继承更为灵活。

2,在为了增强功能的情况下,相较于继承,BufferWriter这种方式解决起来更为方便。

使用字符流可以复制图片吗?为什么?不能,因为字符流就是字节流+编码表,而用字符流去复制图片时,字符流会默认将图片的字节码格式进行编码,所以会导致复制后的图片与原图片可能不一致。

字符流继承体系简图字节流的抽象基类:InputStream ,OutputStream。

字节流的基本应用?复制MP3的例子。

基本操作与字符流类相同但它不仅可以操作字符,还可以操作其他媒体文件复制MP3的四种方式。

import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class CopyMediaFileTest {/*** param args* throws IOException*/public static void main(String[] args) throws IOException { long start = System.currentTimeMillis();copy_4();long end = System.currentTimeMillis();System.out.println((end-start)+"毫秒");}private static void copy_4() throws IOException { FileInputStream fis = new FileInputStream("c:\\0.mp3");FileOutputStream fos = new FileOutputStream("c:\\4.mp3");int ch = 0;while((ch=fis.read())!=-1){fos.write(ch);}fos.close();fis.close();}private static void copy_3() throws IOException {FileInputStream fis = new FileInputStream("c:\\0.mp3");FileOutputStream fos = new FileOutputStream("c:\\3.mp3");BufferedInputStream bufis = new BufferedInputStream(fis);BufferedOutputStream bufos = new BufferedOutputStream(fos);int ch = 0;while((ch=bufis.read())!=-1){bufos.write(ch);}bufos.close();bufis.close();}private static void copy_2() throws IOException { FileInputStream fis = new FileInputStream("c:\\0.mp3");FileOutputStream fos = new FileOutputStream("c:\\2.mp3");byte[] buf = new byte[fis.available()];fis.read(buf);fos.write(buf);fos.close();fis.close();}private static void copy_1() throws IOException { FileInputStream fis = new FileInputStream("c:\\0.mp3");FileOutputStream fos = new FileOutputStream("c:\\1.mp3");byte[] buf = new byte[1024*4];int len = 0;while((len=fis.read(buf))!=-1){fos.write(buf,0,len);}fos.close();fis.close();}}字节流继承体系简图转换流InputStreamReader,OutputStreamWriter转换流的由来?为了方便于字符流与字节流进行转换,也就是建立一个桥梁。

相关文档
最新文档