java第二册—04IO流

最新推荐文章于 2022-10-09 15:55:48 发布

YLNF!!

最新推荐文章于 2022-10-09 15:55:48 发布

阅读量220

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/ChenxiLiylnf/article/details/81563911

版权

JAVA 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

IO流

一、File类

File类代表一个特定的文件或者目录，并提供了若干方法对该文件或目录进行操作。

代码1：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\System32");
		String path = file.getAbsolutePath();
		System.out.println(path);
		
		file = new File(new File("C:\\Windows"), "System32");
		path = file.getAbsolutePath();
		System.out.println(path);
		
		file = new File("C:\\Windows", "System32");
		path = file.getAbsolutePath();
		System.out.println(path);
	}
}

代码2：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\System32\\cmd.exe");
		String path = file.getAbsolutePath();
		System.out.println(path);
		
		file = new File(new File("C:\\Windows\\System32"), "cmd.exe");
		path = file.getAbsolutePath();
		System.out.println(path);
		
		file = new File("C:\\Windows\\System32", "cmd.exe");
		path = file.getAbsolutePath();
		System.out.println(path);
	}
}

•String getName()：返回此对象表示的文件或目录最后一级文件夹名称

代码1：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\System32\\cmd.exe");
		String name = file.getName();//返回文件名cmd.exe
		System.out.println(name);
	}
}

代码2：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\System32");
		String name = file.getName();//返回目录最后一级文件夹名称System32
		System.out.println(name);
	}
}

•String getParent()：返回此File对象的父目录路径名；如果此路径名没有指定父目录，则返回 null

•File getParentFile()：返回File对象所在的父目录File实例；如果File对象没有父目录，则返回 null

代码1：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\Web\\Wallpaper");
		System.out.println(file.getParent());//输出C:\Windows\Web
	}
}

代码2：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\Web\\Wallpaper");
		file = file.getParentFile();
		System.out.println(file.getName());//输出Web
	}
}

•String getPath() ：返回File对象所表示的字符串路径。

import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\Web\\Wallpaper");
		file = file.getParentFile();
		System.out.println(file.getPath());//输出C:\Windows\Web
	}
}

•boolean mkdir()：创建此File类对象指定的目录，不包含父目录。创建成功回true，否则返回false；

•boolean mkdirs()：创建此File对象指定的目录，包括所有必需但不存在的父目录，创建成功返回true；否则返回false。注意，此操作失败时也可能已经成功地创建了一部分必需的父目录。

代码1：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Program_Files\\Java");
		if (file.mkdir()) {
			System.out.println("创建成功");
		}else {
			System.out.println("创建失败");
		}
	}
}

代码2：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Program_Files\\Java");
		if (file.mkdirs()) {
			System.out.println("创建成功");
		}else {
			System.out.println("创建失败");
		}
	}
}

•boolean createNewFile()：如果指定的文件不存在并成功地创建，则返回 true；如果指定的文件已经存在，则返回 false；如果所创建文件所在目录不存在则创建失败并出现IOException异常。

注意：mkdir()和mkdirs()只能创建目录，不能创建文件；而createNewFile()只能创建文件，不能创

•boolean exists()：判断文件或目录是否存在

代码1：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\System32\\cmd.exe");
		if (file.exists()) {//判断cmd.exe文件是否存在
			System.out.println("文件存在");
		}
	}
}

代码2：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\System32");
		if (file.exists()) {//判断目录是否存在
			System.out.println("目录存在");
		}
	}
}

•boolean delete()：删除File类对象表示的目录或文件。如果该对象表示一个目录，则该目录必须为空才能删除；文件或目录删除成功返回true，否则false。

代码1：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("D:\\images");
		if (file.delete()) {// 由于D:\images目录非空，所以删除失败
			System.out.println("目录删除成功");
		} else {
			System.out.println("目录删除失败");
		}
	}
}

代码2：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("D:\\images\\image.jpg");
		if (file.delete()) {//删除图片文件
			System.out.println("图片删除成功");
		} else {
			System.out.println("图片删除失败");
		}
	}
}

•boolean isDirectory()：判断此File对象代表的路径表示是不是目录，只有File对象代表路径存在且是一个目录时才返回true，否则返回false。

•boolean isFile()：判断此File对象代表的路径是否是一个标准文件，只有File对代表路径存在且是一个标准文件时才返回true，否则返回false。

代码1：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Program Files");
		System.out.println(file.isDirectory());//返回true
	}
}

代码2：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:\\Windows\\System32\\cmd.exe");
		System.out.println(file.isFile());//返回true
	}

•String[] list()：返回由File对象对应目录所包含文件名或文件夹名组成的字符串数组。

•File[] listFiles()：返回由当前File对象对应目录所包含文件路径或文件夹路径组成的File类型的数组。

代码1：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		String[] names = new File("C:\\Program Files").list();
		for (String name : names) {
			System.out.println(name);
		}
	}
}

代码2：
import java.io.File;

public class Test {

	public static void main(String[] args) {
		File[] files = new File("C:\\Program Files").listFiles();
		for (File file : files) {
			String fileName = file.getName();
			System.out.println(fileName);
		}
	}
}

•boolean renameTo(File dest)：重新命名此File对象表示的文件，重命名成功返回true，否则返回false。

import java.io.File;

public class Test {

	public static void main(String[] args) {
		File oldFile = new File("D:\\images\\image.jpg");
		File newFile = new File("D:\\images\\Windows.jpg");
		boolean result = oldFile.renameTo(newFile);//将D盘images文件夹中图片更名为Windows.jpg
		if (result) {
			System.out.println("重命名成功");
		} else {
			System.out.println("重命名失败");
		}
	}
}

•static separator：指定文件或目录路径时使用斜线或反斜线来写，但是考虑到跨平台，斜线反斜线最好使用File类的separator属性来表示：

import java.io.File;

public class Test {

	public static void main(String[] args) {
		File file = new File("C:"+File.separator+"Windows"+File.separator+"System32");
		System.out.println(file.getPath());//输出C:\Windows\System32
	}
}

•绝对路径：从盘符开始的路径。

•相对路径：从当前路径开始的路径。

Ø./ 代表同级目录

Ø../ 代表一级上级目录(间隔一个目录)

二、IO流

•I是指Input（输入）,O是指Output（输出）。

•在Java中，文件的输入和输出是通过流（Stream）来实现的，流的概念源于Unix中管道（pipe）的概念。在Unix系统中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。

•一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。对于流而言，我们不用关心数据是如何传输的，只需要向源端输入数据，向目的端获取数据即可。

•流按照处理数据的单位，可以分为字节流和字符流；按照流向分为输入流和输出流（注意：输入流和输出流都是站在程序的角度参照的）。

1、字节流

•字节流用于处理以字节为单位的二进制文件（如音乐、图片等），

•InputStream抽象类是所有输入字节流类的直接或间接父类，FileInputStream是其重要子类：

ØFileInputStream常用构造方法：

①FileInputStream(File file) ：通过File对象创建FileInputStream对象。

②FileInputStream(String name) ：通过文件（非“目录”）路径创建FileInputStream对象。

ØFileInputStream常用方法：

①int read()：从输入流中读取单个字节的数据；如果已到达文件末尾，则返回 -1。

②int read(byte[] b)：从输入流中将最多b.length个字节的数据读入一个byte数组中，以整数形式返回存入数组中的实际字节个数；如果已到达文件末尾，则返回 -1。

③void close()：关闭此文件输入流并释放与此流有关的所有系统资源。

•OutputStream抽象类是所有输出字节流类的直接或间接父类，FileOutputStream是其重要子类：

ØFileOutputStream常用构造方法：

①FileOutputStream(File file) ：通过File对象创建FileOutputStream对象。

②FileOutputStream(String name) ：通过文件（非“目录”）路径创建FileOutputStream对象。

③FileOutputStream(File file, boolean append)：通过File对象创建FileOutputStream对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头。

ØFileOutputStream常用方法：

①void write(int b)：将指定的单个字节数据写入此文件输出流。

②void write(byte[] b, int off, int len)：将byte数组中从off开始的len个字节写入此文件输出流。

③void flush()：刷新字节输出流并强制写出缓冲内所有字节数据。

④void close()：关闭此文件输出流并释放与此流有关的所有系统资源。

•注意： FileOutputStream(File file) 、 FileOutputStream(String name) 或FileOutputStream(File file, false)创建FileOutputStream对象时会创建一个新的空文件；如果使用FileOutputStream(File file, true)创建FileOutputStream对象，则只在第一次执行时创建一个新的空文件。

import java.io.*;

public class Test {
	public static void main(String[] args) {
		FileInputStream inputStream = null;
		FileOutputStream outputStream = null;
		try {
			inputStream = new FileInputStream("C:\\存在.flac");
			outputStream = new FileOutputStream("D:\\存在.flac", true);//File类构造输出流，其中第二个参数设置为true（即将字节写入文件末尾处，而不是写入文件开始处）
			int byteData;
			while ((byteData = inputStream.read()/*逐个读取输入流中的数据*/) != -1) {
				outputStream.write(byteData);//向输出流中逐个存入字节
			}
			outputStream.flush();//刷新字节输出流并强制写出缓冲内所有字节数据。
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();//关闭并释放资源
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (outputStream != null) {
				try {
					outputStream.close();//关闭并释放资源
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

import java.io.*;

public class Test {
	public static void main(String[] args) {
		FileInputStream inputStream = null;
		FileOutputStream outputStream = null;
		try {
			inputStream = new FileInputStream("C:\\存在.flac");
			outputStream = new FileOutputStream("D:\\存在.flac", true);
			byte[] bufferArray = new byte[1024];
			int validBufferLength = 0;
			while ((validBufferLength = inputStream.read(bufferArray)/*设置局部变量缓冲数组bufferArray，read方法会将字节保存到该数组中并返回实际写入bufferArray数组的元素个数，这样减少了循环次数，提高了复制效率。*/) != -1) {
				outputStream.write(bufferArray, 0, validBufferLength);
			}
			outputStream.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (outputStream != null) {
				try {
					outputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

2、字符流

•Java虚拟机将字节转化为2个字节的Unicode字符就形成了字符流，字符流用于处理以Unicode字符为单位的文本文件（如记事本文件等）。

•Reader抽象类是所有输入字符流类的直接或间接父类， FileReader是其重要子类：

ØFileReader常用构造方法：

①FileReader(File file) ：通过File对象创建FileReader对象。

②FileReader(String fileName) ：通过文件（非“目录”）路径创建FileReader对象。

ØFileReader常用方法：

①int read()：从输入流中读取单个字符的数据，如果已到达流的末尾，则返回 -1 。

②int read(char[] cbuf)：从输入流中将最多cbuf.length个字符的数据读入一个char数组中，以整数形式返回存入数组中的实际字节个数，如果已到达流的末尾，则返回 -1 。

③void close()：关闭此文件输入流并释放与此流有关的所有系统资源。

•Writer抽象类是所有输出字符流类的直接或间接父类，FileWriter是其重要子类：

ØFileWriter常用构造方法：

①FileWriter(File file) ：通过File对象创建FileWriter对象。

②FileWriter(String fileName) ：通过文件（非“目录”）路径创建FileWriter对象。

③FileWriter(File file, boolean append)：通过File对象创建FileWriter对象；第二个参数如果为true ，则字节将被写入文件的末尾而不是开头。

ØFileWriter常用方法：

①void write(int c)：将指定的单个字符数据写入此文件输出流。

②void write(char[] cbuf, int off, int len)：将char数组中从off开始的len个字符写入此文件输出流。

③void flush()：刷新字符输出流缓冲。

④void close()：关闭此文件输出流并释放与此流有关的所有系统资源。

•注意： FileWriter (File file) 、 FileWriter (String fileName) 或FileWriter (File file, false)创建FileWriter对象时会创建一个新的空文件；如果使用FileWriter (File file, true)创建FileWriter对象，则只在第一次执行时创建一个新的空文件。

import java.io.FileWriter;
import java.io.IOException;

public class Test {

	public static void main(String[] args) {
		try {
			FileWriter fileWriter = new FileWriter("D:\\笔记.txt", true);// 创建FileWriter对象的同时创建一个空文件；但因为第二个参数为true，所以再次执行该行代码不会创建新文件。
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

import java.io.*;

public class Test {
	public static void main(String[] args) {
		FileReader reader = null;
		FileWriter writer = null;
		try {
			reader = new FileReader("C:\\笔记.txt");
			writer = new FileWriter("D:\\笔记.txt",true);
			int eachCharacter;
			while ((eachCharacter = reader.read()) != -1) {
				writer.write(eachCharacter);
			}
			writer.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

import java.io.*;

public class Test {
	public static void main(String[] args) {
		FileReader reader = null;
		FileWriter writer = null;
		try {
			reader = new FileReader("C:\\笔记.txt");
			writer = new FileWriter("D:\\笔记.txt",true);
			char[] bufferArray = new char[1024];
			int validBufferLength = 0;
			while ((validBufferLength = reader.read(bufferArray)) != -1) {
				writer.write(bufferArray, 0, validBufferLength);
			}
			writer.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

•缓冲流是一种装饰器类，目的是让原字节流、字符流新增缓冲的功能以提高读取或写入。

•缓冲字节输入流：

ØBufferedInputStream(InputStream in)：

•缓冲字节输出流：

ØBufferedOutputStream(OutputStream out)：

import java.io.*;

public class Test {
	public static void main(String[] args) {
		BufferedInputStream inputStream = null;
		BufferedOutputStream bufferedOutputStream = null;
		try {
			FileInputStream fileInputStream = new FileInputStream("C:\\存在.flac");
			inputStream = new BufferedInputStream(fileInputStream);
			FileOutputStream fileOutputStream = new FileOutputStream("D:\\存在.flac", true);
			bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
			byte[] bufferArray = new byte[1024];
			int validBufferLength  = 0;
			while ((validBufferLength  = inputStream.read(bufferArray)) != -1) {
				bufferedOutputStream.write(bufferArray, 0, validBufferLength );
			}
			bufferedOutputStream.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (bufferedOutputStream != null) {
				try {
					bufferedOutputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

3、转换流

•转换流仅用于将字节流转换成字符流。

•InputStreamReader（字节输入流à字符输入流）：

ØInputStreamReader(InputStream in) ：

ØInputStreamReader(InputStream in, String charsetName)：

•OutputStreamWriter（字节输出流à字符输出流）：

ØOutputStreamWriter(OutputStream out) ：

ØOutputStreamWriter(OutputStream out, String charsetName) ：

import java.io.*;

public class StreamToReaderTest {
	public static void main(String[] args) {
		BufferedReader reader = null;
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			System.out.print("请输入你今天最想说的话：");
			String words = reader.readLine();
			System.err.println(words);
		} catch (IOException e) {
			System.out.println(e.getMessage());
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

import java.io.*;

public class Test {
	public static void main(String[] args) {
		BufferedReader bufferedReader = null;
		BufferedWriter bufferedWriter = null;
		try {
			FileInputStream fileInputStream = new FileInputStream("C:\\笔记.txt");
			InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"GBK");
			bufferedReader = new BufferedReader(inputStreamReader);
			
			FileOutputStream fileOutputStream = new FileOutputStream("D:\\笔记.txt");
			OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream,"GBK");
			bufferedWriter = new BufferedWriter(outputStreamWriter);
			
			String oneLineData;
			while ((oneLineData = bufferedReader.readLine()) != null) {
				bufferedWriter.write(oneLineData);
				bufferedWriter.newLine();
			}
			bufferedWriter.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (bufferedReader != null) {
				try {
					bufferedReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (bufferedWriter != null) {
				try {
					bufferedWriter.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}