Java IO对文件的操作

InputStream.read()

返回int ，且范围为0到255间int值 ，从输入流读取下一个数据字节，它是以字节为单位来读的，即每次只读取一个字节内容 ，读取后面三前面补三个字节的0，这样读取出来的结果就永远为正，且为0到255间的数。如果因已到达流末尾而没有可用的字节，则返回值-1 。用于进制文件的读取。

如果我们读取的是二进制文件，如图片声音文件时，我们应该使用如下两种方式来读取：
第一种 ：
还是使用InputStream.read()，方法来读取，只不过我们把int型强制转换byte型即可，这样在转换的过程中，会丢弃前三个字节所补的
零，最终得到从流中读取的真实的编码。但如果这样直接通过read()方法读取，而不是通过read(byte[]
b)时，我们判断流是否结尾，最好使用available()方法来判断，当然也可以使用直接比较读出的结果是否为-1，但是要注意的是我们不能在读取后强转成byte型后再判断，因为二进制文件有可能有-1的编码。

第二种 ：使用InputStream.read(byte[] b)来接收，因为这样不会有byte到int提升的过程，byte数组b里存储的就是真实的编码。如果read(byte[] b)读取到流的尾，则返回-1，所以我们直接判断返回的读取子节数就可知道流是否结束。

OutputStream.write(int b)

将指定的字节写入此输出流。write 的规定是：向输出流写入一个字节。要写入的字节是参数b的八个低位。b 的24个高位将被忽略。此方法能向文件中写入负数编码，即可写入二进制流的文件，如声音、图片等文件。

我们再来看看Reader与Writer字符流相应方法：

Reader.read

Reader.read：读取单个字符。在有可用字符、发生 I/O
错误或者已到达流的末尾前，此方法一直阻塞。范围在 0 到 65535 之间
(0x00-0xffff)，实质上读取出来的就是一个char型，即为Unicode编码了。如果已到达流的末尾，则返回 -1

Writer. write(int c)

Writer. write(int c)：写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。

从上面可以看出是两类字符流，一种是字节流，另一种是字符流，如果我们读取/写
入的是一个二进制文件，则使用字节流InputStream.read/OutputStream.write；如果我们读取/写入的是一个字符文件，则
使用字符流Reader.read/Writer.write会很方便，当然字符流也可以使用字节流来操作，只是在某些情况下不是很方便。

Java代码  

    1. import java.io.File;
    2. import java.io.FileInputStream;
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6. import junit.framework.TestCase;
    7. public class TestBinaryStreamReadWrite extends TestCase {
    8. /*
    9. * 写二进制文件（如声音文件）时，只能使用字节流写。outputStream.write方法 只写入最低八位，
    10. * 前三字节会丢弃掉，只存储最后一字节
    11. */
    12. public void testCreateByteFile() {
    13. try {
    14. FileOutputStream fo = new FileOutputStream("e:/tmp/tmp");
    15. byte b = -1;
    16. //向文件写两个-1，没有编码为-1的字符，所以创建出的文件为纯二进制文件
    17. fo.write(b);
    18. fo.write(b);
    19. fo.close();
    20. } catch (FileNotFoundException e) {
    21. e.printStackTrace();
    22. } catch (IOException e) {
    23. e.printStackTrace();
    24. }
    25. }
    26. /*
    27. * InputStream.read方式是读取一个字节内容后，以int型返回，在这之间有一个转换的过程：当读
    28. * 取一个字节内容后，会在这八位二进制前再补24位二进制的0，所以最后返回的字节编码为正数，永不
    29. * 会为负数，且范围为0-255间的整数。这样如果使用read方法读取二进制文件时，读出的编码是整数，
    30. * 原本可能为负编码，最终显示成了正编码。为了确保得到正确的原本二进制编码，在读取后只能强制转
    31. * 换成byte型，或使用read(byte b)方式来读取。
    32. */
    33. public void testReadEncodeError() {
    34. try {
    35. FileInputStream fi = new FileInputStream("e:/tmp/tmp");
    36. //read方ifc读取的一个字节内容，返回0到255范围内的int字节值，如果因已到达流
    37. //末尾而没有可用的字节，则返回值-1
    38. int readInt = fi.read();
    39. //如果已到达文件末尾，则返回-1。虽然的文件中的每个字节的内容都是-1，但读出来的不是-1，
    40. //所以第二个字节也能输出，而不会出现只能读取第一个字节，第二个字节读不出的问题
    41. while (readInt != -1) {
    42. //输入两个255，但输入的编码是错误的，应该为-1才对
    43. System.out.println(readInt);
    44. //读下一字节
    45. readInt = fi.read();
    46. }
    47. fi.close();
    48. } catch (FileNotFoundException e) {
    49. e.printStackTrace();
    50. } catch (IOException e) {
    51. e.printStackTrace();
    52. }
    53. }
    54. /*
    55. * 使用InputStream.read读取出的编码如果经过强转换byte型后，我们就不能再使用 readByte
    56. * != -1 来判断文件流是否结束了，因为如果为二进制文件，读出的编码就有 为负的，总之，如果读取
    57. * 的是二进制文件，就不能直接使用真实编码与-1比较，只能使用available或通InputStream.read
    58. * (byte[] b)方法返回的所读字节数来判断
    59. */
    60. public void testAvailable() {
    61. try {
    62. File file =  new File("e:/tmp/tmp");
    63. FileInputStream fi = new FileInputStream(file);
    64. System.out.println("available实质上与file的length相同：" +file.length());
    65. //当使用read方法读取出的编码后经强转byte后，不能使用 (byte) fi.read() ！= -1 来
    66. //判断是文件流是否结束，这里我们只能使用available来判断是否达文件尾
    67. while (fi.available() > 0) {
    68. System.out.println("available=" + fi.available());
    69. //使用read()方法读取字节内容的编码后，只能强转byte型才能得到真实的编码
    70. System.out.println((byte) fi.read());
    71. }
    72. fi.close();
    73. } catch (FileNotFoundException e) {
    74. e.printStackTrace();
    75. } catch (IOException e) {
    76. e.printStackTrace();
    77. }
    78. }
    79. /*
    80. * 读取二进制文件（如图片）而非字符文件时，除了使用read()读取强转byte型，使用 InputStream.
    81. * read(byte[] b)是最好的方式，此时使用读取返回的字节数来判断是否读完
    82. */
    83. public void testReadByByteArr() {
    84. try {
    85. FileInputStream fi = new FileInputStream("e:/tmp/tmp");
    86. byte[] byteArr = new byte[1024];
    87. //读取的字节数
    88. int readCount = fi.read(byteArr);
    89. //如果已到达文件末尾，则返回-1
    90. while (readCount != -1) {
    91. for (int i = 0; i < readCount; i++) {
    92. System.out.println(byteArr[i]);
    93. }
    94. readCount = fi.read(byteArr);
    95. }
    96. fi.close();
    97. } catch (FileNotFoundException e) {
    98. e.printStackTrace();
    99. } catch (IOException e) {
    100. e.printStackTrace();
    101. }
    102. }
    103. /*
    104. * 使用InputStream.read读取二进制文件强转换byte型获取真实编码后，不能使用readByte !=
    105. * -1 来判断是否到文件尾
    106. */
    107. public void testGetBytecodeByConvernt() {
    108. try {
    109. FileInputStream fi = new FileInputStream("e:/tmp/tmp");
    110. //读取的一个字节内容，强制转byte型，得到真实的编码
    111. byte readByte = (byte) fi.read();
    112. //这里我们不能使用如下方式来判断是否读流结束，因为编码内容本身就是-1，所以不会输出任何内容
    113. while (readByte != -1) {
    114. System.out.println((byte) readByte);
    115. readByte = (byte) fi.read();
    116. }
    117. fi.close();
    118. } catch (FileNotFoundException e) {
    119. e.printStackTrace();
    120. } catch (IOException e) {
    121. e.printStackTrace();
    122. }
    123. }
    124. }
时间： 2024-12-18 22:57:20

Java IO对文件的操作的相关文章

java IO流文件的读写具体实例(转载)

引言: 关于java IO流的操作是非常常见的,基本上每个项目都会用到,每次遇到都是去网上找一找就行了,屡试不爽.上次突然一个同事问了我java文件的读取,我一下子就懵了第一反应就是去网上找,虽然也能找到,但自己总感觉不是很踏实,所以今天就抽空看了看java IO流的一些操作,感觉还是很有收获的,顺便总结些资料,方便以后进一步的学习... IO流的分类:1.根据流的数据对象来分:高端流:所有的内存中的流都是高端流,比如:InputStreamReader  低端流:所有的外界设备中的流都是低端流

java io 读取文件乱码及读取不出来的问题

import java.io.BufferedReader; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class TestFileWriter { public static void main(String [] args) { try { FileReader out = new FileReader("d:/a.txt"); BufferedR

java(IO)读写文件乱码转换UTF-8问题

java(IO)读写文件乱码转换UTF-8问题 读取文件 String?Content?=?"";?//?文件很长的话建议使用StringBuffer try?{ FileInputStream fs=new FileInputStream("文件录取"); InputStreamReader?isr?=?new?InputStreamReader(fis,?"UTF-8"); BufferedReader?br?=?new?BufferedRe

java IO流 ---文件的读写操作

1 package com.io; 2 import java.io.File; 3 import java.io.FileInputStream; 4 import java.io.FileOutputStream; 5 import java.io.FileNotFoundException; 6 import java.io.IOException; 7 public class Test2 { 8 9 /** 10 * @param args 11 * @throws IOExcepti

Java IO流 之 File 操作文件夹

http://www.verejava.com/?id=17160027381247 import java.io.File; public class Test { public static void main(String[] args) { // File dir=File(String pathname) //即表示文件 又表示目录 File dir=new File("dir2/test"); // boolean mkdir() //创建一个 一级目录 dir.mkdir

Java对Jar文件的操作[转]

原文地址:http://www.cnblogs.com/mailingfeng/archive/2012/04/24/2122160.html 一些文件路径补充知识: URI uri = new URI("file:/D:/workspace-home/JavaDemo/conf/"); File dirFile = new File(uri);  String dirPath = System.getProperty("user.dir") + "\\c

【Android】数据存储-java IO流文件存储

1.数据持久化:将在内存中的瞬时数据保存在存储设备中.瞬时数据:设备关机数据丢失.持久化技术提供一种机制可以让数据在瞬时状态和持久状态之间转换. 2.Android中简单的三种存储方式:文件存储.SharedPreference 存储以及数据库存储. 1.文件存储 :不对数据作任何处理,将数据原封不动地存储到文件中,适合存储一些简单的文本数据和二进制数据. a.将数据存储到文件中 Context类提供了一个openFileOutput()方法,可以用于将数据存储到文件中.这个方法接收两个参数,第

Java实现Excel文件读写操作

写操作: package com.zhao.poi; import java.io.File;import java.io.FileOutputStream;import java.io.IOException; import org.apache.commons.io.FileUtils;import org.apache.poi.hssf.usermodel.HSSFCell;import org.apache.poi.hssf.usermodel.HSSFCellStyle;import

java常用的文件读写操作

现在算算已经做java开发两年了,回过头想想还真是挺不容易的,java的东西是比较复杂但是如果基础功扎实的话能力的提升就很快,这次特别整理了点有关文件操作的常用代码和大家分享 1.文件的读取(普通方式) (1)第一种方法 [java] view plain copy File f=new File("d:"+File.separator+"test.txt"); InputStream in=new FileInputStream(f); byte[] b=new