IO基础（1）-File,IO流用法

最新推荐文章于 2022-04-20 15:29:31 发布
最新推荐文章于 2022-04-20 15:29:31 发布
阅读量268 收藏
点赞数
分类专栏： IO 文章标签： java IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w372426096/article/details/78210220
版权

一、主要内容

  • java.io.File类的使用
  • IO 原理及 流的 分类
  • 文件 流
    FileInputStream   /  FileOutputStream   /  FileReader   /  FileWriter
  • 缓冲流
    BufferedInputStream / BufferedOutputStream /
    BufferedReader / BufferedWriter
  • 转换流
    InputStreamReader  /  OutputStreamWriter
  • 标准输入 / 输出流
  • 打印流
    PrintStream  /  PrintWriter
  • 数据流
    DataInputStream  /  DataOutputStream
  • 对象流    ---- 涉及序列化、反序列化
    ObjectInputStream  /  ObjectOutputStream
  • 随机存取文件流
    RandomAccessFile
二、File 类 

import java.io.File;
import java.io.IOException;
import java.util.Date;

import org.junit.Test;

/*
 * java.io.File类
 * 1.凡是与输入、输出相关的类、接口等都定义在java.io包下
 * 2.File是一个类，可以有构造器创建其对象。此对象对应着一个文件（.txt .avi .doc .ppt .mp3 .jpg）或文件目录
 * 3.File类对象是与平台无关的。
 * 4.File中的方法，仅涉及到如何创建、删除、重命名等等。只要涉及文件内容的，File是无能为力的，必须由io流来完成。
 * 5.File类的对象常作为io流的具体类的构造器的形参。
 */
public class TestFile {
	/*
	 *  createNewFile()
		delete()
		mkDir():创建一个文件目录。只有在上层文件目录存在的情况下，才能返回true
		mkDirs():创建一个文件目录。若上层文件目录不存在，一并创建
		list()
		listFiles()
	 */
	@Test
	public void test3() throws IOException{
		File file1 = new File("d:/io/helloworld.txt");
		System.out.println(file1.delete());
		
		if(!file1.exists()){
			boolean b = file1.createNewFile();
			System.out.println(b);
		}
		
		File file2 = new File("d:\\io1\\io2");
		if(!file2.exists()){
			boolean b = file2.mkdirs();
			System.out.println(b);
		}
		
		File file3 = new File("d:\\teach");
		String[] strs = file3.list();
		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
		
		System.out.println();
		
		File[] files = file3.listFiles();
		for(int i = 0;i < files.length;i++){
			System.out.println(files[i].getName());
		}
	}
	
	/*
	 *  exists()
		canWrite()
		canRead()
		isFile()
		isDirectory()
		lastModified()
		length()

	 */
	@Test
	public void test2(){
		File file1 = new File("d:/io/helloworld.txt");
		File file2 = new File("d:\\io\\io1");
		
		System.out.println(file1.exists());
		System.out.println(file1.canWrite());
		System.out.println(file1.canRead());
		System.out.println(file1.isFile());
		System.out.println(file1.isDirectory());
		System.out.println(new Date(file1.lastModified()));
		System.out.println(file1.length());
		
		System.out.println();
		
		System.out.println(file2.exists());
		System.out.println(file2.canWrite());
		System.out.println(file2.canRead());
		System.out.println(file2.isFile());
		System.out.println(file2.isDirectory());
		System.out.println(new Date(file2.lastModified()));
		System.out.println(file2.length());
	
	}
	
	/*
	 * 路径：
	 * 绝对路径：包括盘符在内的完整的文件路径
	 * 相对路径：在当前文件目录下的文件的路径
	 * 
	 *  getName()
		getPath()
		getAbsoluteFile()
		getAbsolutePath()
		getParent()
		renameTo(File newName)

	 */
	@Test
	public void test1(){
		File file1 = new File("d:/io/helloworld.txt");
		File file2 = new File("hello1.txt");
		
		File file3 = new File("d:\\io\\io1");
		File file4 = new File("d:\\io2");
		
		System.out.println(file1.getName());
		System.out.println(file1.getPath());
		System.out.println(file1.getAbsoluteFile());
		System.out.println(file1.getParent());
		System.out.println(file1.getAbsolutePath());
		
		System.out.println();
		
		System.out.println(file3.getName());
		System.out.println(file3.getPath());
		System.out.println(file3.getAbsoluteFile());
		System.out.println(file3.getParent());
		System.out.println(file3.getAbsolutePath());
		
		//renameTo(File newName):重命名
		//file1.renameTo(file2):file1重命名为file2.要求：file1文件一定存在，file2一定不存在
		boolean b = file1.renameTo(file2);
		System.out.println(b);
		
		boolean b1 = file4.renameTo(file3);
		System.out.println(b1);
	}
}
三、IO
Java IO 原理

输入 input ： 读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中 。
输出 output ： 将程序（内存）数据输出到磁盘、光盘等存储设备 中
流的分类

按操作数据单位不同分为：字节流(8bit)，字符流(16bit) 
按数据流的流向不同分为：输入流，输出流
按流的角色的不同分为：节点流，处理流

(抽象基类)

字节流

字符流

输入流

InputStream

Reader

输出流

OutputStream

Writer

1. Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。
2. 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀 。
IO流体系 

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import org.junit.Test;

/*
 * 1.流的分类：
 * 按照数据流向的不同：输入流  输出流
 * 按照处理数据的单位的不同：字节流  字符流（处理的文本文件）
 * 按照角色的不同：节点流（直接作用于文件的）  处理流
 * 
 * 2.IO的体系
 * 抽象基类			节点流（文件流）                                缓冲流（处理流的一种）
 * InputStream		FileInputStream			BufferedInputStream
 * OutputStream		FileOutputStream		BufferedOutputStream
 * Reader			FileReader				BufferedReader
 * Writer			FileWriter				BufferedWriter
 */
public class TestFileInputOutputStream {
	@Test
	public void testCopyFile(){
		long start = System.currentTimeMillis();
//		String src = "C:\\Users\\shkstart\\Desktop\\1.avi";
//		String dest = "C:\\Users\\shkstart\\Desktop\\2.avi";
		String src = "dbcp.txt";
		String dest = "dbcp2.txt";
		copyFile(src,dest);
		long end = System.currentTimeMillis();
		System.out.println("花费的时间为：" + (end - start));//3198
	}
	
	// 实现文件复制的方法
	public void copyFile(String src, String dest) {
		// 1.提供读入、写出的文件
		File file1 = new File(src);
		File file2 = new File(dest);
		// 2.提供相应的流
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream(file1);
			fos = new FileOutputStream(file2);
			// 3.实现文件的复制
			byte[] b = new byte[1024];
			int len;
			while ((len = fis.read(b)) != -1) {
				// fos.write(b);//错误的写法两种： fos.write(b,0,b.length);
				fos.write(b, 0, len);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

		}
	}

	// 从硬盘读取一个文件，并写入到另一个位置。（相当于文件的复制）
	@Test
	public void testFileInputOutputStream() {
		// 1.提供读入、写出的文件
		File file1 = new File("C:\\Users\\shkstart\\Desktop\\1.jpg");
		File file2 = new File("C:\\Users\\shkstart\\Desktop\\2.jpg");
		// 2.提供相应的流
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream(file1);
			fos = new FileOutputStream(file2);
			// 3.实现文件的复制
			byte[] b = new byte[20];
			int len;
			while ((len = fis.read(b)) != -1) {
				// fos.write(b);//错误的写法两种： fos.write(b,0,b.length);
				fos.write(b, 0, len);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

		}
	}

	// FileOutputStream
	@Test
	public void testFileOutputStream() {
		// 1.创建一个File对象，表明要写入的文件位置。
		// 输出的物理文件可以不存在，当执行过程中，若不存在，会自动的创建。若存在，会将原有的文件覆盖
		File file = new File("hello2.txt");
		// 2.创建一个FileOutputStream的对象，将file的对象作为形参传递给FileOutputStream的构造器中
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(file);
			// 3.写入的操作
			fos.write(new String("I love China！").getBytes());
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 4.关闭输出流
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	@Test
	public void testFileInputStream3() { // abcdefgcde
		FileInputStream fis = null;
		try {
			File file = new File("hello.txt");
			fis = new FileInputStream(file);
			byte[] b = new byte[5];// 读取到的数据要写入的数组。
			int len;// 每次读入到byte中的字节的长度
			while ((len = fis.read(b)) != -1) {
				// for (int i = 0; i < len; i++) {
				// System.out.print((char) b[i]);
				// }
				String str = new String(b, 0, len);
				System.out.print(str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}

		}
	}

	// 使用try-catch的方式处理如下的异常更合理:保证流的关闭操作一定可以执行
	@Test
	public void testFileInputStream2() {
		// 2.创建一个FileInputStream类的对象
		FileInputStream fis = null;
		try {
			// 1.创建一个File类的对象。
			File file = new File("hello.txt");
			fis = new FileInputStream(file);
			// 3.调用FileInputStream的方法，实现file文件的读取。
			int b;
			while ((b = fis.read()) != -1) {
				System.out.print((char) b);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 4.关闭相应的流
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	// 从硬盘存在的一个文件中，读取其内容到程序中。使用FileInputStream
	// 要读取的文件一定要存在。否则抛FileNotFoundException
	@Test
	public void testFileInputStream1() throws Exception {
		// 1.创建一个File类的对象。
		File file = new File("hello.txt");
		// 2.创建一个FileInputStream类的对象
		FileInputStream fis = new FileInputStream(file);
		// 3.调用FileInputStream的方法，实现file文件的读取。
		/*
		 * read():读取文件的一个字节。当执行到文件结尾时，返回-1
		 */
		// int b = fis.read();
		// while(b != -1){
		// System.out.print((char)b);
		// b = fis.read();
		// }
		int b;
		while ((b = fis.read()) != -1) {
			System.out.print((char) b);
		}
		// 4.关闭相应的流
		fis.close();
	}
}
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import org.junit.Test;

/*
 * 使用FileReader、FileWriter 可以实现文本文件的复制。
 * 对于非文本文件（视频文件、音频文件、图片），只能使用字节流！
 */
public class TestFileReaderWriter {
	@Test
	public void testFileReaderWriter(){
		//1.输入流对应的文件src一定要存在，否则抛异常。输出流对应的文件dest可以不存在，执行过程中会自动创建
		FileReader fr = null;
		FileWriter fw = null;
		try{
			//不能实现非文本文件的复制
//			File src = new File("C:\\Users\\shkstart\\Desktop\\1.jpg");
//			File dest = new File("C:\\Users\\shkstart\\Desktop\\3.jpg");
			File src = new File("dbcp.txt");
			File dest = new File("dbcp1.txt");
			//2.
			fr = new FileReader(src);
			fw = new FileWriter(dest);
			//3.
			char[] c = new char[24];
			int len;
			while((len = fr.read(c)) != -1){
				fw.write(c, 0, len);
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			if(fw != null){
				try {
					fw.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(fr != null){
				try {
					fr.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public void testFileReader(){
		FileReader fr = null;
		try {
			File file = new File("dbcp.txt");
			fr = new FileReader(file);
			char[] c = new char[24];
			int len;
			while((len = fr.read(c)) != -1){
				String str = new String(c, 0, len);
				System.out.print(str);
			}
		}catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			if(fr != null){
				try {
					fr.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();

Franco蜡笔小强
关注
专栏目录
File IO
YYTSWD的博客
04-22 338
File I/O 一、操作文件或目录的属性 程序的主要任务就是操作数据，通过允许程序读取文件的内容或向文件写入数据，可以使程序应用更为广泛。 1、使用File类操作文件或目录属性 java.io包提供了一些接口和类，对文件进行基本的操作，包括对文件和目录属性的操作、对文件读写的操作等 File对象既可表示文件，也可表示目录。在程序中，一个File对象可以代表一个或目录。利用它可用来对文件或目录进行...
IO流之File详细用法
qq_21198501的博客
08-14 458
IO流之File的详细用法
Java IO1：IO和File
weixin_34186128的博客
10-17 101
IO 大多数的应用程序都要与外部设备进行数据交换，最常见的外部设备包含磁盘和网络。IO就是指应用程序对这些设备的数据输入与输出，Java语言定义了许多类专门负责各种方式的输入、输出，这些类都被放在java.io包中。   File类 File类是IO包中唯一代表磁盘文件本身的对象，File类定义了一些与平台无关的方法来操作文件。通过调用File类提供的各种方法，能够完成创建、删除文件、重命...
文件流的基本使用方法
BarryLee的博客
12-13 901
@Test public void testWrite() throws IOException { FileWriter fWriter = new FileWriter("E:/test/filewrite.txt"); fWriter.write("Hello Subeyz!\r\n"); fWriter.write("How Are You!\r\n"); fWriter
第3章 文件I/O
Spring__Rider的博客
04-18 228
3.11 原子操作1、追加到一个文件      考虑一个进程，它要将数据追加到一个文件尾端。早期的UNIX系统版本并不支持open的O_APPEND选项，所以程序被编写成下列形式：if (lseek(fd, OL, 2) &lt; 0)    err_sys("lseek error");if (write(fd, buf, 100) != 100)   err_sys("write error"...
Java文件io-stream-file教程
最新发布
08-23
当流结束的时候返回 -1。该方法抛出 IOException。 例如，使用 read() 方法从控制台不断读取字符直到用户输入 q 的程序示例如下： ```java import java.io.*; public class BRRead { public static void main...
commons-io-2.7-bin.zip
07-29
4. **使用方法** - 解压"commons-io-2.7-bin.zip"，将得到的JAR文件添加到项目类路径中。 - 在代码中通过`import org.apache.commons.io.*;`来引用库。 - 根据具体需求，选择合适的类和方法进行I/O操作，例如使用...
commons-io-2.11.0-bin.zip
09-07
除了FileUtils，Apache Commons IO还包含其他类，如IOUtils，提供流操作的工具方法，例如读取或写入流，以及关闭流的便利方法；LineIterator，用于逐行读取文本文件；DirectoryWalker，可以递归遍历目录树，执行...
IO流------------.docx
09-08
Java中的IO流是编程中处理数据输入和输出的关键技术，主要涵盖了从文件操作到网络通信的各种数据传输场景。IO流的原理是通过流的形式...理解和熟练掌握IO流的分类、使用以及相关类的特性，是Java开发中必不可少的技能。
commons-io-1.4.jar.zip_io流jar
09-23
1. **FileUtils**: 提供了大量静态方法来操作文件，如复制、移动、删除、比较文件等，方便且易于使用。 2. **IOUtils**: 包含了许多处理流的工具方法，比如读取流到字符串、关闭流、复制流等，可以减少代码量并提高...
IO流
zjavers的博客
09-29 121
IO流 以流的方向： 输入流（input、read读） 输出流（output、write写） 以读取数据类型： 字节流 字符流 字节流 以Stream结尾的都是字节流。 以字节为单位，一次读取一个字节，可以读图片、文档、视频、音频等。 字符流 以Writer或Reader结尾的都是字符流。 以字符为单位，一次读一个字符，只能读取纯文本文件。 文件专属流 FileInputStream read()（获取当前读到字节） read(byte)（把读到的字节放到数组中，一次放byte.length） s
文件与IO(一)
shaowei的博客
10-01 333
所有程序都要处理输入和输出，处理不同类型的文件，包括文本和二 进制文件，文件编码和其他相关的内容。对文件名和目录的操作也会涉及到。 写文本数据 #!usr/bin/python3 # Read the entire file as a single string with open('somefile.txt', 'rt') as f: data = f.read() print('*' ...
Java基础 file IO
KHOST的博客
12-12 386
File类 手机里的文件 java.io.File类 代表磁盘上的一个文件或者目录的对象 该对象属性中包含了文件或目录的相关信息，如名称、长度、所含文件个数等，调用它的方法则可以完成对文件或目录的常用管理操作，例如，创建、删除等操作。 File类的属性 pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串 pathSeparatorChar 与系
第八章：File IO
wangboluo的博客
03-29 403
第八章：File IO 1.使用File类操作文件或目录属性 File对象既可以表示文件，也可以表示目录。在程序中，一个File对象可以代表一个文件或目录。 创建File对象对象的语法 File file = new File(String pathName);//pathName指的是文件路径名 File类的常用方法 方法名称 boolean exists() 判断文件或目录是...
File的IO总结
d007letian的博客
03-30 343
File分为input和output 文件的读写可以分为字节流读写，字符流读写 分别有缓冲数组读写和缓冲流读写import java.io.*;/** * Created by Administrator on 2017/3/30. */ public class FileTest { public static void main(String[] args) throws I
File类和IO
qq_44499174的博客
12-16 249
File类和I/O file 在java中，IO总是和file是分不开的，所以在学IO前必须先明白什么是file类，也就是什么是文件类。在电脑中，要么是文件，要么是文件夹。不管是.exe，.jpg还是.txt他们都是文件，都是以二进制保存的文件。区别不同的是后缀不同读取识别的格式也不同，但本质是一样的，都是二进制文件。而file类就是Java中操作文件和文件夹的工具类，对于这种工具类我们只需要记那些常用方法就行，如果后续还要使用它的其它的方法，到时在查文档就行。 常用方法 判断文件是否存在： public
JAVA.FileIO流学习（3）
Likeshan的博客
04-26 403
今天学习IO流中的字节流，使用了IO流中的这四个类： File; FileInputStream; FileOutputStream; OutputStream; 例子：拷贝一张图片，从一个目录到另外一个目录下(PS:是拷贝是不是移动) 这里因为是拷贝图片，所以要用字节流，代码如下： package ioStream; import java.io.File; import java.i...
一篇文章彻底了解File IO操作
JoesaCSDN的博客
04-20 1471
IO简介 流的概念 数据流是一组有序、有起点和终点的字节的数据序列，包括输入流和输出流。 流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。 因此Java中的流分为两种： 字节流：数据流中最小的数据单元是字节 字符流：数据流中最小的数据单元是字符 Java中的字符是Unicode编码，一个字符占用两个字节。 in和out 所谓输入、输出，是从 内存 的角度理解的，或者 程序代码 也可以理解为内存 InputStream 输入流，把file文件里的数据读
File和IO简单概述 (凌云志)
weixin_50991263的博客
03-25 256
File和IO 以前数据存储 int[] arr={1,2,3,4,5}; 弊端：不能永久化存储，只要代码运行结束，所有数据都会丢失 电脑中永久存储的地方 硬盘 内存 IO流是什么？ 1.可以将数据从本地文件中读取出来 5.可以将数据从内存保存到本地文件 File类是什么？ 1.在读写数据时告诉续集要操作的(文件/文件夹)在哪 2.对...
Java IO流详解：File类的使用
"Day19 IO流-File相关内容讲解了IO流的概念，特别是File类的使用，包括不同的构造方法和创建文件对象的方式。" 在Java编程中，输入/输出（IO）流是一种处理数据的基本机制，它允许程序与外部设备（如磁盘、内存、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值