javaIO流、File文件知识总结

最新推荐文章于 2022-08-27 11:35:41 发布

王玉见

最新推荐文章于 2022-08-27 11:35:41 发布

阅读量518

点赞数

分类专栏： java 文章标签： java io流字节流字符流

本文链接：https://blog.csdn.net/Yujan_2015/article/details/78694830

版权

java 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

JAVA流

流

定义：一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。

本质是数据传输。

作用：数据在设备间进行传递。

分类：按流向不同输入流（in）/ 输出流（out）

按处理数据类型字节流（byte） / 字符流

	定义	处理对象	使用
字节流	按照字节（8byte）为单位，读取数据，可能会乱码，没有缓冲区，直接输入，字节流不调用colse()方法时，信息已经输出了，	所有类型的数据	图片，音频视频优先考虑
字符流	字符流是基于字节流读取时，查了指定的码表，一次可以读取多个字节，效率高，不会乱码，有缓冲区，而字符流只有在调用 close() 方法关闭缓冲区时，信息才出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。	只能处理字符类型的数据	纯文本优先考虑

关于字符流和字节流的区别可以参照 http://blog.csdn.net/qq_25184739/article/details/51203733

输入流（inputstrem） read（）：file---->程序

程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道

输出流（outputstream） writer（）：程序---->file

程序向输出流写入数据。将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道。

举例：复制文件text1.txt中的内容到text2.txt

先从file中读取到程序byte[]中，再把byte[]写到指定file中

IO流结构图

通过上图我们可以发现：

1.流式部分： IO的主体部分；

2.非流式部分：主要包含一些辅助流式部分的类，如：File类、RandomAccessFile类和FileDescriptor等类；

3.其他类：文件读取部分的与安全相关的类，如：SerializablePermission类，以及与本地操作系统相关的文件系统的类，如：FileSystem类和Win32FileSystem类和WinNTFileSystem类。

4.File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。

5.InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。

6.OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

4. Reader（文件格式操作）：抽象类，基于字符的输入操作。

5. Writer（文件格式操作）：抽象类，基于字符的输出操作。

6. RandomAccessFile（随机文件操作）：它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。

常用的类

InputStream

主要的子类：

InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。继承自InputStream 的流都是向程序中输入数据的，且数据单位为字节（bit）；

InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.

Inputstream类中的常用方法：
　　（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。
　　（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的
　　（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。
　　（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用，
　　（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取
　　（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.

1） FileInputStream把一个文件作为InputStream，实现对文件的读取操作
　　 2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
　　 3） StringBufferInputStream：把一个String对象作为InputStream
　　 4） PipedInputStream：实现了pipe的概念，主要在线程中使用
　　 5） SequenceInputStream：把多个InputStream合并为一个InputStream

outputstream

主要的子类：

OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。
　　1. public void write(byte b[ ])：将参数b中的字节写到输出流。
　　2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。
　　3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。
　　4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。
　　5. public void close( ) : 关闭输出流并释放与流相关的系统资源。

1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream

流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。

FileInputStream

用于读取本地文件中的字节数据，继承InputStream类

创建输入流对象的方式：

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

 
     InputStreamf =newFileInputStream("C:/java/hello"); 
    

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

 
     Filef =newFile("C:/java/hello"); 
    
     InputStreamout =newFileInputStream(f);

构造方法摘要
`FileInputStream(File file)` 通过打开一个到实际文件的连接来创建一个`FileInputStream`，该文件通过文件系统中的 `File` 对象 `file` 指定。
`FileInputStream(FileDescriptor fdObj)` 通过使用文件描述符 `fdObj` 创建一个`FileInputStream`，该文件描述符表示到文件系统中某个实际文件的现有连接。
`FileInputStream(String name)` 通过打开一个到实际文件的连接来创建一个`FileInputStream`，该文件通过文件系统中的路径名 `name` 指定。

方法摘要
`int`	`available()` 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
`void`	`close()` 关闭此文件输入流并释放与此流有关的所有系统资源。
`protected void`	`finalize()` 确保在不再引用文件输入流时调用其`close` 方法。
`FileChannel`	`getChannel()` 返回与此文件输入流有关的唯一`FileChannel` 对象。
`FileDescriptor`	`getFD()` 返回表示到文件系统中实际文件的连接的 `FileDescriptor` 对象，该文件系统正被此`FileInputStream` 使用。
`int`	`read()` 从此输入流中读取一个数据字节。
`int`	`read(byte[] b)` 从此输入流中将最多 `b.length` 个字节的数据读入一个 byte 数组中。
`int`	`read(byte[] b, int off, int len)` 从此输入流中将最多 `len` 个字节的数据读入一个 byte 数组中。
`long`	`skip(long n)` 从输入流中跳过并丢弃 `n` 个字节的数据。

其中read()返回的是读入的一个字节所对应的int值(0-255),而read(byte[] b)和read(byte[] b, int off, int len) 返回的是读入的字节数

FileOutputStream

FileOutputStream用于将字节数据写出到文件。继承自OutputStream类

创建输出流对象的方式：

使用字符串类型的文件名来创建一个输出流对象：

 
     OutputStreamf =newFileOutputStream("C:/java/hello") 
    

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

 
     Filef =newFile("C:/java/hello"); 
    
     OutputStreamf =newFileOutputStream(f);

构造方法摘要
`FileOutputStream(File file)` 创建一个向指定 `File` 对象表示的文件中写入数据的文件输出流。
`FileOutputStream(File file, boolean append)` 创建一个向指定 `File` 对象表示的文件中写入数据的文件输出流。
`FileOutputStream(FileDescriptor fdObj)` 创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。
`FileOutputStream(String name)` 创建一个向具有指定名称的文件中写入数据的输出文件流。
`FileOutputStream(String name, boolean append)` 创建一个向具有指定 `name` 的文件中写入数据的输出文件流。

方法摘要
`void`	`close()` 关闭此文件输出流并释放与此流有关的所有系统资源。
`protected void`	`finalize()` 清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 `close` 方法。
`FileChannel`	`getChannel()` 返回与此文件输出流有关的唯一`FileChannel` 对象。
`FileDescriptor`	`getFD()` 返回与此流有关的文件描述符。
`void`	`write(byte[] b)` 将 `b.length` 个字节从指定 byte 数组写入此文件输出流中。
`void`	`write(byte[] b, int off, int len)` 将指定 byte 数组中从偏移量 `off` 开始的 `len` 个字节写入此文件输出流。
`void`	`write(int b)` 将指定字节写入此文件输出流。

举例：复制文件A.txt到指定文件B.txt中

/**
 * 复制文件内容到指定文件(FileInputStream/FileOutPutStream)
 *
 * @param file1 源文件
 * @param file2 目标文件
 */
public static void copyFileToFile(String file1, String file2) {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    File _file1 = new File(file1);
    File _file2 = new File(file2);
    if (_file1.exists() && _file1.isFile() && _file2.exists() && _file2.isFile()) {
        try {
            fis = new FileInputStream(_file1);
            fos = new FileOutputStream(_file2);
            byte[] bytes = new byte[1024];
            int lg = 0;
            while ((lg = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, lg);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileWriter

构造方法：

注：append为true 表示在filewriter对文件再次写入时，会在该文件的结尾续写，并不会覆盖掉。

主要的方法：

write(String str) //写入字符串。当执行完此方法后，字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。

viod flush() //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。

viod close() //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后，再写入或者刷新的话，会抛IOException异常。

/**
* FileWriter 字符文件输入流通过此IO流向指定file添加字符串内容
*
* @param path 文件的绝对路径
*/
public static void fileWriterToFile(String path) {
String content = "Are you ok!hao are your?";
if (!TextUtils.isEmpty(path)) {
File file = new File(path);
if (file.exists() && file.isFile()) {
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(file, true);
// fileWriter.append(content);//通过追加字符串
fileWriter.write(content.toCharArray(), 0, content.getBytes().length);//通过字节数组写入
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileWriter != null) {
try {
fileWriter.flush();
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}

FileRead

构造器

主要方法

int read(); // 读取单个字符。返回作为整数读取的字符，如果已达到流末尾，则返回 -1。

int read(char []cbuf);//将字符读入数组。返回读取的字符数。如果已经到达尾部，则返回-1。

void close();//关闭此流对象。释放与之关联的所有资源。

通过字符流FileRead/FileWriter拷贝文件内容

/**
 * FileWriter/FileRead 拷贝文件内容(FileRead/FileWriter)
 *
 * @param path1 源文件的绝对路径
 * @param path2 目标文件的绝对路径
 */
public static void copyFileToFile1(String path1, String path2) {
    File file1 = new File(path1);
    File file2 = new File(path2);
    if (file1.exists() && file1.isFile() && file2.exists() && file2.isFile()) {
        FileWriter fileWriter = null;
        FileReader fileReader = null;
        try {
            fileReader = new FileReader(file1);
            fileWriter = new FileWriter(file2);
            char[] bytes = new char[1024];
            int index;
            while ((index = fileReader.read(bytes)) != -1) {
                fileWriter.write(bytes, 0, index);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null) {
                try {
                    fileReader.close();
                    fileWriter.flush();
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

ByteArrayInputStream

字节数组输入流在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中。

接收字节数组作为参数创建：

ByteArrayInputStream bArray = new ByteArrayInputStream(byte [] a);

另一种创建方式是接收一个字节数组，和两个整形变量 off、len，off表示第一个读取的字节，len表示读取字节的长度。

ByteArrayInputStream bArray = new ByteArrayInputStream(byte []a, 
                                                       int off, 
                                                       int len)

成功创建字节数组输入流对象后，可以参见以下列表中的方法，对流进行读操作或其他操作。

序号	方法描述
1	public int read() 从此输入流中读取下一个数据字节。
2	public int read(byte[] r, int off, int len) 将最多 `len` 个数据字节从此输入流读入字节数组。
3	public int available() 返回可不发生阻塞地从此输入流读取的字节数。
4	public void mark(int read) 设置流中的当前标记位置。
5	public long skip(long n) 从此输入流中跳过 `n` 个输入字节。

ByteArrayOutputStream

字节数组输出流在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组缓冲区中。创建字节数组输出流对象有以下几种方式。

下面的构造方法创建一个32字节（默认大小）的缓冲区。

OutputStream bOut = new ByteArrayOutputStream();

另一个构造方法创建一个大小为n字节的缓冲区。

OutputStream bOut = new ByteArrayOutputStream(int a)

成功创建字节数组输出流对象后，可以参见以下列表中的方法，对流进行写操作或其他操作。

序号	方法描述
1	public void reset() 将此字节数组输出流的 `count` 字段重置为零，从而丢弃输出流中目前已累积的所有数据输出。
2	public byte[] toByteArray() 创建一个新分配的字节数组。数组的大小和当前输出流的大小，内容是当前输出流的拷贝。
3	public String toString() 将缓冲区的内容转换为字符串，根据平台的默认字符编码将字节转换成字符。
4	public void write(int w) 将指定的字节写入此字节数组输出流。
5	public void write(byte []b, int off, int len) 将指定字节数组中从偏移量 `off` 开始的 `len` 个字节写入此字节数组输出流。
6	public void writeTo(OutputStream outSt) 将此字节数组输出流的全部内容写入到指定的输出流参数中。

从文件中读取二进制数据，全部存储到ByteArrayOutputStream中。

FileInputStream fis=new FileInputStream("test");

BufferedInputStream bis=new BufferedInputStream(fis);

ByteArrayOutputStream baos=new ByteArrayOutputStream();

int c=bis.read();//读取bis流中的下一个字节

while(c!=-1){

baos.write(c);

c=bis.read();

}

bis.close();

byte retArr[]=baos.toByteArray();

注：用来缓存大量字节数据，且关闭流后，缓存的流依然存在

CharArrayReader

字符数组输入流

CharArrayWriter

字符数组输出流

File类

/* 对文件的增删改查 */
// 假设随便设置一个路径
File file = new File("D:/java.txt");
// 创建文件
file.createNewFile();// 不存在就创建，存在的话就不创建
// 查看文件是否存在
if (file.exists()) {
System.out.println("文件存在");
} else {
System.out.println("文件不存在");
}
// 修改文件的名字
file.renameTo(new File("D:/java2.txt"));
// 删除文件
file.delete();// 如果存在就会被删除
//对文件夹的基本操作
//随意定义一个文件路径
File file2 = new File("D:/java/jsp");
//增加文件夹
file2.mkdirs();//可以创建多层的文件夹路径，而mkdir只能创建一层文件夹
// 文件夹的修改名字和删除和文件的操作基本一样，但是要确保空文件夹才能删除，否则不能
/* 以下是File的其他常用操作 */
//判断一个File文件是文件还是文件夹
if (file.isDirectory()) {
System.out.println(file.getName() + "是个文件夹");
} else if (file.isFile()) {
System.out.println(file.getName() + "是个文件" + "文件大小:"+ file.length());
}
// getName获得文件名,只获得文件名，不包括文件的路径
System.out.println("file name:" + file.getName());
// getPath获得文件文件路径，包括文件名字
System.out.println("file path:" + file.getPath());
// getAbsolutePath获得文件文件路径，包括文件名字
System.out.println("file getAbsolutePath:" + file.getAbsolutePath());
// listFiles列出当前目录下的文件和子目录
String path = "D:/";
File[] files = new File(path).listFiles();
for (File file3 : files) {
// 打印D盘里面的所有文件和文件夹的名称
System.out.println("D:\\"+file3.getName() );
}
// renameTo重命名文件或剪切文件：在同一个目录下表示重命名，否则表示剪切文件
File f = new File("C:/java.txt2");
System.out.println(file.renameTo(f));//剪切成功输出true，否则输出false

参考文章：http://blog.csdn.net/ghost_programmer/article/details/43154185

http://blog.csdn.net/qq_25184739/article/details/51205186

王玉见

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
javaIO流、File文件知识总结

JAVA流流定义：一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。本质是数据传输。作用：数据在设备间进行传递。分类：按流向不同输入流（in）/ 输出流（out）按处理数据类型字节流（byte） / 字符流定义处理对象使
复制链接

扫一扫