学习笔记7
IO流
一、File
1. File类概述和构造方法
File：它是文件和目录路径名的抽象表示
- 文件和目录是可以通过File封装成对象的
- 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的
构造方法
File(String pathname): 通过将给定的路径名字符串转换为抽象路径来创建新的File实例File (String pathname, String child)：从父路径名字符串和子路径名字符串创建新的 File实例File (File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例
示例代码
package com.io.file;
import java.io.File;
public class FileDemo01 {
public static void main(String[] args) {
//File(String pathname): 通过将给定的路径名字符串转换为抽象路径来创建新的File实例
File f1 = new File("D\\tp\\miku001.jpg");
System.out.println(f1);
//File (String pathname, String child)：从父路径名字符串和子路径名字符串创建新的 File实例
File f2 = new File("D\\tp","miku001.jpg");
System.out.println(f2);
//File (File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例
File f3 = new File("D\\tp");
File f4 = new File(f3,"miku001.jpg");
System.out.println(f4);
}
}
2. File类创建功能
public boolean createNewFile()：当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件public boolean mkdir()：创建由此抽象路径名命名的目录public boolen mkdirs()：创建由此抽象路径命名的目录，包括任何必须但不存在的父目录
示例代码
package com.io.file;
import java.io.File;
import java.io.IOException;
public class FileDemo02 {
public static void main(String[] args) throws IOException {
//创建新文件
//boolean createNewFile()：不存在则创建并返回true，存在则不创建并返回false
File f1 = new File("D:\\Code\\java\\fileTest\\java.txt");
System.out.println(f1.createNewFile());
System.out.println("================");
//创建新目录
//boolean mkdir()：不存在则创建并返回true，存在则不创建并返回false，不能创建多级目录
File f2 = new File("D:\\Code\\java\\fileTest\\java");
System.out.println(f2.mkdir());
System.out.println("================");
//创建多级目录
//boolean mkdirs()：不存在则创建并返回true，存在则不创建并返回false，能创建多级目录
File f3 = new File("D:\\Code\\java\\fileTest\\javaSE\\javaEE");
System.out.println(f3.mkdir());
System.out.println(f3.mkdirs());
System.out.println("================");
//不能以路径来判断是文件还是文件夹，且创建的文件名（文件夹名）和已有的文件名（文件夹名）相同的话也会创建不成功
File f4 = new File("D:\\Code\\java\\fileTest\\javaSE.txt");
System.out.println(f4.mkdir());//创建了一个名为javaSE.txt的文件夹
}
}
3. File类判断和获取功能
public boolean isDirectory()：测试此抽象路径名表示的File是否是文件目录public boolean isFile()：测试此抽象路径名表示的File是否是文件public boolean exists()：测试此抽象路径名表示的File是否存在public String getAbsoluteFile()：返回此抽象路径名的绝对路径字符串public String getPath()：将此抽象路径名转换为路径名字符串public String getName()：返回此抽象路径的文件名或者目录名public String[] list()：返回包含此抽象路径下的文件名和目录名的字符串数组public File[] listFile()：返回包含此抽象路径下的文件名和目录名的File数组
示例代码
package com.io.file;
import java.io.File;
public class FileDemo03 {
public static void main(String[] args) {
//创建一个File对象
File f1 = new File("基础语法\\src\\goods\\miku001.jpg");
//public boolean isDirectory()：测试此抽象路径名表示的File是否是文件目录
//public boolean isFile()：测试此抽象路径名表示的File是否是文件
//public boolean exists()：测试此抽象路径名表示的File是否存在
System.out.println(f1.isDirectory());
System.out.println(f1.isFile());
System.out.println(f1.exists());
//public String getAbsoluteFile()：返回此抽象路径名的绝对路径字符串
//public String getPath()：将此抽象路径名转换为路径名字符串
//public String getName()：返回此抽象路径的文件名或者目录名
System.out.println(f1.getAbsoluteFile());
System.out.println(f1.getPath());
System.out.println(f1.getName());
System.out.println("===============");
//public String[] list()：返回包含此抽象路径下的文件名和目录名的字符串数组
File f2 = new File("基础语法\\src\\goods");
String[] s = f2.list();
for (String s1 : s){
System.out.println(s1);
}
System.out.println("===============");
//public File[] listFile()：返回包含此抽象路径下的文件名和目录名的File数组
File[] fileArray2 = f2.listFiles();
for (File file : fileArray2){
if (file.isFile()) {
System.out.println(file.getName());
}
}
}
}
4. File类删除功能
public boolean delete()：删除此抽象路径名表示的文件或者目录
绝对路径和相对路径的区别
- 绝对路径是完整的路径名，不需要任何其他信息
- 相对路径必须使用取自其他路径名的信息进行解释
删除目录时的注意事项
- 如果一个目录中有内容（目录、文件），不能直接删除。应该先删除目录中的内容，最后才能删除目录
示例代码
package com.io.file;
import java.io.File;
import java.io.IOException;
public class FileDemo04 {
public static void main(String[] args) throws IOException {
//创建File对象
File f1 = new File("基础语法\\src\\goods\\miku002.jpg");
System.out.println(f1.createNewFile());
//删除文件
//public boolean delete()：删除文件或目录
System.out.println(f1.delete());
//在当前目录下创建目录
File f2 = new File("基础语法\\src\\goods\\mkdir");
System.out.println(f2.mkdir());
//删除该目录
System.out.println(f2.delete());
//创建目录再创建文件
System.out.println(f2.mkdir());
File f3 = new File("基础语法\\src\\goods\\mkdir\\java.txt");
System.out.println(f3.createNewFile());
//删除目录
// System.out.println(f2.delete());//有内容不能删
System.out.println(f3.delete());
System.out.println(f2.delete());
}
}
5. 递归
递归概述：以编程的角度来看，递归指的是方法定义中调用方法本身的现象
递归解决问题的思路：
- 把一个复杂的问题层层转化为一个与原问题相似但规模较小的问题来解决
- 递归策略只需少量的程序就可描述出解决过程所需要的多次重复计算
递归解决问题要找到两个内容：
- 递归出口：无出口则会内存溢出
- 递归规则：与原问题相似的规模较小的问题
示例代码：
package com.io.digui;
import java.util.ArrayList;
public class DiGuiDemo01 {
public static void main(String[] args) {
//不死神兔//斐波那契数列
//1，1，2，3，5...
int[] rbt = new int[20];
rbt[0] = 1;
rbt[1] = 1;
for (int i = 2; i < rbt.length; i++) {
rbt[i] = rbt[i - 1] + rbt[i - 2];
}
System.out.println(rbt[19]);
System.out.println(f(20));
/*
递归解决问题首先要定义一个方法
定义一个方法f(n)：表示第n个月的兔子对数
*/
}
public static int f (int n ){
if (n == 1 || n == 2){
return 1;
} else{
return f(n - 1) + f(n - 2);
}
}
}
6. 案例：递归求阶乘
需求：用递归求5的阶乘，并把结果在控制台输出
package com.io.digui;
public class DiGuiDemo02 {
public static void main(String[] args) {
//递归求阶乘
System.out.println(f(5));
}
//
public static int f ( int n){
if (n == 1){
return 1;
} else {
return f(n -1) * n;
}
}
}
7. 案例：遍历目录
需求：给定一个路径，请通过递归完成该目录下的所有内容，并把所有文件的绝对路径输出在控制台
示例代码
package com.io.file;
import java.io.File;
public class FileDemo05 {
public static void main(String[] args) {
//创建File对象
File file = new File("D:\\tp");
f(file);
//获取
}
//获取该目录下的所有内容
public static void f(File file){
//获取该目录下的所有文件或目录的File数组
File[] files = file.listFiles();
//判断是否为空
if (files != null){
//遍历File数组
for (File f1 : files){
//如果为目录则调用f方法
if (f1.isDirectory()){
f(f1);
} else if (f1.isFile()){
System.out.println(f1.getAbsoluteFile());
}
}
} else {
System.out.println(file.getName() + "目录下为空！");
}
}
}
二、字节流
1. IO流概述和分类
IO流概述
- IO：输入/输出(Input/Output)
- 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
- IO流就是用来处理设备间数据传输问题的
- 常见的应用：文件复制、文件下载、文件上传
IO流分类：
- 按照数据的流向
- 输入流：读数据
- 输出流：写数据
- 按照数据类型来分
- 字节流：
- 字节输入流，字节输出流
- 字符流：
- 字符输入流，字节输出流
- 字节流：
一般来说，我们说IO流的分类是按照数据类型来分的
使用情况：
- 如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流。
2. 字节流写数据
字节流抽象基类
- InputStream：这个抽象类是表示字节输入流的所有类的超类
- OutputStream：这个抽象类是表示字节输出流的所有类的超类
- 子类名特点：子类名称都是以其父类名作为子类命的后缀
FileOutputStream：文件输出流用于将数据写入File
FileOutputStream(String name)创建文件输出流
使用字节输出流写数据的步骤：
- 创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
- 调用字节输出流对象的写数据方法
- 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）（非常重要！！）
示例代码：
package com.io.output;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo01 {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fileOutputStream = new FileOutputStream("基础语法\\src\\goods\\test.txt");
/*
调用系统功能创建了文件
创建了字节输出流对象
让字节输出流对象指向创建好的文件
*/
//public void write(int b)：将指定的字节写入此文件输出流数据
fileOutputStream.write(97);//a
fileOutputStream.write(57);//9
fileOutputStream.write(55);//7
//public void close()：释放资源
fileOutputStream.close();
}
}
3. 字节流写数据的3种方式
public void write(int b)：将指定的字节写如此文件输出流，一次写一个字节数据public void write(byte[] b)：将b.length字节从指定的字节数组写入此文件输出流一次写一个字节数组数据public void write(byte b[], int off, int len)：将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据
示例代码
package com.io.output;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class FileOutputStreamDemo02 {
public static void main(String[] args) throws IOException {
//创建FileOutputStream对象
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\test.txt");//自动封装File对象
//
fos.write(97);
fos.write(98);
fos.write(99);
fos.write(100);
fos.write(101);
String s= "abcde";
//public byte[] getBytes()：将 String编码成一个序列使用平台的默认字符集字节，结果存放到一个新的字节数组。
byte[] bytes =s.getBytes(StandardCharsets.UTF_8);
fos.write(bytes);
//public void write(byte b[])
byte[] bys = {97,98,99,100,101,102};
fos.write(bys);
//public void write(byte b[], int off, int len)：从偏移量开始写入此文件输出流，写入len个字节
fos.write(bys,3,1);
//释放资源
fos.close();
}
}
4. 字节流写数据的两个小问题
字节流写数据如何实现换行？
- 写完数据后，加换行符
字节流写数据如何实现追加写入？
public FileOutputStream(String name,boolean append)- 创建文件输出流以指定的名称写入文件，如果第二个参数为true，则字节将写入文件的末尾而不是开头
5. 字节流加异常处理
filally：在异常处理时提供finally块来执行所有清除操作，比如说IO流中的释放资源
特点：被finally控制的语句一定会执行，除非JVM退出
示例代码
package com.io.output;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class FileOutputStreamDemo04 {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//创建FileOutputStream对象
fos = new FileOutputStream("z:基础语法\\src\\goods\\test04.txt");
//写入数据
fos.write("hello".getBytes(StandardCharsets.UTF_8));
} catch (IOException e) {
e.printStackTrace();
} finally {
//释放资源
if (fos != null){//保证健壮性
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6. 字节流读数据
1. 一次读一个字节数据
需求：把文件fos.txt中的内容读取出来在控制台输出
FileInputStream：从文件系统中的文件获取输入字节
- FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名
使用字节输入流读数据的步骤：
- 创建字节输入流对象
- 调用字节输入流对象的读数据方法
- 释放资源
示例代码
package com.io.input;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamDemo01 {
public static void main(String[] args) throws IOException {
//创建FileInputStream对象
FileInputStream fis = new FileInputStream("基础语法\\src\\goods\\test03.txt");
// //调用读数据方法 int read()
// int by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
//
// by = fis.read();
// System.out.println(by);
// System.out.println((char) by);
/*
for (;;){
int by = fis.read();
if (by == -1){
break;
} else {
System.out.print((char) by);
}
}
*/
//优化上面的程序
int by;
while ((by = fis.read()) != -1){
System.out.print((char) by);
}
//如果达到文件末尾，则返回 -1
//释放资源
fis.close();
}
}
2. 一次读一个字节数组数据
需求：把txt文件中的内容读取出来在控制台输出
示例代码
package com.io.input;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputDemo02 {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("基础语法\\\\src\\\\goods\\\\Dancing stars on me!.txt");
byte[] bys = new byte[1024];//或者1024的整数倍
//int read(byte[] b)：从该字节输入流读取最多b.length字节的数据到一个字节数组
// int len = fis.read(bys);//返回的是实际读取的个数
// System.out.println(len);
// System.out.println(new String(bys));
//
// len = fis.read(bys);
// System.out.println(len);
// System.out.println(new String(bys));
int len;
while((len = fis.read(bys)) != -1){
System.out.println(new String(bys,0,len));
}
//释放资源
fis.close();
}
}
7. 案例：复制文本文件
需求：把一个txt文件复制到另一个txt文件中
示例代码
package com.io.input;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopyDemo01 {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("基础语法\\src\\goods\\Dancing stars on me!.txt");
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\copy.txt");
//读数据
int by;
while ((by = fis.read()) != -1){
//写数据
fos.write(by);
}
//释放资源
fis.close();
fos.close();
}
}
8. 案例：复制图片
需求：把一个图片复制到另一个位置
package com.io.input;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopyDemo02 {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("基础语法\\src\\goods\\miku001.jpg");
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\anime\\miku001copy.jpg");
//读数据（字符数组）
byte[] bytes = new byte[2048];
int len ;
while ((len = fis.read(bytes)) != -1){
//写数据
fos.write(bytes);
}
//释放资源
fis.close();
fos.close();
}
}
9. 字节缓冲流
字节缓冲流：
- BufferedOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
- BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组，当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节
构造方法：
- 字节缓冲输出流：BufferedOutput(OutputStream out)
- 字节缓冲输出流：BufferedInput(OutputStream in)
为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
- 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作
示例代码
package com.io.buffered;
import java.io.*;
import java.nio.charset.StandardCharsets;
public class BufferStreamDemo01 {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\miku001.txt");
//创建字节缓冲输出流对象
BufferedOutputStream bos = new BufferedOutputStream(fos);
//写数据
bos.write("hello\n".getBytes(StandardCharsets.UTF_8));//字符要转换为字节
bos.write("world\n".getBytes(StandardCharsets.UTF_8));//字符要转换为字节
bos.write("miku001\n".getBytes(StandardCharsets.UTF_8));//字符要转换为字节
//释放资源
bos.close();
fos.close();
//创建字节输入流对象
FileInputStream fis = new FileInputStream("基础语法\\src\\goods\\miku001.txt");
//创建字节缓冲输入流对象
BufferedInputStream bis = new BufferedInputStream(fis);
//读数据
//一次读一个
int len;
while ((len = bis.read()) != -1) {
System.out.print((char) len);
}
System.out.println("============");
//一次读一个字节数组
int len1;
byte[] bytes = new byte[1024];
while ((len1 = bis.read(bytes)) != -1){
System.out.print(new String(bytes,0,len1));
}//把上面的一次读一个字节的方式注释掉才能打印出
//释放资源
bis.close();
fis.close();
}
}
10. 案例：复制视频
需求：把一个视频复制到指定目录
package com.io.buffered;
import java.io.*;
public class VideoCopyDemo01 {
public static void main(String[] args) throws IOException {
//记录开始时间
long startTime = System.currentTimeMillis();
//复制视频
//方式一：基本字节流一次读写一个字节
//共耗时：2057毫秒
//method1();
//方式二：基本字节流一次读一个字节数组
//共耗时：3毫秒
//method2();
//方式三：字节缓冲流一次读写一个字节
//共耗时：17毫秒
//method3();
//方式四：字节缓冲流一次读写一个字节数组
//共耗时：3毫秒
method4();
//记录结束时间
long endTime = System.currentTimeMillis();
System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
}
//方式一：基本字节流一次读写一个字节
public static void method1() throws IOException {
//创建文件输入流对象
FileInputStream fis = new FileInputStream("基础语法\\src\\goods\\head.mp4");
//创建文件输出流对象
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\anime\\head.mp4");
//读数据
int len;
while ((len = fis.read()) != -1) {
//写数据
fos.write(len);
}
fos.close();//缓冲流关闭要在基本字节流之前
fis.close();
}
//方式二：基本字节流一次读一个字节数组
public static void method2() throws IOException {
//创建文件输入流对象
FileInputStream fis = new FileInputStream("基础语法\\src\\goods\\head.mp4");
//创建文件输出流对象
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\anime\\head.mp4");
int len;
byte[] bytes = new byte[1024];
while ((len = fis.read(bytes)) != -1) {
//写数据
fos.write(bytes, 0, len);
}
fos.close();//缓冲流关闭要在基本字节流之前
fis.close();
}
//方式三：字节缓冲流一次读写一个字节
public static void method3() throws IOException {
//创建文件输入流对象
FileInputStream fis = new FileInputStream("基础语法\\src\\goods\\head.mp4");
//创建文件输出流对象
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\anime\\head.mp4");
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
int len ;
while ((len = bis.read()) != -1){
//写数据
bos.write(len);
}
//释放资源
bos.close();
bis.close();
fos.close();//缓冲流关闭要在基本字节流之前
fis.close();
}
//方式四：字节缓冲流一次读写一个字节数组
public static void method4() throws IOException{
//创建文件输入流对象
FileInputStream fis = new FileInputStream("基础语法\\src\\goods\\head.mp4");
//创建文件输出流对象
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\anime\\head.mp4");
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
int len;
byte[] bytes = new byte[1024];
//读数据
while ((len = bis.read(bytes)) != -1) {
//写数据
bos.write(bytes, 0, len);
}
//释放资源
bos.close();
bis.close();
fos.close();//缓冲流关闭要在基本字节流之前
fis.close();
}
}
字节缓冲流加一次读写一个字节数组最快
三、字符流
1. 为什么会出现字符流
由于字节流操作中文不是特别方便，所以java就提供字符流
- 字符流 = 字节流 + 编码表
用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？
- 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数（汉字在UTF-8中占用3个字节，在GBK中占用两个字节）
2. 编码表
基础知识：
- 计算机中存储的信息都是二进制数表示的，我们在屏幕上看到英文、汉字等字符是二进制数转换之后的结果
- 按照某种规则，将字符存储到计算机中，成为编码，反之，将存储在计算机中的二进制数按照某种规则解析出来，称为解码，这里强调一下：按照A码存储，必须按照A编码解析，这样才能显示正确的文本符号，否则就会导致乱码现象
- 字符编码：就是一套自然语言的字符与二进制之间的对应规则（A，65）
字符集：
- 是一个系统支持的所有字符的集合，包括各国家文字，标点符号，图形符号，数字等
- 计算机要准确地存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见的字符集有ASCII字符集、GBXXX字符集、Unicode字符集等
ASCII字符集
- ASCII(Amercan Standard Code for Information Interchange，美国信息交换标准代码)：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）
- 基本的ASCII字符集，使用7位表示一个字符，共128字符，ASCII的拓展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符，是一个系统支持所有字符的集合，包括各国文字，标点符号，图形符号，数字等
GBXXX：
- GB2312：简体中文码表，一个小于127的字符的意义与原来的相同，但两个大于127的字符连在一起时，就表示一个汉字，这样大约组合7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名等都编进去了，连在ASCII里本来就有的数字、标点、字母都统统变了两个字节长的编码，这就是常说的“全角”字符，而原来在127号以下的那些就叫”半角“字符了
- GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等
- GB18030：最新的中文码表，收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成，支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等
Unicode字符集
- 为表达任意语言而设计，是业界的一种标准，也称为统一码，标准万国码。他最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方式，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码
- UTF-8编码：可以用来表示Unicode标准中的任意字符，他是电子邮件，网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码
- 编码规则
- 128个US-ASCII字符，只需一个字节编码
- 拉丁文等字符，需要两个字节编码
- 大部分常用字（含中文）使用三个字节编码
- 其他极少使用的Unicode辅助字符，使用四字节编码
- 编码规则
采用何种规则编码，就要采用对应规则解码，否则就会出现乱码
3. 字符串中的编码解码问题
编码：
- byte[] getByte(): 使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
- byte[] getBytes(String charsetName)：使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中
解码：
- String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String
- String(byte[] bytes,String charsetName)：通过指定的字符集解码指定的字节数组来构造新的String
示例代码：
package com.io.charstream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
public class StringDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
//定义一个字符串
String s = "中国";
//byte[] getBytes()：适用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
byte[] bytes = s.getBytes();
System.out.println(Arrays.toString(bytes));//[-28, -72, -83, -27, -101, -67]
//byte[] getBytes(String charseName)：使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中
byte[] bytes1 = s.getBytes("GBK");
System.out.println(Arrays.toString(bytes1));//[-42, -48, -71, -6]
//String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String
String ss = new String(bytes);
System.out.println(ss);//中国
//String(byte[] ,String charseName)：通过指定的字符集解码指定的字节数组来构造新的String
String sss = new String(bytes1 , "GBK");
System.out.println(sss);//中国
}
}
4. 字符流中的编码解码问题
字符流抽象基类
- Reader：字符输入流的抽象类
- Writer：字符输出流的抽象类
字符流中和编码解码问题相关的两个类
- InputStreamReader
- OutPutStreamWriter
示例代码
package com.io.charstream;
import jdk.internal.util.xml.impl.Input;
import java.io.*;
public class SteamDemo01 {
public static void main(String[] args) throws IOException {
//OutputStreamWriter：是从字节流到字符流的桥梁
//创建InputStreamReader对象
/*
FileOutputStream fos = new FileOutputStream("基础语法\\src\\goods\\mikuOO1.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);
*/
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("基础语法\\src\\goods\\miku001.txt"),"GBK");
String s = "中国";
osw.write(s);//�й�
osw.close();//用完直接关闭释放资源
//创建InputSteamReader对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("基础语法\\src\\goods\\miku001.txt"),"GBK");
//一次读取一个字符数据
int ch;
while((ch = isr.read()) != -1){
System.out.print((char)ch);
}
//中国
isr.close();
}
}
5. 字符流写数据的五种方式
void write(int c)：写一个字符void write(char[] cbuf)：写一个字符数组void Write(char[] cbuf,int off.int len)：写入字符数组的一部分void write(String str)：写一个字符串void write(String str,int off,int len)：写一个字符串的一部分
示例代码
package com.io.charstream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo01 {
public static void main(String[] args) throws IOException {
//创建OutputStreamWriter对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("基础语法\\src\\goods\\miku001.txt"));
//void write(int c)：写一个字符
osw.write(97);
//void write(char[] cbuf)：写一个字符数组
char[] cbuf = {'a','b','h'};
osw.write(cbuf);
//void write(char[] cbuf, int off, int len)：写一个字符数组的一部分
char[] chars = {'a','b','h','c','d','e','f','g'};
osw.write(chars,0,4);
//void write(String str)：写一个字符串
String str = "asdfasdfasdfsafdasf";
osw.write(str);
//void write(String str, int off, int len)：写一部分字符串
osw.write(str,0,1);
//void flush()：刷新流
//释放资源
osw.close();
}
}
- 注意：由于字符流底层还是用字节流写入数据，所以需要调用flush()刷新才能写入
6. 字符流读数据的两种方式
int read()：一次读一个字符数据int read(char[] cbuf)：一次读一个字符数组数据
示例代码
package com.io.charstream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo01 {
public static void main(String[] args) throws IOException {
//创建InputStreamReader对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("基础语法\\src\\goods\\miku001.txt"));
//void read()：一次读一个字符
int i;
// while((i = isr.read()) != -1){
// System.out.print((char) i);
// }
//void read(char[] cbuf)：一次读一个字符数组
char[] chars = new char[1024];
while((i = isr.read(chars)) != -1){
System.out.print(new String(chars,0,i));
}
//释放资源
isr.close();
}
}
7. 案例：复制Java文件
把某地的java文件复制到另一个地方的某个java文件里
package com.io.charstream;
import java.io.*;
public class CopyDemo01 {
public static void main(String[] args) throws IOException {
//创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("基础语法\\src\\goods\\miku.java"));
//创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("基础语法\\src\\goods\\anime\\copyMiku.java"));
//读数据
int len ;
char[] chars = new char[1024];
while((len = isr.read(chars)) != -1){
//写数据
osw.write(chars,0,len);
}
//释放资源
osw.close();
isr.close();
}
}
改进版：
使用
FileReader：用于读取字符文件的便捷类
和
FileWriter：用于写入字符文件的便捷类
package com.io.charstream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyDemo02 {
public static void main(String[] args) throws IOException {
//创建FileWriter和FileReader对象
FileReader fr = new FileReader("基础语法\\src\\goods\\miku.java");
FileWriter fw = new FileWriter("基础语法\\src\\goods\\anime\\CopyMiku.java");
//读数据
int len;
char[] chars = new char[1024];
while ((len = fr.read(chars)) != -1){
//写数据
fw.write(chars,0,len);
}
//释放资源
fw.close();
fr.close();
}
8. 字符缓冲流
- BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
- BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小，默认值足够大，可用于大多是用途
构造方法：
- BufferedWriter(Writer out)
- Buffered(Reader in)
示例代码
package com.io.buffered;
import java.io.*;
public class BufferedStreamDemo02 {
public static void main(String[] args) throws IOException {
//创建BufferedWriter对象
BufferedWriter bw = new BufferedWriter(new FileWriter("基础语法\\src\\goods\\miku001.txt"));
//创建BufferedReader对象
BufferedReader br = new BufferedReader(new FileReader("基础语法\\src\\goods\\miku001.txt"));
//写数据
bw.write("当今武林，还没有一个人能看清楚我热剑秦的热剑，是如何出鞘入鞘，你也不例外啊");
bw.flush();//写完数据之后把数据刷新掉，或者关闭
//读数据
int len;
char[] chars =new char[1024];
while((len = br.read(chars)) != -1 ){
System.out.print(new String(chars,0,len));
}
//释放资源
bw.close();
br.close();
}
}
9. 字符缓冲流特有功能
BufferWriter：
- void newLine()：写一个行分隔符，行分隔符字符串由系统属性定义
BufferedReader:
- public String readLine()：读一行文字，结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null
示例代码
package com.io.buffered;
import java.io.*;
public class BufferedStreamDemo03 {
public static void main(String[] args) throws IOException {
//创建BufferedWriter对象
BufferedWriter bw = new BufferedWriter(new FileWriter("基础语法\\src\\goods\\miku001.txt"));
//写入数据
for (int i = 0; i < 10; i++) {
bw.write("hello" + i);
// bw.write("\n");
bw.newLine();
bw.flush();
}
//创建字符缓冲输入流对象BufferedReader
BufferedReader br = new BufferedReader(new FileReader("基础语法\\src\\goods\\miku001.txt"));
//读数据
/*
int len;
char[] chars = new char[1024];
while((len = br.read(chars)) != -1){
System.out.print(new String(chars,0,len));//会读换行符
}
*/
//一行一行读
String str ;
while ((str = br.readLine()) != null ){
System.out.println(str);//不包含换行符，要加ln
}
//释放资源
bw.close();
}
}
10. 案例：复制Java文件（使用字符缓冲流特有功能）
示例代码
package com.io.buffered;
import java.io.*;
import java.nio.Buffer;
public class JavaCopyDemo01 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象BufferedReader
BufferedReader br = new BufferedReader(new FileReader("基础语法\\src\\goods\\Miku.java"));
//创建字符缓冲输出流对象BufferedWriter
BufferedWriter bw = new BufferedWriter(new FileWriter("基础语法\\src\\goods\\anime\\CopyMiku.java"));
//读数据（行）
String str;
while ((str = br.readLine()) != null){
//写数据（行）
bw.write(str);
bw.newLine();
bw.flush();
}
//释放资源
br.close();
bw.close();
}
}
浙公网安备 33010602011771号