Java新IO缓冲区与Buffer笔记

javaio流学习总结总结一：javaio流学习总结一、IO流的三种分类方式1.按流的方向分为：输入流和输出流按流的数据单位不同分为：字节流和字符流3.按流的功能不同分为：节点流和处理流二、IO流的四大抽象类：字符流：Reader Writer字节流：InputStream（读数据）OutputStream（写数据）三、InputStream的基本方法int read（） thros IOExeption 读取一个字节以整数形式返回，如果返回-1已到输入流的末尾void lose（） thros IOExeption 关闭流释放内存资源long skip（long n） thros IOExeption 跳过n个字节不读四、OutputStream的基本方法void rite（int b） thros IOExeption 向输出流写入一个字节数据void flush（） thros IOExeption 将输出流中缓冲的数据全部写出到目的地五、Writer的基本方法void rite（int ） thros IOExeption 向输出流写入一个字符数据void rite（String str） thros IOExeption将一个字符串中的字符写入到输出流void rite（String str，int offset，int length）将一个字符串从offset开始的length个字符写入到输出流void flush（） thros IOExeption将输出流中缓冲的数据全部写出到目的地六、Reader的基本方法int read（） thros IOExeption 读取一个字符以整数形式返回，如果返回-1已到输入流的末尾七、节点流类型八、访问文件之FileInputStream和FileOutputStream继承基类用于向文件中输入输出字节九、访问文件之FileReader和FileWriter继承基类用于向文件中输入输出字符----输出流在构造函数第二个参数可以设置true意义为跟在已有文件后进行输入----此类流会抛出FileNotFoundExeption需要对其进行显示捕捉十、缓冲流：缓冲流要套接在相应的节点流之上，提高了读写的效率。

javaio笔记JavaIO是Java编程语言中的一个重要部分，它提供了用于读取和写入数据的接口和类。

通过学习JavaIO，我们可以更好地理解和使用Java中的文件、流和缓冲区等概念。

一、基本概念1.输入流（InputStream）和输出流（OutputStream）：输入流用于从文件中读取数据，输出流用于向文件中写入数据。

2.缓冲区（Buffer）：缓冲区是一种用于存储数据的内存区域，它可以在输入流和输出流之间进行缓存，从而提高数据传输的效率。

3.字符流（Reader和Writer）：字符流用于读取和写入文本数据，它提供了更高级别的抽象，可以处理各种不同的字符编码方式。

4.管道流（PipedInputStream和PipedOutputStream）：管道流是一种用于在多个线程或进程之间进行数据传输的机制。

二、常用类和方法1.FileInputStream和FileOutputStream：用于读取和写入文件的数据流。

2.BufferedInputStream和BufferedOutputStream：提供了缓冲区机制，可以提高数据传输的效率。

3.DataInputStream和DataOutputStream：用于读写基本数据类型和对象数据的流。

4.PrintStream：用于将输出数据格式化为易于阅读的格式。

5.FileReader和FileWriter：用于读取和写入文本数据的字符流。

6.PipedInputStream和PipedOutputStream：用于在多个线程或进程之间进行数据传输的管道流。

三、示例代码1.读取文件内容：```javatry(FileInputStreaminputStream=newFileInputStream("file.t xt");BufferedReaderreader=newBufferedReader(newInputStreamRead er(inputStream))){Stringline;while((line=reader.readLine())!=null){System.out.println(line);}}catch(IOExceptione){e.printStackTrace();}```2.向文件写入数据：```javatry(FileOutputStreamoutputStream=newFileOutputStream("fil e.txt");PrintStreamwriter=newPrintStream(outputStream)){writer.println("Hello,world!");}catch(IOExceptione){e.printStackTrace();}```四、常见问题和解决方法1.文件读取异常：检查文件路径是否正确，确保文件存在并且可读。

package com.buffered;import java.io.*;public class TestBufferedIO {public static void main(String[] args) {String path = "d:/SQLHelp.java";TestBufferedIO t = new TestBufferedIO();try {// t.read2(path);//t.read3();//PrintStream ps = System.out;PrintStream ps = new PrintStream(new File("d:/SQLHelp1.java"));t.list(path, ps);} catch (IOException e) {e.printStackTrace();}}/*** 测试字节流的处理流** @param path* @throws IOException*/public void read1(String path) throws IOException {File f = new File(path);InputStream is = new FileInputStream(f);BufferedInputStream bis = new BufferedInputStream(is);byte[] bs = new byte[20];int flag = -1;while ((flag = bis.read(bs)) != -1) {String msg = new String(bs);System.out.print(msg);}bis.close();is.close();}/*** 测试打印流** @param f* @param fs*/public static void list(String f, PrintStream fs) throws IOException { try {BufferedReader br = new BufferedReader(new FileReader(f));String s = null;while ((s = br.readLine()) != null) {fs.println(s);}br.close();} catch (IOException e) {fs.println("无法读取文件");}}/*** 测试字符流的处理流** @param path* @throws IOException*/public void read2(String path) throws IOException {File f = new File(path);Reader reader = new FileReader(f);BufferedReader br = new BufferedReader(reader);String msg = null;while ((msg = br.readLine()) != null) {System.out.println(msg);}br.close();reader.close();}/*** 接收键盘输入*/public void read3() throws IOException {System.out.println("用户请输入内容：");InputStream is = System.in;BufferedReader reader = new BufferedReader(new InputStreamReader(is));String msg = null;while ((msg = reader.readLine()) != null) {System.out.println(msg);}reader.close();is.close();}}。

java笔记10 io流(stream)本章内容Java流式输入/输出原理Java流类的分类流入/流出流类常见的节点流和处理流文件流缓冲流数据流转换流Print流Object流流的原理：读写数据真正的文件在硬盘里数据，读数据都是0和1，文件想像成一个桶，文件里取数据，管道就是流，和水流的原理一样。

流就是2根管道,一个向里一个向外,无论向里还是向外都是对我们写的程序来说的包在外面是处理流,一根不够包2根处理流管道,直接套在节点流或者处理流上面在java程序中，对于数据的输入/输出操作以"流"方式进行，J2SDK提供了各种各样的"流"类，用以获取不通种类的数据，程序中通过标准的方法输入和输出数据通常我们指的流就是：io包里的类，java.io包中定义了多个流类型(类或抽象类)来事先输入/输出功能：可以从不桶的调度对其进行分类：按数据流的方向不同可以分为输入流和输出流按处理数据单位不同可以分为字节流和字符流按照功能不同可以分为节点流和处理流(注释)：输入流：程序的角度读数据输出流：往外写字节流：0和1字符流：一个字符一个字符(2个字节)节点流：管道直接接到数据源上处理流：套在其他管道上的流，处理流是"连接"在已存在的流(节点流或处理流)之上，通过对数据的处理为程序提供更为强大的读写功能。

J2SDK所提供的所有刘类型位于包java.io内都分别继承自以下四种抽象流类型字节流字符流输入流InuputStreamReader往里读输出流OutputStreamWriter字符形式往外写4根管道：一端接着程序一端接着数据源InputStream：继承自InputStream的流都是用于向程序中输入数据,且单位为字节(8bit) 深色：节点流浅色：处理流InputStream的基本方法：abstract intread()throws IOException read一下读一个字节读取一个字节并以正数的形式返回(0-255)如果返回-1已到输入流的末尾intread(byte b)throws IOException从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。

第七章：输入和输出流第一节：数据流的基本概念1.在java中，把不同类型的输入、输出源抽象为流，其中输入或输出的数据成为数据流，用统一的接口表示。

2.数据流是指一组有顺序的、有起点和终点的字节集合。

程序从键盘接收数据或向文件中写数据，都可以使用数据流来完成。

3.流分为输入数据流和输出数据流。

输入数据流只能读不能写；而输出数据流只能写不能读。

从数据流中读取数据是，必须有一个数据源与该数据流相连（FileInput Stream in = new FileInputStream(“javatest.txt”);）（实例化）4.Java.io包中提供了表示数据流的4个基本抽象类（不可以实例化），分别是InputStream、OutputStream、Reader和Writer。

因此涉及数据流操作的程序中，几乎都要使用引入语句：import java.io.*5.为了使对象的状态能够方便地永久保存下来，java.io包中又提供了以字节流为基础的用于对象的永久化保存状态的机制，通过实现ObjectInput和Object Output接口来完成。

6.输入数据流提供的主要操作方法有：（得到-1，标志数据流结束）int read():从输入流读取一个字节的二进制数据int read( byte [ ] b):将多个字节读到数组中，填满整个数组int read( byte [ ] b ,int off , int len): 从输入流中读取长度为len的数据，从数组b中下标为off的位置开始放置读入的数据，读毕返回读取的字节数。

7.void close(): 关闭数据流int available(): 返回目前可以从数据流中读取的字节数long skip(long l): 跳过数据流中指定数量的字节不读取，返回值表示实际跳过的字节数8.如需要反向读取数据流，则使用回推操作（Push Back）Boolean markSupported(): 用于测试数据流是否支持回推操作void mark(int): 用于标记数据流的当前位置，并划出一个缓冲区，其大小至少为指定参数的大小。

Java 缓冲区的理解在Java中，缓冲区（Buffer）是一种数据结构，用于在内存中临时存储数据。

它提供了一种有效的方式来处理输入和输出，以及在不同的组件之间传输数据。

Java 缓冲区广泛应用于文件操作、网络通信、数据库读写等场景中，它能够提高数据传输的效率，减少IO操作的次数。

1. 缓冲区的概念和作用缓冲区是一块连续的内存区域，它可以临时存储一定量的数据。

Java中提供了一系列缓冲区类（如ByteBuffer、CharBuffer、IntBuffer等），用于存储不同类型的数据。

缓冲区的作用主要有两个方面：•提高IO效率：通过读写缓冲区来减少IO操作的次数，从而提高程序的性能。

•实现数据交互：通过缓冲区在不同组件之间传输数据，如网络通信中的数据传输。

2. 缓冲区的基本原理缓冲区的基本原理是利用读写指针来跟踪数据的读写位置，并保持内存中的数据与外部数据源的同步。

在使用缓冲区进行数据读写时，需要先分配一个合适大小的缓冲区对象，然后通过读写指针来操作缓冲区中的数据。

读写指针包括位置（position）、限制（limit）和容量（capacity）三个属性：•位置（position）：指示下一个读写操作的位置，默认初始值为0，每进行一次读写操作，位置会自动向后移动。

•限制（limit）：指示读写的操作范围，它始终小于等于容量。

读操作时，限制等于缓冲区中的实际数据长度；写操作时，限制等于缓冲区容量。

•容量（capacity）：缓冲区的总容量，它不会改变。

实际读写操作时，通过读写指针来操作缓冲区中的数据。

读操作会将位置指针向后移动，而写操作会将位置指针向前移动。

通过控制位置指针和限制，可以实现对缓冲区的灵活读写。

3. 缓冲区的类型Java提供了多种类型的缓冲区，以适应不同类型的数据读写需求。

常见的缓冲区类型有：•ByteBuffer：用于存储字节数据，是最常用的缓冲区类型。

可以通过allocate()方法来创建ByteBuffer对象，也可以通过wrap()方法来包装一个字节数组。

java中的IO操作总结（一）所谓IO，也就是Input与Output的缩写。

在java中，IO涉及的范围比较大，这里主要讨论针对文件内容的读写其他知识点将放置后续章节（我想，文章太长了，谁都没耐心翻到最后）对于文件内容的操作主要分为两大类分别是：字符流字节流其中，字符流有两个抽象类：Writer Reader其对应子类FileWriter和FileReader可实现文件的读写操作BufferedWriter和BufferedReader能够提供缓冲区功能，用以提高效率同样，字节流也有两个抽象类：InputStream OutputStream其对应子类有FileInputStream和FileOutputStream实现文件读写BufferedInputStream和BufferedOutputStream提供缓冲区功能俺当初学IO的时候犯了不少迷糊，网上有些代码也无法通过编译，甚至风格都很大不同，所以新手请注意：1.本文代码较长，不该省略的都没省略，主要是因为作为一个新手需要养成良好的代码编写习惯2.本文在linux下编译，类似于File.pathSeparator和File.separator这种表示方法是出于跨平台性和健壮性考虑3.代码中有些操作有多种执行方式，我采用了方式1...方式2...的表述，只需轻轻解开注释便可编译4.代码中并没有在主方法上抛出异常，而是分别捕捉，造成代码过长，如果仅是测试，或者不想有好的编程习惯，那你就随便抛吧……5.功能类似的地方就没有重复写注释了，如果新手看不懂下面的代码，那肯定是上面的没有理解清楚编译之后的效果：编译之后，产生life目录下的lrc.txt文件，复制成功编译之后产生的文件，以上在字符串中加\r\n就是为了便于终端显示其实在linux下面换行仅用\n即可读取文件到终端两个目录都有“一个人生活.mp3”文件，顺便说一下，这歌挺好听的初学者在学会使用字符流和字节流之后未免会产生疑问：什么时候该使用字符流，什么时候又该使用字节流呢？其实仔细想想就应该知道，所谓字符流，肯定是用于操作类似文本文件或者带有字符文件的场合比较多而字节流则是操作那些无法直接获取文本信息的二进制文件，比如图片，mp3，视频文件等说白了在硬盘上都是以字节存储的，只不过字符流在操作文本上面更方便一点而已此外，为什么要利用缓冲区呢？我们知道，像迅雷等下载软件都有个缓存的功能，硬盘本身也有缓冲区试想一下，如果一有数据，不论大小就开始读写，势必会给硬盘造成很大负担，它会感觉很不爽人不也一样，一顿饭不让你一次吃完，每分钟喂一勺，你怎么想？因此，采用缓冲区能够在读写大文件的时候有效提高效率。

JavaIO流详解：重点Java IO流详解：重点数据流的基本概念：把不同类型的输⼊，输出源抽象为：流（Stream）其中，输⼊或输出的数据称为数据流(Data Stream)，⽤统⼀的接⼝来表⽰；IO流的分类：数据流是指⼀组有顺序的，有起点和终点的字节集合；按照流的流向，可以分为输⼊流和输出流；，其中输⼊，输出是针对程序来说的；按照处理单位的不同，分为：字节流和字符流：字节流：每次读取⼀个字节，当传输的⽂件中中⽂时，就会出现乱码；字符流：每次读取2个字节，有中⽂时，使⽤该流就可以正确传输显⽰中⽂；（1字符=2个字节，1字节=8位，⼀个汉字占2个字节）按照⾓⾊划分：分为：节点流和处理流：节点流：从或向⼀个特定的地⽅（节点）读写数据；如FileInputStream;（直接操作数据的：都是节点流，构造⽅法都是数据对象）处理流（包装流）：是对⼀个已经存在的流的连接和封装；通过所封装的流的功能调⽤实现数据读写；处理流的构造⽅法总是要带⼀个其他的流对象做参数；Java IO流有4个抽象基类：其他流都是继承这4⼤基类；字节流，字符流输⼊流：字节输⼊流，字符输⼊流输出流：字节输出流，字符输出流如何选择适合⾃⼰的流：⾸先要知道是选择输⼊流还是输出流；然后考虑你传输数据时，是每次传⼀个字节就选字节流；如果存在中⽂，肯定选字符流；根据前⾯2步，就可以选出⼀个合适的节点流；如果需要在此基础上增强，那么就在处理流中挑选⼀个即可；字节输⼊流：inputStreamInputStream抽象类：常⽤⽅法//inputstream类中常⽤⽅法：//1, int read()：从输⼊流中读取⼀个字节的⼆进制数据；//2，int read(byte[] b)：将多个字节读取到数组中，填满整个数组；//3，int read(byte[] int off, int len)：从输⼊流读取长度位len的数据，从数组b中下标为off的位置开始放置读⼊的数据，读完返回读取的字节数；//4，void close():关闭流数据；字节输⼊流有很多⼦类：常⽤的有：ByteArrayInputStream：字节数组输⼊流，该类的功能就是从字节数组byte[] 中进⾏以字节为单位的读取；也就是将资源⽂件都以字节形式存⼊到该类中的字节数组中去；我们拿数据也是从这个字节数组中拿；PipedInputStream：管道字节输⼊流它和PipedOutputStream⼀起使⽤，能实现多线程间的管道通信；FilterInputStream：装饰着模式中充当装饰者的⾓⾊具体的装饰者都要继承它，所以在该类的⼦类下都是⽤来装饰别的流的，也就是处理类；BufferedInputStream：缓冲流对处理流进⾏装饰，增强，内部会有⼀个缓冲区，⽤来存放字节，每次都素将缓冲区存满后发送，⽽不是⼀个字节或2个字节这样发送，效率更⾼；DataInputSteam：数据输⼊流：⽤来装饰其他输⼊流，它允许通过数据流来读写Java基本类型；FileInputStream：⽂件输⼊流：通常⽤来对⽂件进⾏读取操作；File：对指定⽬录的⽂件进⾏操作：对指定⽬录的⽂件进⾏操作：增，删，改，查！ObjectInputStream：对象输⼊流：⽤来提供对基本数据或对象的持久存储；序列化，反序列化；----------节点流------------------------------------------------------------------------------------------------------------------------------------代码案例：ByteArrayInputStream：read()⽅法；/*** 案例1：ByteArrayInputStream：把byte数组中的数据，读取到控制台*/public class Demo02 {public static void main(String[] args) {//1,给byte数组赋值String s="hello";byte[] bytes=s.getBytes();int d=0;//2,声明⼀个byte数组输⼊流ByteArrayInputStream bis=new ByteArrayInputStream(bytes);try {//3,读取流中的数据while ((d=bis.read())!=-1){//-1：代表流就读取完毕System.out.print((char)d);//强转}//4,关闭流bis.close();} catch (Exception e) {e.printStackTrace();}}}代码案例2：toByteArray()：⽅法public class Demo04 {public static void main(String[] args) {//1，声明⼀个字符串，并给byte数组赋值String str1="hello";byte[] bytes =str1.getBytes();//2,创建⼀个新字节数组，⽤于接收数据byte[] bytes1 =new byte[5];ByteArrayOutputStream bos=new ByteArrayOutputStream();try {bos.write(bytes);bytes1 =bos.toByteArray();//接收数据//3,把byte转换称字符串:因为String类提供byte类型的参数构造⽅法 String s=new String(bytes1);System.out.println("--:"+s);//4,关闭流：bos.close();} catch (IOException e) {e.printStackTrace();}}}代码案例：FileInputStream: read();/*** FileInputStream类*/public class Demo08 {public static void main(String[] args) {//1,定义⼀个⽂件String s="hello";File file=new File("E:/haha/demo1.txt");try {//2,声明⼀个⽂件输⼊流，构造⽅法总送⽂件FileInputStream fis=new FileInputStream(file);int d =0;while ((d=fis.read()) != -1){System.out.print((char)d );//123}//3,关闭流fis.close();} catch (Exception e) {e.printStackTrace();}}}代码案例：FileOutputStream：write()⽅法：参数都是byte[]；/*** FileOutputStream类：* 操作的都是byte[] 数据；*/public class Demo09 {public static void main(String[] args) {//1，写⼊数据：可以写⼊byte[]String ss="world";byte[] bytes=ss.getBytes();//2，定位⽂件位置File file=new File("E:/haha/demo1.txt");try {FileOutputStream fos=new FileOutputStream(file);fos.write(bytes);//写⼊byte数据System.out.println("over");//3，关闭流fos.close();} catch (Exception e) {e.printStackTrace();}}}----------处理流------------------------------------------------------------------------------------------------------------------------------------代码案例：BufferedInputStream 类： read()⽅法public class Demo11 {public static void main(String[] args) {File file= new File("E:/haha/demo1.txt");try {FileInputStream fis=new FileInputStream(file);//声明⼀个缓冲流BufferedInputStream bis=new BufferedInputStream(fis);//读取缓冲流int d=-1;while((d=bis.read())!= -1){System.out.print((char) d);//world}//关闭流fis.close();bis.close();} catch (IOException e) {e.printStackTrace();}}}代码案例：public class Demo12 {public static void main(String[] args) {String ss="hello";byte[] bytes=ss.getBytes();//声明⼀个字节流ByteArrayInputStream bais=new ByteArrayInputStream(bytes);//声明⼀个处理流BufferedInputStream bis=new BufferedInputStream(bais);//读取流数据try {int d =0;while ((d=bis.read()) != -1){System.out.print((char) d);//hello}//关闭流bais.close();bis.close();} catch (IOException e) {e.printStackTrace();}}}代码案例：BufferedOutputStream：write();public class Demo14 {public static void main(String[] args) {String ss="doubi4";byte[] bytes=ss.getBytes() ;try {FileOutputStream fos=new FileOutputStream("E:/haha/demo1.txt"); BufferedOutputStream bos=new BufferedOutputStream(fos);bos.write(bytes);System.out.println("over");fos.close();bos.close();} catch (IOException e) {e.printStackTrace();}}}。