javaio缓冲区大小

『壹』 javaio缓冲区为什么不直接开辟大空间

Javaio缓冲区不直接开辟大空间原因：有效地管理系统资源，方便用户使用的程序集合。(操作系统是加在裸机上的第一层软件，是用户与计算机的接口)。

当BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并置入缓冲区，如果缓冲区数据不足，才会再从文件中读取。这里的缓冲区应该是在硬盘中。

使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。这里的缓存区应该在内存中。

原理：

Java把这些不同来源和目标的数据都统一抽象为数据流。Java语言的输入输出功能是十分强大而灵活的，美中不足的是看上去输入输出的代码并不是很简洁，因为你往往需要包装许多不同的对象。

在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流。

『贰』 java io 默认缓冲区大小是多少字节

8192个字节。
你可以去jdk中查看BufferedReader类的源代码，里面定义了private static int defaultCharBufferSize = 8192

『叁』 Java 以下两个要求 怎么在Java中以程序的方式实现 （围绕CORBA和IOR）

最近在看JAVANIO 的相关知识，了解一下IO的底层实现原理。

IO涉及到的底层的概念大致如下：

1） 缓冲区操作。2） 内核空间与用户空间。3） 虚拟内存。4） 分页技术。

一，虚拟存储器

虚拟存储器是硬件异常（缺页异常）、硬件地址翻译、主存、磁盘文件和内核软件的完美交互，它为每个进程提供了一个大的、一致的和私有的地址空间。

虚拟存储器的三大能力：①将主存看成是一个存储在磁盘上的地址空间的高速缓存。②为每个进程提供了一个一致的地址空间。③保护每个进程的地址空间不被其他进程破坏。

虚拟内存的两大好处：① 一个以上的虚拟地址可指向同一个物理内存地址。② 虚拟内存空间可大于实际可用的硬件内存。

二，用户空间与内核空间

设虚拟地址为32位，那么虚拟地址空间的范围为0~4G。操作系统将这4G分为二部分，将最高的1G字节（虚拟地址范围为：0xC0000000-0xFFFFFFFF）供内核使用，称为内核空间。而将较低的3G字节供各个进程使用，称为用户空间。

每个进程可以通过系统调用进入内核，因为内核是由所有的进程共享的。对于每一个具体的进程，它看到的都是4G大小的虚拟地址空间，即相当于每个进程都拥有一个4G大小的虚拟地址空间。

三，IO操作

一般IO缓冲区操作：

1） 用户进程使用read（）系统调用，要求其用户空间的缓冲区被填满。

2） 内核向磁盘控制器硬件发命令，要求从磁盘读入数据。

3） 磁盘控制器以DMA方式（数据不经过CPU）把数据复制到内核缓冲区。

4） 内核将数据从内核缓冲区复制到用户进程发起read（）调用时指定的用户缓冲区。

四，JAVA中的IO，本质上是把数据移进或者移出缓冲区。

read（）和write（）系统调用完成的作用是：把内核缓冲区映射的物理内存空间中的数据 拷贝到 用户缓冲区映射的物理内存空间中。

因此，当使用内存映射IO时，可视为：用户进程直接把文件数据当作内存，也就不需要使用read（）或write（）系统调用了。

当发起一个read（）系统调用时，根据待读取的数据的位置生成一个虚拟地址（用户进程使用的是虚拟地址），由MMU转换成物理地址，若内核中没有相应的数据，产生一个缺页请求，内核负责页面调入从而将数据从磁盘读取到内核缓冲区映射的物理内存中。对用户程序而言，这一切都是在不知不觉中进行。

总之，从根本上讲数据从磁盘装入内存是以页为单位通过分页技术装入内存的。

五，JAVA NIO中的直接缓存和非直接缓存

直接缓存：不是分配于堆上的存储，位于JVM之外，它不受JAVA的GC管理，相当于内核缓冲区。非直接缓存：建立在JAVA堆上的缓存，受JVM管理，相当于用户缓冲区。

根据上面第三点，将直接缓存中的数据写入通道的速度要快于非直接缓存。因为，连接到通道的另一端是文件（磁盘，FileChannel）或者网络（Socket通道），这些都是某种形式上的硬件。那么，对于非直接缓存而言，数据从缓冲区传递到硬件，要经过内核缓冲区中转。而对于直接缓存而言，就不需要了，因为直接缓存已经直接映射到内核缓冲区了。

『肆』 java 读取一个巨大的文本文件，该如何实现 既能保证内存不溢出 又能保证性能

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class ReadBig {
public static String fff = "C:\\mq\\read\\from.xml";

public static void main1(String[] args) throws Exception {

final int BUFFER_SIZE = 0x300000;// 缓冲区大小为3M

File f = new File(fff);

/**
*
* map(FileChannel.MapMode mode,long position, long size)
*
* mode - 根据是按只读、读取/写入或专用（写入时拷贝）来映射文件，分别为 FileChannel.MapMode 类中所定义的
* READ_ONLY、READ_WRITE 或 PRIVATE 之一
*
* position - 文件中的位置，映射区域从此位置开始；必须为非负数
*
* size - 要映射的区域大小；必须为非负数且不大于 Integer.MAX_VALUE
*
* 所以若想读取文件后半部分内容，如例子所写；若想读取文本后1/8内容，需要这样写map(FileChannel.MapMode.READ_ONLY,
* f.length()*7/8,f.length()/8)
*
* 想读取文件所有内容，需要这样写map(FileChannel.MapMode.READ_ONLY, 0,f.length())
*
*/

MappedByteBuffer inputBuffer = new RandomAccessFile(f, "r")
.getChannel().map(FileChannel.MapMode.READ_ONLY,
f.length() / 2, f.length() / 2);

byte[] dst = new byte[BUFFER_SIZE];// 每次读出3M的内容

long start = System.currentTimeMillis();

for (int offset = 0; offset < inputBuffer.capacity(); offset += BUFFER_SIZE) {

if (inputBuffer.capacity() - offset >= BUFFER_SIZE) {

for (int i = 0; i < BUFFER_SIZE; i++)

dst[i] = inputBuffer.get(offset + i);

} else {

for (int i = 0; i < inputBuffer.capacity() - offset; i++)

dst[i] = inputBuffer.get(offset + i);

}

int length = (inputBuffer.capacity() % BUFFER_SIZE == 0) ? BUFFER_SIZE
: inputBuffer.capacity() % BUFFER_SIZE;

System.out.println(new String(dst, 0, length));// new
// String(dst,0,length)这样可以取出缓存保存的字符串，可以对其进行操作

}

long end = System.currentTimeMillis();

System.out.println("读取文件文件一半内容花费：" + (end - start) + "毫秒");

}

public static void main2(String[] args) throws Exception {
int bufSize = 1024;
byte[] bs = new byte[bufSize];
ByteBuffer byteBuf = ByteBuffer.allocate(1024);
FileChannel channel = new RandomAccessFile(fff, "r").getChannel();
while (channel.read(byteBuf) != -1) {
int size = byteBuf.position();
byteBuf.rewind();
byteBuf.get(bs); // 把文件当字符串处理，直接打印做为一个例子。
System.out.print(new String(bs, 0, size));
byteBuf.clear();
}

}

public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new FileReader(fff));
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}

}

『伍』 关于java的io读写，缓冲区是如何提高读写效率的

理解是对的。
调用I\O操作的时候，实际上还是一个一个的读或者写，关键就在，CPU只有一个，不论是几个核心。CPU在系统调用时，会不会还要参与主要操作？参与多次就会花更多的时间。

系统调用时，若不用缓冲，CPU会酌情考虑使用 中断。此时CPU是主动地，每个周期中都要花去一部分去询问I\O设备是否读完数据，这段时间CPU不能做任何其他的事情（至少负责执行这段模块的核不能）。所以，调用一次读了一个字，通报一次，CPU腾出时间处理一次。

而设置缓冲，CPU通常会使用 DMA 方式去执行 I\O 操作。CPU 将这个工作交给DMA控制器来做，自己腾出时间做其他的事，当DMA完成工作时，DMA会主动告诉CPU“操作完成”。这时，CPU接管后续工作。在此，CPU 是被动的。DMA是专门 做 I＼O 与 内存 数据交换的，不仅自身效率高，也节约了CPU时间，CPU在DMA开始和结束时做了一些设置罢了。
所以，调用一次，不必通报CPU，等缓冲区满了，DMA 会对C PU 说 “嘿，伙计！快过来看看，把他们都搬走吧”。

综上，设置缓冲，就建立了数据块，使得DMA执行更方便，CPU也有空闲，而不是呆呆地候着I\O数据读来。从微观角度来说，设置缓冲效率要高很多。尽管，不能从这个程序上看出来。 几万字的读写\就能看到差距

『陆』 java 中简述使用流进行读写文本文件的步骤

读写是两个不同的分支，通常都是分开单独使用的。

• 可以通过BufferedReader 流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。
  BufferedReader bre = null;
  try {
  String file = "D:/test/test.txt";
  bre = new BufferedReader(new FileReader(file));//此时获取到的bre就是整个文件的缓存流
  while ((str = bre.readLine())!= null) // 判断最后一行不存在，为空结束循环
  {
  System.out.println(str);//原样输出读到的内容
  }；
  备注： 流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。
  

• 可以通过“FileOutputStream”创建文件实例，之后过“OutputStreamWriter”流的形式进行存储，举例：

  OutputStreamWriter pw = null;//定义一个流
  pw = new OutputStreamWriter(new FileOutputStream(“D:/test.txt”),"GBK");//确认流的输出文件和编码格式，此过程创建了“test.txt”实例
  pw.write("我是要写入到记事本文件的内容");//将要写入文件的内容，可以多次write
  pw.close();//关闭流
  备注：文件流用完之后必须及时通过close方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。

『柒』 理解不了BufferedReader的大小有什么作用

1、java.io.BufferedReader和java.io.BufferedWriter类各拥有8192字符的缓冲区。当BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并置入缓冲区，而之后若使用read()方法，会先从缓冲区中进行读取。如果缓冲区数据不足，才会再从文件中读取，使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。

2、从标准输入流System.in中直接读取使用者输入时，使用者每输入一个字符，System.in就读取一个字符。为了能一次读取一行使用者的输入，使用了BufferedReader来对使用者输入的字符进行缓冲。readLine()方法会在读取到使用者的换行字符时，再一次将整行字符串传入。

3、System.in是一个位流，为了转换为字符流，可使用InputStreamReader为其进行字符转换，然后再使用BufferedReader为其增加缓冲功能。例如：
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

下面的示例示范了BufferedReader和BufferedWriter的使用。可以在文字模式下输入字符，程序会将输入的文字存储至指定的文件中，如果要结束程序，输入quit字符串即可。
Java代码 ：
package ysu.hxy;
import java.util.*;
import java.io.*;

public class BufferedReaderWriterDemo {
public static void main(String[] args) {
try {
//缓冲System.in输入流
//System.in是位流，可以通过InputStreamReader将其转换为字符流
BufferedReader bufReader = new BufferedReader(new InputStreamReader(System.in));
//缓冲FileWriter
BufferedWriter bufWriter = new BufferedWriter(new FileWriter(args[0]));
String input = null;
//每读一行进行一次写入动作
while(!(input = bufReader.readLine()).equals("quit")) {
bufWriter.write(input);
//newLine()方法写入与操作系统相依的换行字符，依执行环境当时的OS来决定该输出那种换行字符
bufWriter.newLine();
}
bufReader.close();
bufWriter.close();
} catch( e) {
System.out.println("没有指定文件");
} catch(IOException e) {
e.printStackTrace();
}
}
}
//运行后会在目录下产生一个文件test2.txt，并在其中写入刚才输入的内容。