目录
一.File类概述
package com.wjh.d1_File;
import java.io.File;
/**
* 目标:学会使用File对象定位操作系统的文件(文件和文件夹)
*/
public class FileDemo {
public static void main(String[] args) {
//1.创建了File对象(指定文件的路径)
//路径写法
// D:/resources/1.jpg
//File f = new File("D:\\resources\\1.jpg"); //文件路径 " \\ " -> 转义
//File f = new File("D:/resources/1.jpg"); //文件路径 " \\ " -> 转义
File f = new File("D:" + File.separator +"\\resources\\1.jpg"); //文件路径 " \\ " -> 转义
long size = f.length(); //文件的字节大小
System.out.println(size); //37250
//2.File创建对象,支持绝对路径,支持相对路径(重点)
File f1 = new File("D:/resources/2.jpg"); //绝对路径
System.out.println(f1.length()); //17803
//相对路径:一般定位模块中的文件的,相对到工程下!!
File f2 = new File("../File-io-app/src/date.txt"); //15
System.out.println(f2.length());
//3.File创建对象,可以是文件,也可以是文件夹
File f3 = new File("D:/resources"); //文件路径 "
System.out.println(f3.exists()); //判断文件是否存在
}
}
37250
17803
15
true进程已结束，退出代码为 0
二.File类的常用API
1.判断文件类型,获取文件信息
package com.wjh.d1_File;
/*
目标:File类的获取功能API
public boolean isDirectory() 判断此路径名表示的File是否为文件夹
public boolean isFile() 判断此路径名表示的File是否为文件
public boolean exists() 判断此路径名表示的File是否存在
public long length() 返回文件的大小（字节数量）
public String getAbsolutePath() 返回文件的绝对路径
public String getPath() 返回定义文件时使用的路径
public String getName() 返回文件的名称，带后缀
public long lastModified() 返回文件的最后修改时间（时间毫秒值）
*/
import java.io.File;
import java.text.SimpleDateFormat;
public class FileDemo2 {
public static void main(String[] args) {
//1.绝对路径创建一个文件对象
File f1 = new File("D:/resources/2.jpg");
File f2 = new File("../File-io-app/src/date.txt");
//a.获取他的绝对路径
System.out.println(f1.getAbsoluteFile()); //D:\resources\2.jpg
System.out.println(f2.getAbsoluteFile()); //D:\JavaDemo\JavaSEPro\JavaSEProMax\day01-opp-demo\..\File-io-app\src\date.txt
//b.获取文件定义的时候使用的路径
System.out.println(f1.getPath()); //D:\resources\2.jpg
System.out.println(f2.getPath()); //..\File-io-app\src\date.txt
//c.获取文件的名称(带后缀)
System.out.println(f1.getName()); //2.jpg
System.out.println(f2.getName()); //date.txt
//d.获取文件的大小:字节个数
System.out.println(f1.length()); //17803
System.out.println(f2.length()); //15
//e.获取文件的最后修改时间
System.out.println(f1.lastModified()); //1683708045368
long time = f1.lastModified();
System.out.println("最后修改时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time)); //最后修改时间:2023-05-10 16:40:45
System.out.println(f2.lastModified()); //1683709170653
long time2 = f2.lastModified();
System.out.println("最后修改时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time2)); //最后修改时间:2023-05-10 16:59:30
//f.判断文件是否是文件还是文件夹
System.out.println(f1.isFile()); //true
System.out.println(f1.isDirectory()); //false
System.out.println(f2.isFile()); //true
System.out.println(f2.isDirectory()); //false
File file = new File("D:/");
System.out.println(file.isFile()); //false
System.out.println(file.isDirectory()); //true
System.out.println(file.exists()); //true
}
}
D:\JavaJDK\bin\java.exe "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2021.1.3\lib\idea_rt.jar=65528:D:\Program Files\JetBrains\IntelliJ IDEA 2021.1.3\bin" -Dfile.encoding=UTF-8 -classpath D:\JavaDemo\JavaSEPro\JavaSEProMax\day01-opp-demo\out\production\File-io-app com.wjh.d1_File.FileDemo2
D:\resources\2.jpg
D:\JavaDemo\JavaSEPro\JavaSEProMax\day01-opp-demo\..\File-io-app\src\date.txt
D:\resources\2.jpg
..\File-io-app\src\date.txt
2.jpg
date.txt
17803
15
1683708045368
最后修改时间:2023-05-10 16:40:45
1683709170653
最后修改时间:2023-05-10 16:59:30
true
false
true
false
false
true
true进程已结束，退出代码为 0
2.创建文件,删除文件功能
package com.wjh.d1_File;
import java.io.File;
import java.io.IOException;
public class FileDemo3 {
public static void main(String[] args) {
File f = new File("..\\File-io-app\\src\\date.txt");
//1.创建新文件,创建成功返回true,反之,不需要这个,以后写文件的时候都会自动创建
try {
System.out.println(f.createNewFile()); //false
} catch (IOException e) {
e.printStackTrace();
}
File f2 = new File("..\\File-io-app\\src\\date02.txt");
try {
System.out.println(f2.createNewFile()); //true
} catch (IOException e) {
e.printStackTrace();
}
//2.mkdir创建一个一级目录
File f3 = new File("D:/resources/aaa");
System.out.println(f3.mkdir()); //true
//3.mkdirs创建多级目录(重点)
File f4 = new File("D:/resources/aaa/bbb/ccc/ddd"); //4级
System.out.println(f4.mkdirs()); //true
//4.删除文件或者空文件夹
File f5 = new File("D:/resources/aaa/bbb/ccc/ddd"); //不进回收站
System.out.println(f5.delete()); //true
//只能删除空文件夹,不能删除非空文件夹
File f6 = new File("D:/resources");
System.out.println(f6.delete()); //false
}
}
false
false
false
true
true
false进程已结束，退出代码为 0
3.遍历文件夹
package com.wjh.d1_File;
import java.io.File;
import java.util.Arrays;
public class FileDemo4 {
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); //拿一级
/*
1.jpg
2.jpg
3.jpg
aaa
*/
}
//2.一级文件对象
//获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回(重点)
File[] files = f1.listFiles();
for (File file : files) {
System.out.println(file.getAbsolutePath()); //绝对路径
/*
D:\resources\1.jpg
D:\resources\2.jpg
D:\resources\3.jpg
D:\resources\aaa
*/
}
//注意事项
File dir = new File("D:/aaaaaa");
File[] files1 = dir.listFiles();
System.out.println(files1); //null
File dir2 = new File("D:/abcd");
File[] files2 = dir2.listFiles();
System.out.println(Arrays.toString(files2)); //[]
}
}
1.jpg
2.jpg
3.jpg
aaa
D:\resources\1.jpg
D:\resources\2.jpg
D:\resources\3.jpg
D:\resources\aaa
null
[]进程已结束，退出代码为 0
三.方法递归
1.递归的形式和特点
package com.wjh.d2_recusion;
public class RecursionDemo1 {
public static void main(String[] args) {
test(); //栈内存溢出
}
private static void test() {
System.out.println("=======test被执行!=======");
test2(); //方法递归:直接递归形式
}
private static void test2() {
System.out.println("=======tes2t被执行!=======");
test3(); //方法递归:间接递归形式
}
private static void test3() {
System.out.println("=======test3被执行!=======");
test(); //方法递归:间接递归形式
}
}
2.递归的算法流程,核心要素
package com.wjh.d2_recusion;
/*
目标:掌握递归的算法和执行流程
*/
public class RecursionDemo2 {
public static void main(String[] args) {
int n = f(5);
System.out.println(n); //120
}
public static int f(int n){
if(n == 1){
return 1;
}else{
return f(n - 1) * n;
}
}
}
120
进程已结束，退出代码为 0
3.递归常见案例
package com.wjh.d2_recusion;
import java.util.Scanner;
public class RecursionDemo3 {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
//计算1-n的和
System.out.println("请输入一个数字:");
int num = sc.nextInt();
int n = f(num);
System.out.println("1-n的和是:" + n);
}
private static int f(int num) {
if(num == 1){
return 1;
}else {
return f(num - 1) + num;
}
}
}
请输入一个数字:
5
1-n的和是:15进程已结束，退出代码为 0
4.递归的经典问题
package com.wjh.d2_recusion;
/*
猴子第一天摘下若干桃子，当即吃了一半，觉得好不过瘾，于是又多吃了一个
第二天又吃了前天剩余桃子数量的一半，觉得好不过瘾，于是又多吃了一个
以后每天都是吃前天剩余桃子数量的一半，觉得好不过瘾，又多吃了一个
等到第10天的时候发现桃子只有1个了。
需求：请问猴子第一天摘了多少个桃子？
分析：
整体来看，每一天都是做同一个事件，典型的规律化问题，考虑递归三要素：
递归公式：
递归终结点：
递归方向：
天 数 吃
1 n n/2+1 2^1
2 n/2-1 n/4+1 2^2
3 n/4-1 n/8+1 2^3
4 n/8-1 n/16+1 2^4
......
9 n/512+1 2^9
10 1 n/1024+1 2^10
n/512-1=1 n=1024
第一天(数) 吃 第二天(数)
公式(合理的):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 RecursionDemo4 {
public static void main(String[] args) {
int n = f(1);
System.out.println(n); //1534
for (int i = 10; i >= 1 ; i--) {
f(i);
System.out.println("第" + i + "天共有:" + f(i) + "个,吃了" + (f(i) / 2 + 1) + "个");
}
}
private static int f(int n) {
if(n == 10){
return 1;
}else{
return 2 * f(n + 1) + 2 ;
}
}
}
1534
第10天共有:1个,吃了1个
第9天共有:4个,吃了3个
第8天共有:10个,吃了6个
第7天共有:22个,吃了12个
第6天共有:46个,吃了24个
第5天共有:94个,吃了48个
第4天共有:190个,吃了96个
第3天共有:382个,吃了192个
第2天共有:766个,吃了384个
第1天共有:1534个,吃了768个进程已结束，退出代码为 0
5.非规律化递归案例-文件搜索
package com.wjh.d2_recusion;
/*
需求：
文件中有一个: (D:\360安全浏览器下载\GameBuff\locales\aaa\我在这.txt)
文件搜索、从D:盘中，搜索出某个文件名称并输出绝对路径。
分析：
先定位出的应该是一级文件对象
遍历全部一级文件对象，判断是否是文件
如果是文件，判断是否是自己想要的
如果是文件夹，需要继续递归进去重复上述过程
*/
import java.io.File;
import java.io.IOException;
public class RecursionDemo5 {
public static void main(String[] args) {
//搜索文件中有一个: (D:\360安全浏览器下载\GameBuff\locales\aaa\我在这.txt)
//1.传入目录和文件名
searchFile(new File("D:/"), "我在这.txt");
}
/**
* 1.搜索目录下的全部文件,找到想要的文件
* @param dir 被搜索的源目录
* @param fileName 被搜索的文件名
*/
public static void searchFile(File dir,String fileName){
//3.判断dir是否是目录
if(dir != null && dir.isDirectory()){
//文件不是空文件且是文件夹
//4.提取当前目录下的一级文件对象
File[] files = dir.listFiles();
//5.判断是否存在一级文件对象,存在才可以遍历
if(files != null && files.length > 0){
//6.开始遍历
for (File file : files) {
//6.5判断当前遍历一级文件对象是文件还是文件夹
if(file.isFile()){
//是否是我们要找的,是打印出绝对路径,结束
if(file.getName().contains(fileName)){
System.out.println("找到了:\n" + file.getAbsoluteFile());
//启动它:(只能启动.exe文件)
// try {
// Runtime r = Runtime.getRuntime(); //启动它
// r.exec(file.getAbsolutePath());
// } catch (IOException e) {
// e.printStackTrace();
// }
return;
}
}else{
//说明是文件夹,需要继续寻找
searchFile(file, fileName);
}
}
}
}else{
System.out.println("对不起,当前搜索的不是文件夹!");
}
}
}
找到了:
D:\360安全浏览器下载\GameBuff\locales\aaa\我在这.txt
666
6.非规律化递归案例-啤酒问题
package com.wjh.d2_recusion;
/*
需求：
啤酒2元1瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，
请问10元钱可以喝多少瓶酒，剩余多少空瓶和盖子。
答案：
15瓶 3盖子 1瓶子
分析:
*/
public class RecursionDemo6 {
public static int totalNumber; //记录买的啤酒
public static int totalButtle; //记录上次剩余的瓶子个数
public static int totalCover; //记录上次剩余的盖子个数
public static void main(String[] args) {
buy(10);
}
/**
* 进行买啤酒
* @param money
*/
private static void buy(int money) {
int buyNumber = money/2;
totalNumber += buyNumber;
//记录当前的瓶子个数、盖子个数
int buttle = totalButtle + buyNumber;
int cover = totalCover + buyNumber;
//将当前的瓶子和盖子转换为金钱，利用递归再次购买啤酒
int allMoney = 0;
//先判断瓶子和盖子的个数是否满足可以兑换的数量,
if (buttle >= 2){
allMoney += (buttle/2) * 2;
}
if (cover >= 4){
allMoney += (cover/4) * 2;
}
//并计算当前剩余的瓶子和盖子的数量
totalButtle = buttle % 2;
totalCover = cover % 4;
//进行判断是否进行递归操作
if (allMoney >= 2){
buy(allMoney);
}else {
System.out.println(totalNumber+"瓶酒\t\t"+totalButtle+"个瓶子\t\t"+totalCover+"个盖子");
}
}
}
15瓶酒 1个瓶子 3个盖子
进程已结束，退出代码为 0
四.字符集
1.常见字符集介绍
2.字符集的编码,解码操作
package com.wjh.d3_charset;
/*
目标:学会自己进行文字的编码和解码:为以后可能用到的场景做准备.
*/
import java.util.Arrays;
public class Test {
public static void main(String[] args) throws Exception{
//1.编码(把 文字 转化为 字节)
String name = "abc我爱你中国";
byte[] bytes = name.getBytes("GBK"); //以当前代码默认字符进行编码
byte[] bytes2 = name.getBytes(); //以当前代码默认字符进行编码(UTF-8)
System.out.println(bytes.length); //18
System.out.println(Arrays.toString(bytes)); //打印出位置
//[97, 98, 99, -50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
System.out.println(Arrays.toString(bytes2)); //
//[97, 98, 99, -26, -120, -111, -25, -120, -79, -28, -67, -96, -28, -72, -83, -27, -101, -67]
//2.解码:把字节抓换成中文形式(编码前 编码后的字符集必须一致,否则乱码!)
String rs = new String (bytes);
System.out.println(rs); //GBK中文乱码,英文不乱码
//abc�Ұ����й�
String rs2 = new String (bytes2); //默认UTF-8
System.out.println(rs2); //中文不乱码,英文不乱码
//abc我爱你中国abc我爱你中国
//指定解码器
String rs3 = new String (bytes,"GBK"); //指定GBK
System.out.println(rs3); //不乱码
//abc我爱你中国abc我爱你中国
String rs4 = new String (bytes2,"GBK"); //默认UTF-8
System.out.println(rs4); //乱码
//abc鎴戠埍浣犱腑鍥�
}
}
13
[97, 98, 99, -50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
[97, 98, 99, -26, -120, -111, -25, -120, -79, -28, -67, -96, -28, -72, -83, -27, -101, -67]
abc�Ұ����й�
abc我爱你中国
abc我爱你中国
abc鎴戠埍浣犱腑鍥�进程已结束，退出代码为 0
五.IO流概述
六.字节流的使用
1.字节输入流：每次读取一个字节
package com.wjh.d4_byte_Stream;
import java.io.*;
/*
*/
public class FileInputStreamDemo1 {
public static void main(String[] args) throws Exception {
//1.创建一个文件字节输入流管道,与原文件接通
//InputStream is = new FileInputStream(new File("../File-io-app/src/date.txt")); //多态
InputStream is = new FileInputStream("..\\File-io-app\\src\\date.txt"); //多态(简化写法)
//文档内容: abC
//2.读取一个字节返回(每次读取一个字节)
// int b1 = is.read();
// System.out.println(b1); //a -> 97 : 存编号
//
// int b2 = is.read();
// System.out.println(b2); //b -> 98
//
// int b3 = is.read();
// System.out.println((char)b3); //C -> 67
//
// int b4 = is.read();
// System.out.println(b4); // -1 : 文档内容长度流到最后了!
//3.使用循环改进
//定义一个变量记录每次读取的字节
// (由于UTF-8格式,一个中文汉字占用3个字节,所以这个方法不适用于有中文的文档,且读写速度很慢!)
int b;
while((b = is.read()) != -1 ){
System.out.print((char) b + " ");
}
}
}
a b C
进程已结束，退出代码为 0
2.字节输入流：每次读取一个字节数组
package com.wjh.d4_byte_Stream;
/*
目标:使用文件字节输入流每次读取一个字节
*/
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
public class FileInputStreamDemo2 {
public static void main(String[] args) throws Exception {
//ab3abccd
// //1.创建一个文件字节输入流管道与原文件接通
InputStream is = new FileInputStream("..\\File-io-app\\src\\date02.txt");
//
// //2.要定义一个字节数组,用于读取数据
// byte[] bytes = new byte[3]; //3B -> 一次流3个字节
// int len = is.read(bytes);
// System.out.println("读取了几个字节:" + len);
// String rs = new String(bytes); //解码
// System.out.println(rs);
//
// byte[] bytes2 = new byte[3]; //3B -> 一次流3个字节
// int len2 = is.read(bytes2);
// System.out.println("读取了几个字节:" + len2);
// String rs2 = new String(bytes2); //解码
// System.out.println(rs2);
//
// byte[] bytes3 = new byte[3]; //3B -> 一次流3个字节
// int len3 = is.read(bytes3);
// System.out.println("读取了几个字节:" + len3);
// String rs3 = new String(bytes3,0,len3); //解码
// // 构造器String(变量,初始位置,结束位置)
// //System.out.println(rs3); //cdc c -> 读的第二次的 c
// System.out.println(rs3); //cd -> 读多少倒多少
ab3abccd
//3.改进循环,每次一个字节数组(也不能避免中文乱码的问题!)
byte[] buffer = new byte[3];
int len; //记录每次读取的字节数.
while ((len = is.read(buffer)) != -1){
System.out.println(new String(buffer, 0, len));
// ab3
// abc
// cd
}
}
}
ab3
abc
cd进程已结束，退出代码为 0
3.字节输入流：读取文件的全部字节
package com.wjh.d4_byte_Stream;
/*
目标:使用文件字节输入流一次读完全部字节(可以解决中文乱码)
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class FileInputStreamDemo3 {
public static void main(String[] args) throws Exception {
//1.创建一个文件字节输入流管道与原文件接通
File f = new File("..\\File-io-app\\src\\DATE\\date3.txt");
InputStream is = new FileInputStream(f);
//2.定义一个字节数组与文件的大小一样大.
byte[] bytes = new byte[(int)f.length()];
int len = is.read(bytes);
System.out.println("读取了多少个字节:" + len);
System.out.println("文明大小:" + f.length());
System.out.println(new String(bytes));
//读取全部字节
byte[] bytes1 = is.readAllBytes();
System.out.println(new String(bytes1));
}
}
读取了多少个字节:43
文明大小:43
adfhj关键词sf公司电话dasf第三个fh
进程已结束，退出代码为 0
4.字节输出流：写字节数据到文件
package com.wjh.d4_byte_Stream;
/*
目标:使用文件字节输入流
*/
import java.io.*;
public class FileInputStreamDemo4 {
public static void main(String[] args) throws Exception {
//1.创建一个文件字节输入流管道与原文件接通
OutputStream os = new FileOutputStream("..\\File-io-app\\src\\DATE\\date5.txt");
//2.写数据进去
//a.public void write(int a) 写一个字节出去
os.write('a');
os.write(98);
//os.write('是');
os.write("\r\n".getBytes());
//b.public void write(byte[] buffer) 写一个字节数组出去
byte[] bytes = {'s', 98, 99, 'f'};
os.write(bytes);
os.write("\r\n".getBytes());
byte[] bytes1 = "s释放资源xfa".getBytes();
os.write(bytes1);
os.write("\r\n".getBytes());
//c.public void write(byte[] buffer , int pos , int len) 写一个字节数组的一部分出去。
byte[] bytes2 = {'q', 98, 99, 'f'};
os.write(bytes2,0,4);
os.write("\r\n".getBytes());
//刷新数据
os.flush();
//释放资源, 包含了刷新的!关闭后不能继续使用
os.close();
}
}
5.文件拷贝
package com.wjh.d4_byte_Stream;
/*
目标:学会使用字节流完成文件的复制(支持一切文件类型的复制)
*/
import java.io.*;
public class CopyDemo05 {
public static void main(String[] args) {
//1.创建一个字节输入流管道与原文件接通
try {
InputStream is = new FileInputStream("F:\\黑马程序员资料\\Java\\1、Java基础-20天学会Java\\1、课程全套PPT\\2、基础加强课全套PPT\\aaa.txt");
//2.创建一个自己输出流管道与目标文件接通
OutputStream os = new FileOutputStream("F:\\黑马程序员资料\\Java\\1、Java基础-20天学会Java\\new.txt");
//3.定义一个字节数组转移数据
byte[] bytes = new byte[1024];
int len; //记录每次读取的字节数
while((len = is.read(bytes)) != -1){
os.write(bytes,0, len);
}
System.out.println("复制完成");
//4.关闭流
os.close();
is.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
七.资源释放的方式
1.try-catch-finaly
package com.wjh.d5_resource;
import java.io.*;
/*
*/
public class TryCatchFinalDemo1 {
public static void main(String[] args) {
InputStream is = null;
OutputStream os = null;
//1.创建一个字节输入流管道与原文件接通
try {
//System.out.println(10/0);
is = new FileInputStream("F:\\黑马程序员资料\\Java\\1、Java基础-20天学会Java\\1、课程全套PPT\\2、基础加强课全套PPT\\aaa.txt");
//2.创建一个自己输出流管道与目标文件接通
os = new FileOutputStream("F:\\黑马程序员资料\\Java\\1、Java基础-20天学会Java\\new.txt");
//3.定义一个字节数组转移数据
byte[] bytes = new byte[1024];
int len; //记录每次读取的字节数
while((len = is.read(bytes)) != -1){
os.write(bytes,0, len);
}
System.out.println("复制完成");
} catch (Exception e) {
e.printStackTrace();
}finally {
//这里的代码,哪怕上面的代码有 return; 也必须执行这里
//如果这里加了return;返回的永远是finally里面的值
//无论代码是正常结束还是出现异常都要最后执行这里,除非虚拟机停止工作
System.out.println("=========finally=========");
//4.关闭流
try {
if(os != null){
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(is != null){
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.tiy-with-resource
JDK7
package com.wjh.d5_resource;
import java.io.*;
/*
*/
public class TryCatchResourceDemo2 {
public static void main(String[] args) {
try (
//这里面只能放资源对象,用完会自动关闭,自动调用资源对象的close方法关闭资源(即使出现异常也会做关闭操作！)
//1.创建一个字节输入流管道与原文件接通
InputStream is = new FileInputStream("F:\\黑马程序员资料\\Java\\1、Java基础-20天学会Java\\1、课程全套PPT\\2、基础加强课全套PPT\\aaa.txt");
//2.创建一个自己输出流管道与目标文件接通
OutputStream os = new FileOutputStream("F:\\黑马程序员资料\\Java\\1、Java基础-20天学会Java\\new.txt");
//int age = 23; 不是资源直接报错!
//可以自己写资源接口
MySql mySql = new MySql();
){
//System.out.println(10/0);
//3.定义一个字节数组转移数据
byte[] bytes = new byte[1024];
int len; //记录每次读取的字节数
while((len = is.read(bytes)) != -1){
os.write(bytes,0, len);
}
System.out.println("复制完成");
} catch (Exception e) {
e.printStackTrace();
}
}
}
class MySql implements AutoCloseable{
@Override
public void close() throws IOException {
System.out.println("文件资源被释放!");
}
}
JDK9
package com.wjh.d5_resource;
import java.io.*;
/*
*/
public class TryCatchResourceDemo3 {
public static void main(String[] args) throws Exception {
//这里面只能放资源对象,用完会自动关闭,自动调用资源对象的close方法关闭资源(即使出现异常也会做关闭操作！)
//1.创建一个字节输入流管道与原文件接通
InputStream is = new FileInputStream("F:\\黑马程序员资料\\Java\\1、Java基础-20天学会Java\\1、课程全套PPT\\2、基础加强课全套PPT\\aaa.txt");
//2.创建一个自己输出流管道与目标文件接通
OutputStream os = new FileOutputStream("F:\\黑马程序员资料\\Java\\1、Java基础-20天学会Java\\new.txt");
try (is;os){
//int age = 23; 不是资源直接报错!
//可以自己写资源接口
//System.out.println(10/0);
//3.定义一个字节数组转移数据
byte[] bytes = new byte[1024];
int len; //记录每次读取的字节数
while((len = is.read(bytes)) != -1){
os.write(bytes,0, len);
}
System.out.println("复制完成");
} catch (Exception e) {
e.printStackTrace();
}
}
}
八.字符流的使用
1.文件字符输入流 -> 一次读取一个字符
package com.wjh.d6_charstream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;
//目标: 每次读取一个字符
//原文件内容: 寂adfhj关键词sf公司电话dasf第三个fh
public class CharStreamDemo3 {
public static void main(String[] args) throws Exception {
//1.创建一个字符流输入管道与原文件接通
Reader fr = new FileReader("..\\File-io-app\\src\\DATE\\date.txt");
//2.读取一个字符返回,没有可读的字符返回-1
// int code = fr.read();
// System.out.println((char)code); //寂
//
// int code1 = fr.read();
// System.out.println((char)code1); //a
//3.使用循环读取字符
int code;
while ((code = fr.read()) != -1){
System.out.print((char) code);
}
}
}
2.文件字符输入流 -> 一次读取一个数组
package com.wjh.d6_charstream;
import java.io.FileReader;
import java.io.Reader;
//寂adfhj关键词sf公司电话dasf第三个fh
public class CharStreamDemo2 {
public static void main(String[] args) throws Exception{
//1.创建一个字符流输入管道与原文件接通
Reader fr = new FileReader("..\\File-io-app\\src\\DATE\\date.txt");
//2.循环,使用一个字符数组每次读取字符数组的数据 1024 + 1024 + 8
char[] chars = new char[1024]; //1K字符 -> 不是1KB
int len;
while((len = fr.read(chars)) != -1){
String rs = new String(chars,0 , len);
System.out.println(rs);
}
}
}
3.文件字符输出流
package com.wjh.d6_charstream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;
public class CharStreamDemo1 {
public static void main(String[] args) throws Exception{
//1.创建一个字符流输入管道与原文件接通
//Writer wr = new FileWriter("..\\File-io-app\\src\\DATE\\date09.txt"); //覆盖管道,每次启动都会清空文件之前的数据
Writer wr = new FileWriter("..\\File-io-app\\src\\DATE\\date09.txt", true); //追加管道,每次启动都会追加数据到文件后面
//a.void write(int c) 写一个字符
wr.write(98);
wr.write('a');
wr.write('是'); //不会出问题!
wr.write("\r\n");
//b.void write(char[] cbuf) 写入一个字符数组
char[] chars = "asdf第三方sdsa".toCharArray();
wr.write(chars);
wr.write("\r\n");
//c.void write(char[] cbuf, int off, int len) 写入字符数组的一部分
wr.write(chars, 3, 5);
wr.write("\r\n");
//d.void write(String str) 写一个字符串
wr.write("sdsa反倒是防控");
wr.write("\r\n");
//e.void write(String str, int off, int len) 写一个字符串的一部分
wr.write("sdsa反倒是防控", 0, 5);
wr.write("\r\n");
//wr.flush();//刷新,关闭可以继续使用
wr.close(); //关闭,关闭后不能使用
}
}
812
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
