编JAVA程序获取指定D盘下file.txt内容要求创建一个fis字节输入流对象一个buf字节组长度定义为1024整数倍

您可以使用以下代码来实现您的需求：

该代码会创建一个 FileInputStream 对象，该对象将从指定的文件路径中读取数据。然后，它会创建一个长度为 1024 的字节数组，并使用 fisread(buf) 方法将文件内容读取到该数组中。最后，它会将读取到的内容输出到控制台，并关闭输入流。

Try again

Java *** 作文件包括了两个层面：

在文件系统的层面上来 *** 作文件，包括创建文件、删除文件、创建目录、拷贝文件等等。

*** 作文件里保存的数据，包括读文件、写文件。

1 在文件系统层面 *** 作文件

11 File 类介绍

Java 中通过 javaioFile 类来对一个文件（包括目录）进行抽象的描述。不过有 File 对象，并不代表对应的文件真实存在。

12 File 常见属性

属性 修饰符及类型 说明

pathSeparator static String 依赖于系统的路径分隔符，String 类型的表示

pathSeparator static char 依赖于系统的路径分隔符，char 类型的表示

13 File 构造方法

构造方法 说明

File(File parent, String child) 根据父目录+孩子文件路径，创建一个新的 File 实例

File(String pathname) 根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者相对路径

File(String parent, String child) 根据父目录路径+孩子文件路径，创建一个新的 File 实例

14 File 常用方法

方法 返回值类型 说明 注意

getParent() String 返回 File 对象的父目录文件路径

getName() String 返回 File 对象的纯文件名称

getPath() String 返回 File 对象的文件路径

getAbsolutePath() String 返回 File 对象的绝对路径

getCanonicalPath() String 返回 File 对象的修饰过的绝对路径 如果绝对路径的值为：d:///testtxt，那么修饰过的绝对路径就为：d:/testtxt。

exists() boolean 判断 File 对象描述的文件是否真实存在

isDirectory() boolean 判断 File 对象代表的文件是否是一个目录

isFile() boolean 判断 File 对象代表的文件是否是一个普通文件

createNewFile() boolean 根据 File 对象，自动创建一个空文件。成功创建后返回 true 如果文件路径不正确或者没有权限，则可能创建失败。

delete() boolean 根据 File 对象，删除该文件。成功删除后返回 true 如果文件路径不正确或者没有权限，则可能删除失败。

deleteOnExit() void 根据 File 对象，标注文件将被删除，删除动作会到 JVM 运行结束时才会进行

list() String[] 返回 File 对象代表的目录下的所有文件名

listFiles() File[] 返回 File 对象代表的目录下的所有文件，以 File 对象表示

mkdir() boolean 创建 File 对象代表的目录

mkdirs() boolean 创建 File 对象代表的目录，如果必要，会创建中间目录

renameTo(File dext) boolean 重命名文件或移动文件，当目录为空时也可以重命名目录

canRead() boolean 判断用户是否对文件有可读权限

canWrite() boolean 判断用户是否对文件有可写权限

2 *** 作文件里的数据

文件内容的 *** 作包括读文件和写文件，而对于这两种 *** 作 Java 又提供了两种不同的类：

读类 写类 说明

InputStream OutputStream 字节流，针对二进制文件进行读写， *** 作基本单位是字节

Reader Writer 字符流，针对文本文件进行读写， *** 作基本单位是字符

字节流： 它处理单元为1个字节， *** 作字节和字节数组，存储的是二进制文件，如果是音频文件、、歌曲，就用字节流。

字符流： 它处理的单元为2个字节的 Unicode 字符，分别 *** 作字符、字符数组或字符串，字符流是由 Java 虚拟机将字节转化为2个字节的 Unicode 字符为单位的字符而成的，如果是关系到中文（文本）的，用字符流更好。

所有文件都是以字节的形式储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列。

字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串。

字节流提供了处理任何类型的 IO *** 作的功能，但它不能直接处理 Unicode 字符，而字符流就可以。

字节流在 *** 作的时候本身不会用到缓冲区的，是与文件本身直接 *** 作的；而字符流在 *** 作的时候会使用到缓冲区的。

其中 InputStream/OutputStream 和 Reader/Writer 都实现了 Closeable 接口，所以可以不主动通过 close 方法去关闭该资源，而是通过代码可读性更高的 try-with-resource *** 作在 try 中的内容结束后，无论是否有异常都关闭该资源。

使用 OutputStream 或 writer 打开文件默认会清空之前的文件内容

21 *** 作字节流数据

211 InputStream

InputStream 是一个抽象类，使用时需要使用具体的实现类。InputStream 的实现类很多，针对不同的输入设备都可以对应一个实现类，其中针对文件读取的实现类是 FileInputStream。

FileInputStream 构造方法：

构造方法 说明

FileInputStream(File file) 利用 File 构造对应文件输入流

FileInputStream(String name) 利用文件路径构造对应文件输入流

InputStream 核心方法：

方法 返回值类型 说明

read() int 一次读取一个字节的数据，如果返回 -1 表示文件读完了

read(byte[] b) int 一次最多读取 blength 字节的数据到 b 中，返回值为实际读到的字节数量，如果返回 -1 表示文件读完了

read(byte[] b, int off, int len) int 一次最多读取 len 个字节到 b 中，并从 off 的位置开始存放，返回值为实际读到的字节数量，如果返回 -1 表示文件读完了

close() void 关闭字节流

为什么 read 方法的返回值是 Int 类型？

对于 read 方法的返回值，当读取的是数字和英文时，返回值是对应的 ascii 码；当读取的是汉字时，返回的是汉字的机内码，比如使用的是 GBK 编码方式，返回的就是 GBK 的内部编码。read 方法每次从 inputstream 中读取一个字节，而一个字节是8位，但当最高位是1的时候，二进制对应的 ascii 码值就是复数，而 ascii 是没有负数的，所以用 byte 类型表示不了。并且 11111111 对应的十进制值是 -1，而返回 -1 表示文件读取完毕了，则后面的数据就不会读了，因此 byte 类型不适合，int 类型则可以解决这个问题。

示例代码： 使用 read() 方法读取文件内容

public class Demo1 {

public static void main(String[] args) throws IOException {

File file = new File("/testtxt");

StringBuilder sb = new StringBuilder();

try (InputStream inputStream = new FileInputStream(file)){

while(true) {

int b = inputStreamread();

if(b == -1){

break;

}

sbappend((char) b);

}

} catch (IOException e) {

eprintStackTrace();

}

Systemoutprintln(sbtoString());

}

}

登录后复制



示例代码： 使用 read(byte[] b) 方法读取文件内容

public class Demo1 {

public static void main(String[] args) throws IOException {

File file = new File("/testtxt");

byte[] buffer = new byte[1024];

try (InputStream inputStream = new FileInputStream(file)){

while(true) {

int len = inputStreamread(buffer);

if(len == -1){

break;

}

String s = new String(buffer, 0, len, "utf-8");

Systemoutprintln(s);

}

} catch (IOException e) {

eprintStackTrace();

}

}

}

登录后复制



212 OutputStream

OutputStream 是一个抽象类，使用时需要使用具体的实现类。OutputStream 的实现类很多，针对不同的输出设备都可以对应一个实现类，其中针对文件读取的实现类是 FileOutputStream。

FileOutputStream 构造方法：

构造方法 说明

FileOutputStream(File file) 利用 File 构造对应文件输出流

FileOutputStream(String name) 利用文件路径构造对应文件输出流

FileOutputStream(File file, boolean append) append 表示是否追加数据到文件的末尾，为 true 表示追加，为 false 表示情空之前的内容重新加入

FileOutputStream(String name, boolean append) append 表示是否追加数据到文件的末尾，为 true 表示追加，为 false 表示情空之前的内容重新加入

OutputStream 核心方法：

方法 返回值类型 说明

write() int 一次写入一个字节的数据

write(byte[] b) int 一次最多写入 blength 字节的数据到 b 中，返回值为实际写入的字节数量

write(byte[] b, int off, int len) int 一次最多写入 len 个字节到 b 中，并从 off 的位置开始存放，返回值为实际写入到的字节数量

close() void 关闭字节流

示例代码：

public class Demo1{

public static void main(String[] args) throws IOException {

File in = new File("/intxt");

File out = new File("/outtxt");

byte[] buffer = new byte[1024];

try (InputStream inputStream = new FileInputStream(in);

OutputStream outputStream = new FileOutputStream(out)) {

while (true) {

int len = inputStreamread(buffer);

if (len == -1) {

break;

}

outputStreamwrite(buffer, 0, len);

}

} catch (IOException e) {

eprintStackTrace();

}

}

}

登录后复制



213 BufferedInputStream

BufferedInputStream 也是 InputStream 的具体实现类，相比于 FileInputStream 优化了系统调用，即通俗解释为：将数据保存了缓存区，但是减少磁盘 IO 并不是 BufferedInputStream 来做的，而是 OS 来做的。OS 根据局部性原理，会预读部分的数据到内存缓存区，这样下次 IO 如果读取数据在缓存命中了，就不需要等待磁盘的寻址，而是直接返回数据，效率就会快很多。

214 BufferedOutputStream

BufferedOutPutStream 也是 OutputStream 的具体实现类，相比于 FileOutputStream 优化了系统调优，即每次写数据的时候，都会将数据放入缓存区中，等缓存区满了之后，才会一次性写入到磁盘中，大大提高了效率。

22 *** 作字符流数据

221 Reader

Reader 是实现字符输入流的一种类型，其本身属于一个抽象类，使用时需要使用具体的实现类。Reader 的实现类很多，针对不同的输入设备都可以对应一个实现类，其中针对文件读取的实现类是 FileReader。Reader 的使用方式和 InputStream 相仿。

示例代码：

public class Demo2 {

public static void main(String[] args) throws FileNotFoundException {

File file = new File("/testtxt");

StringBuilder sb = new StringBuilder();

try (Reader reader = new FileReader(file)) {

while (true) {

int read = readerread();

if (read == -1) {

break;

}

sbappend((char) read);

}

} catch (IOException e) {

eprintStackTrace();

}

Systemoutprintln(sbtoString());

}

}

登录后复制



222 Writer

Writer 是实现字符输出流的一种类型，其本身属于一个抽象类，使用时需要使用具体的实现类。Writer 的实现类很多，针对不同的输出设备都可以对应一个实现类，其中针对文件读取的实现类是 FileWriter。Writer 的使用方式和 OutputStream 相仿。

FileWriter 构造方法：

构造方法 说明

FileWriter(File file) 利用 File 构造对应文件输出流

FileWriter(String name) 利用文件路径构造对应文件输出流

FileWriter(File file, boolean append) append 表示是否追加数据到文件的末尾，为 true 表示追加，为 false 表示情空之前的内容重新加入

FileWriter(String name, boolean append) append 表示是否追加数据到文件的末尾，为 true 表示追加，为 false 表示情空之前的内容重新加入

示例代码：

public class Demo2 {

public static void main(String[] args) throws FileNotFoundException {

File in = new File("/intxt");

File out = new File("/outtxt");

try (Reader reader = new FileReader(in);

Writer writer = new FileWriter(out)) {

while (true) {

int read = readerread();

if (read == -1) {

break;

}

writerwrite(read);

}

} catch (IOException e) {

eprintStackTrace();

}

}

}

登录后复制



223 BufferedReader

BufferedReader 也是 Reader 的具体实现类，相比于 Reader 优化了系统调用，即通俗解释为：将数据保存了缓存区，但是减少磁盘 IO 并不是 BufferedReader 来做的，而是 OS 来做的。OS 根据局部性原理，会预读部分的数据到内存缓存区，这样下次 IO 如果读取数据在缓存命中了，就不需要等待磁盘的寻址，而是直接返回数据，效率就会快很多。

224 BufferedWriter

BufferedWriter 也是 Writer 的具体实现类，相比于 Writer 优化了系统调优，即每次写数据的时候，都会将数据放入缓存区中，等缓存区满了之后，才会一次性写入到磁盘中，大大提高了效率。

23 Scanner 和 PrintWriter

Java 标准库中提供的 Scanner 和 PrintWriter 类能够像文件中读取文本数据和写入文本数据。

231 Scanner

javautilScanner 类常用来从控制台中读取字符串和基本类型的数值。Scanner 可以将输入的值以空白字符分割标记。

Scanner 的构造方法：

构造方法 说明

Scanner(Readable source) 创建一个 Scanner，从指定的可读资源中扫描标记，包括文件、文件路径、字符串等。

Scanner(InputStream source) 创建一个 Scanner，从指定的字节输入流中扫把标记。

Scanner 常用方法：

方法 返回值类型 说明

hasNext() boolean 如果 Scanner 还要更多的数据可读取，则返回 true

next() String 从 Scanner 中读取下一个标记作为字符串返回

nextLine() String 从 Scanner 中读取一行，以换行符结束

close() void 关闭 Scanner

Systemin 为系统自带的标准输入流，该流是一直打开并准备提供输入数据。通常，这个流对应于键盘输入或由主机环境或用户指定的另一个输入源。

使用 Scanner 没有必要关闭输入文件，但是关闭能够释放文件占有的资源。

示例代码：

public class Demo3 {

public static void main(String[] args) {

try (Scanner scanner = new Scanner(new File("/testtxt"))) {

while (scannerhasNext()) {

String s = scannernext();

Systemoutprintln(s);

}

} catch (IOException e) {

eprintStackTrace();

}

}

}

登录后复制



232 PrintWriter

javaioPrintWriter 类可用来创建一个文件并向文本文件中写入数据。通常使用 Systemoutprintln 向控制台输入文本。

PrintWriter 构造方法：

构造方法 说明

PrintWriter(Writer out) 为指定的字符输入流创建一个 PrintWriter。

PrintWriter(Writer out, boolean autoFlush) 为指定的字符输入流创建一个 PrintWriter，如果 autoFlush 为 true，则 println、printf 或 format 方法将刷新输出缓冲区。

PrintWriter(OutputStream out) 为指定的字节输入流创建一个 PrintWriter。

PrintWriter(OutputStream out, boolean autoFlush) 为指定的字节输入流创建一个 PrintWriter，如果 autoFlush 为 true，则 println、printf 或 format 方法将刷新输出缓冲区。

PrintWriter(String fileName) 为指定的文件路径创建一个 PrintWriter

PrintWriter(String fileName, String csn) 为指定的文件路径创建一个 PrintWriter，并且通过指定的字符集对字符进行编码。

PrintWriter(File file) 为指定的文件对象创建一个 PrintWriter。

PrintWriter(File file, String scn) 为指定的文件对象创建一个 PrintWriter，并且通过指定的字符集对字符进行编码。

PrintWriter 常用方法：

方法 返回值类型 说明

print(String s) void 将字符串写入文件中

println(String s) void 将字符串写入文件中，多打印一个换行

printf(String s) void 将字符串写入文件中，按照指定格式写文件中

Systemout 为系统自带的 printStream，表示控制台的标准 Java 对象，通过它能够向控制台输入数据。

使用 PrintWriter 必须使用 close 方法关闭文件，或者使用 try-with-resources 自动关闭资源，狗则数据就不能正确地保存在文件中。

示例代码：

//java中使用文件输入流和文件输出流进行文件读写的用例！           

Java 

   package comtestio; 

import javaioFile; 

import javaioFileInputStream; 

import javaioFileNotFoundException; 

import javaioFileOutputStream; 

import javaioIOException; 

import javaioInputStream; 

import javaioOutputStream; 

/ 

   

  @author 亚当爱上java 

  用例内容：文件输入流和文件输入流结合用例，字节流方式 

 时间：2010-06-20 

  注意事项：文件输入流和文件输出流都是相对与内存来说的，例如通过程序读取文件时往内存输入数据就是文件输入流 

/ 

public class FileInputOrOutput { 

 public static void main(String[] args) { 

  // 文件或者路径名的抽象表现形式,意思就是说之后如果进行 *** 作的话就是全部在这个抽象路径名所指向的文件或者文件加中 

  File file = new File("e:/testtxt"); 

  File file2 = new File("e:/test1txt"); 

   

  // 文件字节数的个数 

  // Systemoutprintln(filelength()); 

  try { 

   /------------------------------------------读 *** 作部分-----------------------------------------------/ 

   //文件输入流对象 

   InputStream fis = new FileInputStream(file); 

   // 文件输入流对象所读取的字节数大小 

   // Systemoutprintln(fisavailable()); 

   / 

     1按照一个字节为单位进行读取数据,弊端是遇到中文就会把中文的汉字拆开从而出现乱码 

    / 

   // //流对象读出的返回值是每次所读到的一个字符所对应的ascii码值 

   // int i = fisread(); 

   //    

   // //如果已经读到文件尾则i==-1,此时终止循环 

   // while(i!=-1){ 

   // Systemoutprint((char)i); 

   // 保证每一次循环都继续往后读取一个字符，否则i的值不变会成为死循环 

   // i = fisread(); 

   // } 

   / 

     2按照一个字节数组所指定的大小为单位进行读取，每次最多可以读取数组定义的大小的字节个数 

    / 

   // 每次读取都以1K字节作为单位来进行 

   byte b[] = new byte[1024]; 

   // 流对象读出并返回的是每次读取字节的个数，最大每次读取自己数可以和数组blength相同 

   // b中存储了每次所读取的所有数据 

   int i = fisread(b); 

   String str = ""; 

   // 如果已经读到文件尾则i==-1,此时终止循环 

   while (i != -1) { 

    // 把每次读取的字节数组解码为字符串 

    // 参数1：要解码为字符的字节 

    // 参数2：要解码的首字符的索引 

    // 参数3：要解码的字节的个数,如果文件个数大于所设定的一次读取文件的大小时i的取值就是 

    // blength,否则小于数组的字节大小时则为实际的读取出自己数的大小 

    str = str + new String(b, 0, i); 

    // 保证每一次都往文件的下一部分进行读取，否则i值没有变化会成为死循环 

    i = fisread(b); 

   } 

   // Systemoutprint(str); 

   // 关闭输入流对象 

   fisclose(); 

   

   /------------------------------------------写 *** 作部分-----------------------------------------------/ 

   //文件输出流对象 

   OutputStream fos = new FileOutputStream(file2); 

    

   //str是从file所指定的文件中读出的所有内容，将此内容写入另一个文件中 

   //将字符解码为字节数组 

   byte b2[] = strgetBytes(); 

    

   //将解码后的字节数组，通过文件输出流对象写入到缓冲区中 

   foswrite(b); 

   //强制将缓冲区中的内容输出到文件中 

   fosflush(); 

   //关闭输出流对象 

   fosclose(); 

    

  } catch (FileNotFoundException e) { 

   // TODO Auto-generated catch block 

   eprintStackTrace(); 

  } catch (IOException e) { 

   // TODO Auto-generated catch block 

   eprintStackTrace(); 

  } 

 } 

}

安卓开发离不开手机存储，然而大部分人对于安卓开发中的存储概念存在误区，内部外部SD卡傻傻分不清？

以下引用来自对 官方文档 的理解

呵呵呵，先别说话，然而重点来了（敲黑板），按照官方的说法，

内部存储是指系统的存储空间，没有root是访问不到的呦亲，比如sharedPreferenced或者database都是保存在这里面的。

外部存储，又分为 2 部分：

然而现实中，常常有同事把手机那个32G，64G存储叫做内部存储= =，宝宝好累，人家明明是 ExternalStorage ！！

希望本篇能让大家对内外部存储有一个正确鲜明的认识

getFilesDir()

路径如下

文档 云:若想 *** 作该路径，你需要一个输出流：

就像这样:

注: this 是 context 对象

在

路径下会看到新文件哦

如果你还想读取的话， 文档 云:你需要一个输入流：

Log如下

getCacheDir()

文档 云:

路径如下：

特别的,还有getDir() ：

getDir("- -!txt", ContextMODE_PRIVATE)getAbsolutePath()

路径如下：

app_是系统自己加上去的

内部存储就是系统的存储，没有root你是看不到的，内部存储最大特点就是可以用Context对象调用各个获取路径的方法。比如： contextfileList()

那就是

下的文件遍历。

而 deleteFile("ABC") 就是

删除下名为 ABC 的文件

</br></br></br>

*** 作外部存储你首先需要以下权限

当你申请了write权限，那么read权限默认也就通过啦

再判断状态：

if (EnvironmentMEDIA_MOUNTEDequals(EnvironmentgetExternalStorageState))

EnvironmentgetExternalStorageDirectory()

这个路径根据手机厂家不同会有些许变化

直接传入 Environment 中的常量获取相应的路径，如下：

EnvironmentgetExternalStoragePublicDirectory(EnvironmentDIRECTORY_ALARMS));

或者

EnvironmentgetExternalStoragePublicDirectory(EnvironmentDIRECTORY_PICTURES));

公有目录下，系统会区分不同类别 （例如铃声在系统设置中显示为铃声而不是音乐）

44以后访问该目录不再需要权限了

getExternalFilesDir(String type)

eg

getExternalFilesDir(EnvironmentDIRECTORY_MUSIC)

特别的：ContextCompat下的

ContextCompatgetExternalFilesDirs(context,type)

返回一个File[]，在44以后第一条数据默认外部主存储目录，第二条数据就是sd卡路径啦，但是注意44之前是没有第二条数据的哦

该目录下的特点是卸载程序后，该目录和其下所有文件均会被删除

getExternalCacheDir()

注意，使用该目录注意管理空间，你不能等系统帮你清理，而是自己清理不再需要的缓存

特别的：ContextCompat下的

ContextCompatgetExternalCacheDirs()

道理同上

发现特点了吗朋友，无论外部内部，只有路径中有包名，那么就是私有的，而且是随着程序的卸载而被删除的， 有包名的路径均是Context中的方法，而公有的路径均是Environment调用的

这个货真真是要了老命，一般的方法根部不好使，结合网上有的方法加上公司项目中的方法，总结如下：

百分百好用的获取SD卡路径方法：

最后集合 path 中的值就是SD卡根目录

虽然无视版本百分百好用，但是如果你的手机有SD卡槽却没插SD卡，该方法最后 path 返回的是 null ，也就是说该方法无法判断到底是没插SD卡还是根本不支持SD卡

其实还有一种方法

String path = Systemgetenv("SECONDARY_STORAGE");

该方法只要你手机支持SD卡，无论你插没插SD卡，均会返回SD卡路径，但是 60及以上该方法被移除

Environment中源码其实就是根据这个方法获取路径的

安卓官方文档大家一定要看，他就是我们开发者的权威呀，圣经呀！！

感觉这样应该可以，

先从数据库里面获得

这个的绝对路径

然后

使用UIL类

URL

url=new

URL(file:///路径);

然后得到这个文件的输入流InputStream

in=urlopenStream();

然后得到此的位图Bitmap

bitmap=BitmapFactorydecodeStream(in);

ImageView

img=new

ImageView(this);

imgsetImageBitmap(bitmap);

从网络上的话是这样，但是手机上是不是这样就不清楚了你可以试一下。

那个应该是要放在手机上。

一、按数据来源（去向）分类：

1、是文件： FileInputStream, FileOutputStream, FileReader, FileWriter

2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream

3、是Char[]: CharArrayReader, CharArrayWriter

4、是String: StringBufferInputStream, StringReader, StringWriter

5、网络数据流：InputStream, OutputStream, Reader, Writer

二、按是否格式化输出分：

1、要格式化输出：PrintStream, PrintWriter

三、按是否要缓冲分：

1、要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter

四、按数据格式分：

1、二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream及其所有带Stream结束的子类

2、纯文本格式（含纯英文与汉字或其他编码方式）；Reader, Writer及其所有带Reader, Writer的子类

五、按输入输出分：

1、输入：Reader, InputStream类型的子类

2、输出：Writer, OutputStream类型的子类

六、特殊需要：

1、从Stream到Reader,Writer的转换类：InputStreamReader, OutputStreamWriter

2、对象输入输出：ObjectInputStream, ObjectOutputStream

3、进程间通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4、合并输入：SequenceInputStream

5、更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：

首先，考虑最原始的数据格式是什么： 原则四

第二，是输入还是输出：原则五

第三，是否需要转换流：原则六第1点

第四，数据来源（去向）是什么：原则一

第五，是否要缓冲：原则三 （特别注明：一定要注意的是readLine()是否有定义，有什么比read, write更特殊的输入或输出方法）

第六，是否要格式化输出：原则二

Java中Inputstream与Reader的区别

Reader支持16位的Unicode字符输出，InputStream支持8位的字符输出。

Reader和InputStream分别是I/O库提供的两套平行独立的等级机构，

InputStream、OutputStream是用来处理8位元的流，

Reader、Writer是用来处理16位元的流。

而在JAVA语言中，byte类型是8位的，char类型是16位的，所以在处理中文的时候需要用Reader和Writer。

值得说明的是，在这两种等级机构下，还有一道桥梁InputStreamReader、OutputStreamWriter负责进行InputStream到Reader的适配和由OutputStream到Writer的适配。

javaioReader 和 javaioInputStream 组成了 Java输入类。Reader 用于读入16位字符，也就是 Unicode编码的字符；而 InputStream 用于读入 ASCII字符和二进制数据。

在 Java中，有不同类型的 Reader 输入流对应于不同的数据源：

FileReader 用于从文件输入；

CharArrayReader 用于从程序中的字符数组输入；

StringReader 用于从程序中的字符串输入；

PipedReader 用于读取从另一个线程中的 PipedWriter 写入管道的数据。

相应的也有不同类型的 InputStream 输入流对应于不同的数据源：FileInputStream，ByteArrayInputStream，StringBufferInputStream，PipedInputStream。另外，还有两种没有对应 Reader 类型的 InputStream 输入流：

Socket 用于套接字；

URLConnection 用于 URL 连接。

这两个类使用 getInputStream() 来读取数据。

相应的，javaioWriter 和 javaioOutputStream 也有类似的区别。

以上就是关于编JAVA程序获取指定D盘下file.txt内容要求创建一个fis字节输入流对象一个buf字节组长度定义为1024整数倍全部的内容，包括:编JAVA程序获取指定D盘下file.txt内容要求创建一个fis字节输入流对象一个buf字节组长度定义为1024整数倍、java中,文件输入 *** 作由下面哪个、Java里那个输入流和输出流怎么用等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！