使用数组，集合等不能长久的存储数据（硬盘可以）
文件是数据的载体
// 1、创建File对象（指定了文件的路径）
路径写法：1、 D:\resources\xueshan.jpeg
2、D:/resources/xueshan.jpeg
3、File f = new File("D:\\resources\\xueshan.jpeg");
4、File f = new File("D:/resources/xueshan.jpeg");
5、File f = new File("D:" + File.separator+"resources"+ File.separator +"xueshan.jpeg");
long size = f.length(); // 是文件的字节大小
System.out.println(size);绝对路径与相对路径
// 2、File创建对象，支持绝对路径 支持相对路径（重点）
File f1 = new File("D:\\resources\\beauty.jpeg"); // 绝对路径，从盘符开始
System.out.println(f1.length());
// 相对路径：一般定位模块中的文件的。 相对到工程下！！（不带盘符-重中之重）
File f2 = new File("file-io-app/src/data.txt");
System.out.println(f2.length());File创建文件夹
// 3、File创建对象 ，可以是文件也可以是文件夹
//不带后缀就是文件夹
File f3 = new File("D:\\resources");
System.out.println(f3.exists()); // 判断这个路径是否存在，这个文件夹存在否
//存在返回true 不存在返回false
File类常用方法 判断文件类型 获取文件信息
绝对路径
// 1.绝对路径创建一个文件对象
File f1 = new File("D:/resources/xueshan.jpeg");
// a.获取它的绝对路径。
System.out.println(f1.getAbsolutePath());
// b.获取文件定义的时候使用的路径。
System.out.println(f1.getPath());
// c.获取文件的名称：带后缀。
System.out.println(f1.getName());
// d.获取文件的大小：字节个数。
System.out.println(f1.length()); // 字节大小
// e.获取文件的最后修改时间
long time = f1.lastModified();
System.out.println("最后修改时间：" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(time));
// f、判断文件是文件还是文件夹
System.out.println(f1.isFile()); // true
System.out.println(f1.isDirectory()); // false相对路径
File f2 = new File("file-io-app\\src\\data.txt");
// a.获取它的绝对路径。
System.out.println(f2.getAbsolutePath());
// b.获取文件定义的时候使用的路径。
System.out.println(f2.getPath());
// c.获取文件的名称：带后缀。
System.out.println(f2.getName());
// d.获取文件的大小：字节个数。
System.out.println(f2.length()); // 字节大小
// e.获取文件的最后修改时间
long time1 = f2.lastModified();
System.out.println("最后修改时间：" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(time1));
// f、判断文件是文件还是文件夹
System.out.println(f2.isFile()); // true
System.out.println(f2.isDirectory()); // false
System.out.println(f2.exists()); // true
File file = new File("D:/");
System.out.println(file.isFile()); // false
System.out.println(file.isDirectory()); // true
System.out.println(file.exists()); // true
File file1 = new File("D:/aaa");
System.out.println(file1.isFile()); // false
System.out.println(file1.isDirectory()); // false
System.out.println(file1.exists()); // falseFile类常用方法 创建文件、删除文件功能
package com.itheima.d1_file;
import java.io.File;
import java.io.IOException;
/**
目标：File类的创建和删除的方法
- public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，
创建一个新的空文件。 （几乎不用的，因为以后文件都是自动创建的！）
- public boolean delete() ：删除由此File表示的文件或目录。 （只能删除空目录）
- public boolean mkdir() ：创建由此File表示的目录。（只能创建一级目录）
- public boolean mkdirs() ：可以创建多级目录（建议使用的）
*/
public class FileDemo03 {
public static void main(String[] args) throws IOException {
File f = new File("file-io-app\\src\\data.txt");
// a.创建新文件，创建成功返回true ,反之 ,不需要这个，以后文件写出去的时候都会自动创建
System.out.println(f.createNewFile());
File f1 = new File("file-io-app\\src\\data02.txt");
System.out.println(f1.createNewFile()); // （几乎不用的，因为以后文件都是自动创建的！）
// b.mkdir创建一级目录
File f2 = new File("D:/resources/aaa");
System.out.println(f2.mkdir());
// c.mkdirs创建多级目录(重点)
File f3 = new File("D:/resources/ccc/ddd/eee/ffff");
// System.out.println(f3.mkdir());
System.out.println(f3.mkdirs()); // 支持多级创建
// d.删除文件或者空文件夹
System.out.println(f1.delete());
File f4 = new File("D:/resources/xueshan.jpeg");
System.out.println(f4.delete()); // 占用一样可以删除
// 只能删除空文件夹,不能删除非空文件夹.
File f5 = new File("D:/resources/aaa");
System.out.println(f5.delete());
}
}
File类常用方法 遍历文件夹
package com.itheima.d1_file;
import java.io.File;
import java.util.Arrays;
/**
目标：File针对目录的遍历
- public String[] list()：
获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。
- public File[] listFiles()(常用)：
获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）
*/
public class FileDemo04 {
public static void main(String[] args) {
// 1、定位一个目录
File f1 = new File("D:/resources");
String[] names = f1.list();
for (String name : names) {
System.out.println(name);
}
// 2.一级文件对象
// 获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）
File[] files = f1.listFiles();
for (File f : files) {
System.out.println(f.getAbsolutePath());
}
// 注意事项
File dir = new File("D:/resources/ddd");
File[] files1 = dir.listFiles();
System.out.println(Arrays.toString(files1));
}
}
文件的算法形式 ——方法递归
package com.itheima.d2_recusion;
/**
目标：递归的算法和执行流程
*/
public class RecursionDemo02 {
public static void main(String[] args) {
System.out.println(f(5));
}
//注意看形参n 与函数内实参n 一致
//递归的公式：f(n)=f(n-1)*n;
//递归的终结点：f(1)
//递归的方向必须走向终结点：
public static int f(int n){
if(n == 1){
return 1;
}else {
return f(n - 1) * n;
}
}
}
package com.itheima.d2_recusion;
/**
目标：1 - n求和
*/
public class RecursionDemo03 {
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;
}
}
} 
package com.itheima.d2_recusion;
/**
目标 猴子吃桃。
公式（合理的）： f(x) - f(x)/2 - 1 = f(x+1)
2f(x) - f(x) - 2 = 2f(x + 1)
f(x) = 2f(x + 1) + 2
求f(1) = ?
终结点： f（10） = 1
递归的方向：合理的
*/
public class RecursionDemo04 {
public static void main(String[] args) {
System.out.println(f(1));
System.out.println(f(2));
System.out.println(f(3));
}
public static int f(int n){
if(n == 10){
return 1;
}else {
return 2 * f(n + 1) + 2;
}
}
}
package com.itheima.d2_recusion;
import java.io.File;
import java.io.IOException;
/**
目标：去D判断搜索 eDiary.exe文件
*/
public class RecursionDemo05 {
public static void main(String[] args) {
// 2、传入目录 和 文件名称
searchFile(new File("D:/") , "eDiary.exe");
}
/**
* 1、搜索某个目录下的全部文件，找到我们想要的文件。
* @param dir 被搜索的源目录
* @param fileName 被搜索的文件名称
*/
public static void searchFile(File dir,String fileName){
// 3、判断dir是否是目录
if(dir != null && dir.isDirectory()){
// 可以找了
// 4、提取当前文件夹下的一级文件对象
//API listFiles当对象是一个文件时返回null 当对象是一个空文件夹时返回[]
File[] files = dir.listFiles(); // null []
// 5、判断是否存在一级文件对象，存在才可以遍历
if(files != null && files.length > 0) {
for (File file : files) {
// 6、判断当前遍历的一级文件对象是文件 还是 文件夹
if(file.isFile()){
// 7、是不是咱们要找的，是把其路径输出即可
if(file.getName().contains(fileName)){
System.out.println("找到了：" + file.getAbsolutePath());
// 自动启动软件
try {
Runtime r = Runtime.getRuntime();
r.exec(file.getAbsolutePath());
} catch (IOException e) {
e.printStackTrace();
}
}
}else {
// 8、是文件夹，需要继续递归寻找
searchFile(file, fileName);
}
}
}
}else {
System.out.println("对不起，当前搜索的位置不是文件夹！");
}
}
}非规律化递归——啤酒问题
package com.itheima.d2_recusion;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
/**
目标：啤酒2元1瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，
请问10元钱可以喝多少瓶酒，剩余多少空瓶和盖子。
答案：15瓶 3盖子 1瓶子
*/
public class RecursionDemo06 {
// 定义一个静态的成员变量用于存储可以买的酒数量
public static int totalNumber; // 总数量
public static int lastBottleNumber; // 记录每次剩余的瓶子个数
public static int lastCoverNumber; // 记录每次剩余的盖子个数
public static void main(String[] args) {
// 1、拿钱买酒
buy(10);
System.out.println("总数：" + totalNumber);
System.out.println("剩余盖子数：" + lastCoverNumber);
System.out.println("剩余瓶子数：" + lastBottleNumber);
}
public static void buy(int money){
// 2、看可以立马买多少瓶
int buyNumber = money / 2; // 5
totalNumber += buyNumber;
// 3、把盖子 和瓶子换算成钱
// 统计本轮总的盖子数 和 瓶子数
int coverNumber = lastCoverNumber + buyNumber;
int bottleNumber = lastBottleNumber + buyNumber;
// 统计可以换算的钱
int allMoney = 0;
if(coverNumber >= 4){
allMoney += (coverNumber / 4) * 2;
}
lastCoverNumber = coverNumber % 4;
if(bottleNumber >= 2){
allMoney += (bottleNumber / 2) * 2;
}
lastBottleNumber = bottleNumber % 2;
if(allMoney >= 2){
buy(allMoney);
}
Integer[] arr2 = new Integer[]{11, 22, 33};
Arrays.sort(arr2);
}
}自写方法删除非空文件夹
package com.itheima.d2_recusion;
import java.io.File;
/**
目标：删除非空文件夹
*/
public class RecursionDemo07 {
public static void main(String[] args) {
deleteDir(new File("D:/new"));
}
/**
删除文件夹，无所谓里面是否有内容，都可以删除
* @param dir
*/
public static void deleteDir(File dir){
// 1、判断dir存在且是文件夹
if(dir != null && dir.exists() && dir.isDirectory()){
// 2、提取一级文件对象。
File[] files = dir.listFiles();
// 3、判断是否存在一级文件对象，存在则遍历全部的一级文件对象去删除
if(files != null && files.length > 0){
// 里面有内容
for (File file : files) {
// 4、判断file是文件还是文件夹，文件直接删除
if(file.isFile()){
file.delete();
}else {
// 递归删除
deleteDir(file);
}
}
}
// 删除自己
dir.delete();
}
}
}字符集
String编码与String解码
目标：学会自己进行文字的编码和解码，为以后可能用到的场景做准备。 系统默认都是UTF-8的编码解码 如果对方要求用 GBK 则需要自定义编码解码
package com.itheima.d3_charset;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
/**
目标：学会自己进行文字的编码和解码，为以后可能用到的场景做准备。
系统默认都是UTF-8的编码解码 如果对方要求用 GBK 则需要自定义编码解码
*/
public class Test {
public static void main(String[] args) throws Exception {
// 1、编码：把文字转换成字节（使用指定的编码）
String name = "abc我爱你中国";
// byte[] bytes = name.getBytes(); // 以当前代码默认字符集进行编码 （UTF-8）
byte[] bytes = name.getBytes("GBK"); // 指定编码
System.out.println(bytes.length);
System.out.println(Arrays.toString(bytes));
// 2、解码：把字节转换成对应的中文形式（编码前 和 编码后的字符集必须一致，否则乱码 ）
// String rs = new String(bytes); // 默认的UTF-8
String rs = new String(bytes, "GBK"); // 指定GBK解码
System.out.println(rs);
}
}I O流概述
也成为输入、输出流，就是用来读写数据
I 表示 intput,是数据从硬盘文件读入到内存的过程，称之输入，负责读。
O 表示 output,是内存程序的数据从内存到写出到硬盘文件的过程，称之输出，负责写
文件字节输入流FilelnputStream
一个字节一个字节的读取
package com.itheima.d4_byte_stream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
/**
目标：字节输入流的使用。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter(实现类，可以使用的)
文件字节输入流：FileInputStream
-- 作用：以内存为基准，把磁盘文件中的数据以字节的形式读取到内存中去。
按照字节读文件数据到内存中。
-- 构造器：
public FileInputStream(File file):创建字节输入流管道与源文件对象接通
public FileInputStream(String pathname)：创建字节输入流管道与源文件路径接通。
-- 方法：
public int read(): 每次读取一个字节返回，读取完毕返回-1。
小结：
一个一个字节读取中文数据输出其实是被淘汰的，性能极差！
一个一个字节读取中文数据输出，会出现截断中文字节的情况，无法避免读取中文输出乱码的问题。
*/
public class FileInputStreamDemo01 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字节输入流管道与源文件接通。
// InputStream is = new FileInputStream(new File("file-io-app\\src\\data.txt"));
// 简化写法
InputStream is = new FileInputStream("file-io-app\\src\\data.txt");
// 2、读取一个字节返回 （每次读取一滴水）
// int b1 = is.read();
// System.out.println((char)b1);
//
// int b2 = is.read();
// System.out.println((char)b2);
//
// int b3 = is.read();
// System.out.println((char)b3);
//
// int b4 = is.read(); // 读取完毕返回-1
// System.out.println(b4);
// 3、使用循环改进
// 定义一个变量记录每次读取的字节 a b 3 爱
// o o o [ooo]
int b;
while (( b = is.read() ) != -1){
System.out.print((char) b);
}
}
}三个字节三个字节的读取
package com.itheima.d4_byte_stream;
import java.io.FileInputStream;
import java.io.InputStream;
/**
目标：使用文件字节输入流每次读取一个字节数组的数据。
*/
public class FileInputStreamDemo02 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app/src/data02.txt");
// 2、定义一个字节数组，用于读取字节数组
// byte[] buffer = new byte[3]; // 3B
// int len = is.read(buffer);
// System.out.println("读取了几个字节：" + len);
// //String rs = new String(buffer);解码操作
// String rs = new String(buffer);
// System.out.println(rs);
//
// int len1 = is.read(buffer);
// System.out.println("读取了几个字节：" + len1);
// String rs1 = new String(buffer);
// System.out.println(rs1);
// // buffer = [a b c]
//
// // buffer = [a b c] ==> [c d c]
// int len2 = is.read(buffer);
// System.out.println("读取了几个字节：" + len2);
// // 读取多少倒出多少
// String rs2 = new String(buffer,0 ,len2);
// System.out.println(rs2);
//
// int len3 = is.read(buffer);
// System.out.println(len3); // 读取完毕返回-1
// 3、改进使用循环，每次读取一个字节数组
byte[] buffer = new byte[3];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1) {
// 读取多少倒出多少
System.out.print(new String(buffer, 0 , len));
}
}
}前两种单独读一个字节和三个字节的读取，均存在乱码风险，所以，可以将读取字节数组设置成与文件的大小一样大即可
方式一：自己定义一个字节数组与文件的大小一样大，然后使用读取字节数组的方法，一次性读取完成 JDK8
// 1、创建一个文件字节输入流管道与源文件接通
File f = new File("file-io-app/src/data03.txt");
InputStream is = new FileInputStream(f);
//2、定义一个字节数组与文件的大小刚刚一样大。
byte[] buffer = new byte[(int) f.length()];
int len = is.read(buffer);
System.out.println("读取了多少个字节：" + len);
System.out.println("文件大小：" + f.length());
System.out.println(new String(buffer));方式二：官方为字节输入流InputStream提供了API可以直接把文件的全部数据读取到一个字节数组中 JDK9
// 1、创建一个文件字节输入流管道与源文件接通
File f = new File("file-io-app/src/data03.txt");
InputStream is = new FileInputStream(f);
// 读取全部字节数组
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));
文件字节输出流FileOutputStream
OutputStream os = new FileOutputStream("file-io-app/src/out04.txt" , true); // 追加数据管道
OutputStream os = new FileOutputStream("file-io-app/src/out04.txt"); // 先清空之前的数据，写新数据进入
os.write("\r\n".getBytes()); // 换行
os.flush(); // 写数据必须，刷新数据 可以继续使用流
os.close(); // 释放资源，包含了刷新的！关闭后流不可以使用了
package com.itheima.d4_byte_stream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
/**
目标：字节输出流的使用。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter (实现类)
a.FileOutputStream文件字节输出流。
-- 作用：以内存为基准，把内存中的数据，按照字节的形式写出到磁盘文件中去。
简单来说，把内存数据按照字节写出到磁盘文件中去。
-- 构造器：
public FileOutputStream(File file):创建一个字节输出流管道通向目标文件对象。
public FileOutputStream(String file):创建一个字节输出流管道通向目标文件路径。
public FileOutputStream(File file , boolean append):创建一个追加数据的字节输出流管道通向目标文件对象。
public FileOutputStream(String file , boolean append):创建一个追加数据的字节输出流管道通向目标文件路径。
-- 方法：
public void write(int a):写一个字节出去 。
public void write(byte[] buffer):写一个字节数组出去。
public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
参数一，字节数组；参数二：起始字节索引位置，参数三：写多少个字节数出去。
小结：
记住。
换行： os.write("\r\n".getBytes()); // 换行
追加数据管道： OutputStream os = new FileOutputStream("day10_demo/out01.txt" , true); // 追加管道！！
*/
public class OutputStreamDemo04 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out04.txt" , true); // 追加数据管道
// OutputStream os = new FileOutputStream("file-io-app/src/out04.txt"); // 先清空之前的数据，写新数据进入
// 2、写数据出去
// a.public void write(int a):写一个字节出去
os.write('a');
os.write(98);
os.write("\r\n".getBytes()); // 换行
// os.write('徐'); // [ooo]
// b.public void write(byte[] buffer):写一个字节数组出去。
byte[] buffer = {'a' , 97, 98, 99};
os.write(buffer);
os.write("\r\n".getBytes()); // 换行
byte[] buffer2 = "我是中国人".getBytes();
// byte[] buffer2 = "我是中国人".getBytes("GBK");
os.write(buffer2);
os.write("\r\n".getBytes()); // 换行
// c. public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
byte[] buffer3 = {'a',97, 98, 99};
os.write(buffer3, 0 , 3);
os.write("\r\n".getBytes()); // 换行
// os.flush(); // 写数据必须，刷新数据 可以继续使用流
os.close(); // 释放资源，包含了刷新的！关闭后流不可以使用了
}
}文件拷贝功能实现（可以拷贝任何文件）（直接拿来用）
package com.itheima.d4_byte_stream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
/**
* 目标：学会使用字节流完成文件的复制（支持一切文件类型的复制）
*/
public class CopyDemo05 {
public static void main(String[] args) {
try {
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");
// 4、关闭流。
os.close();
is.close();
} catch (Exception e){
e.printStackTrace();
}
}
}文件资源释放的方式
1）try-catch-finally // 无论程序正常结束或是异常结束 finally最后肯定会被执行，因此适合做程序的收尾工作
package com.itheima.d5_resource;
import java.io.*;
/**
* 目标：学会使用finally释放资源。
*/
public class TryCatchFinallyDemo1 {
public static void main(String[] args) {
InputStream is = null;
OutputStream os = null;
try {
// System.out.println(10/ 0);
// 1、创建一个字节输入流管道与原视频接通
is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
os = new FileOutputStream("file-io-app/src/out05.txt");
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");
// System.out.println( 10 / 0);
} catch (Exception e){
e.printStackTrace();
} finally {
// 无论代码是正常结束，还是出现异常都要最后执行这里
System.out.println("========finally=========");
try {
// 4、关闭流。
if(os!=null)os.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(is != null) is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(test(10, 2));
}
public static int test(int a , int b){
try {
int c = a / b;
return c;
}catch (Exception e){
e.printStackTrace();
return -111111; // 计算出现bug.
}finally {
System.out.println("--finally--");
// 哪怕上面有return语句执行，也必须先执行完这里才可以！
// 开发中不建议在这里加return ，如果加了，返回的永远是这里的数据了，这样会出问题！
return 100;
}
}
}2）try-with-resource
JDK7 的改进方案
package com.itheima.d5_resource;
import java.io.*;
/**
* 目标：学会使用JDK 7的新方式释放资源
*/
public class TryCatchResouceDemo2 {
public static void main(String[] args) {
try (
// 定义流对象
// 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");
// int age = 23; // 这里只能放资源
MyConnection connection = new MyConnection(); // 最终会自动调用资源的close方法
) {
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");
} catch (Exception e){
e.printStackTrace();
}
}
}
class MyConnection implements AutoCloseable{
@Override
public void close() throws IOException {
System.out.println("连接资源被成功释放了！");
}
}文件字符输入流、文件字符输出流（读取中文输出）
一个字符一个字符的读取
package com.itheima.d6_char_stream;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
/**
目标：字符输入流的使用。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter (实现类)
c.FileReader:文件字符输入流。
-- 作用：以内存为基准，把磁盘文件的数据以字符的形式读入到内存。
简单来说，读取文本文件内容到内存中去。
-- 构造器：
public FileReader(File file):创建一个字符输入流与源文件对象接通。
public FileReader(String filePath):创建一个字符输入流与源文件路径接通。
-- 方法：
public int read(): 读取一个字符的编号返回！ 读取完毕返回-1
public int read(char[] buffer):读取一个字符数组，读取多少个字符就返回多少个数量，读取完毕返回-1
小结：
字符流一个一个字符的读取文本内容输出，可以解决中文读取输出乱码的问题。
字符流很适合操作文本文件内容。
但是：一个一个字符的读取文本内容性能较差！！
*/
public class FileReaderDemo01 {
public static void main(String[] args) throws Exception {
// 目标：每次读取一个字符。
// 1、创建一个字符输入流管道与源文件接通
Reader fr = new FileReader("file-io-app\\src\\data06.txt");
// 2、读取一个字符返回，没有可读的字符了返回-1
// int code = fr.read();
// System.out.print((char)code);
//
// int code1 = fr.read();
// System.out.print((char)code1);
// 3、使用循环读取字符
int code;
while ((code = fr.read()) != -1){
System.out.print((char) code);
}
}
}字符数组读取中文（目前最好的代码）
字符数组读取中文（目前最好的代码）
package com.itheima.d6_char_stream;
import java.io.FileReader;
import java.io.Reader;
/**
目标：字符输入流的使用-按照字符数组读取。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter (实现类)
c.FileReader:文件字符输入流。
-- 作用：以内存为基准，把磁盘文件的数据以字符的形式读入到内存。
简单来说，读取文本文件内容到内存中去。
-- 构造器：
public FileReader(File file):创建一个字符输入流与源文件对象接通。
public FileReader(String filePath):创建一个字符输入流与源文件路径接通。
-- 方法：
public int read(): 读取一个字符的编号返回！ 读取完毕返回-1
public int read(char[] buffer):读取一个字符数组，
读取多少个字符就返回多少个数量，读取完毕返回-1
小结：
字符流按照字符数组循环读取数据，可以解决中文读取输出乱码的问题，而且性能也较好！！
*/
public class FileReaderDemo02 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字符输入流与源文件接通
Reader fr = new FileReader("file-io-app/src/data07.txt");
// 2、用循环，每次读取一个字符数组的数据。 1024 + 1024 + 8
char[] buffer = new char[1024]; // 1K字符
int len;
while ((len = fr.read(buffer)) != -1) {
String rs = new String(buffer, 0, len);
System.out.print(rs);
}
}
}
package com.itheima.d6_char_stream;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
/**
目标：字符输出流的使用。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter (实现类)
d.FileWriter文件字符输出流的使用。
-- 作用：以内存为基准，把内存中的数据按照字符的形式写出到磁盘文件中去。
简单来说，就是把内存的数据以字符写出到文件中去。
-- 构造器：
public FileWriter(File file):创建一个字符输出流管道通向目标文件对象。
public FileWriter(String filePath):创建一个字符输出流管道通向目标文件路径。
public FileWriter(File file,boolean append):创建一个追加数据的字符输出流管道通向目标文件对象。
public FileWriter(String filePath,boolean append):创建一个追加数据的字符输出流管道通向目标文件路径。
-- 方法：
a.public void write(int c):写一个字符出去
b.public void write(String c)写一个字符串出去：
c.public void write(char[] buffer):写一个字符数组出去
d.public void write(String c ,int pos ,int len):写字符串的一部分出去
e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
小结：
字符输出流可以写字符数据出去，总共有5个方法写字符。
覆盖管道：
Writer fw = new FileWriter("Day10Demo/src/dlei03.txt"); // 覆盖数据管道
追加数据管道：
Writer fw = new FileWriter("Day10Demo/src/dlei03.txt",true); // 追加数据管道
换行：
fw.write("\r\n"); // 换行
结论：读写字符文件数据建议使用字符流。复制文件建议使用字节流。
*/
public class FileWriterDemo03 {
public static void main(String[] args) throws Exception {
// 1、创建一个字符输出流管道与目标文件接通
// Writer fw = new FileWriter("file-io-app/src/out08.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
Writer fw = new FileWriter("file-io-app/src/out08.txt", true); // 覆盖管道，每次启动都会清空文件之前的数据
// a.public void write(int c):写一个字符出去
fw.write(98);
fw.write('a');
fw.write('徐'); // 不会出问题了
fw.write("\r\n"); // 换行
// b.public void write(String c)写一个字符串出去
fw.write("abc我是中国人");
fw.write("\r\n"); // 换行
// c.public void write(char[] buffer):写一个字符数组出去
char[] chars = "abc我是中国人".toCharArray();
fw.write(chars);
fw.write("\r\n"); // 换行
// d.public void write(String c ,int pos ,int len):写字符串的一部分出去
fw.write("abc我是中国人", 0, 5);
fw.write("\r\n"); // 换行
// e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
fw.write(chars, 3, 5);
fw.write("\r\n"); // 换行
// fw.flush();// 刷新后流可以继续使用
fw.close(); // 关闭包含刷线，关闭后流不能使用
}
}
扫一扫
420
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
