异常
异常的分类:
- 异常(Exception):合理的应用程序可能需要捕获的问题 (可预料)
- 错误(Error):合理的应用程序不应该试图捕获的问题 (不可预料)
异常的处理方式:
try……catch(finally)
:捕获,自己处理
try{
//尝试执行的代码
}catch(Exception e){
//出现可能的异常之后的处理代码
}finally{
//一定会执行的代码,如关闭资源
}
throw
:抛出,交给调用者处理,执行程序后,程序不再执行
public void 方法名() throws Exception{
}
//处理方法1:接着抛出
//处理方法2:try……catch{}
IO流概述
- 按数据流分类:输入流,输出流
- 按操作方式分类:
字节流:
InputStream(FileInputStream , BufferedInputStream) ,
OutputStream(FileOutputStream , BufferedOutputStream)
字符流:
Reader(FileReader , BufferReader)
Writer(FileWriter , BufferWriter)
File类
构造方法:
File(String pathname)
File(String parent,String child)
File(File parent,String child)
成员方法:
createNewFile()
:创建文件mkdir()和mkdirs()
:创建目录isDirectory()
:判断File对象是否为目录isFile()
:判断File对象是否为文件exists()
:判断File对象是否存在getAbsolutePath()
:获取绝对路径(C:/1.txt)getPath()
:获取文件的相对路径(1.txt)getName()
:获取文件名list()
:获取指定目录下的所有文件(夹)名称数组listFiles()
:获取指定目录所有文件(夹)File数组
Test类:(创建和判断功能)
package File类;
import java.io.File;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
//需求:将C:\PAG\1.txt封装成File对象
//方式一:根据字符串形式的路径获取File对象
//File file1 = new File("C:\\PAG\\1.txt");
File file1 = new File("C:/PAG/1.txt");
System.out.println("file1:" + file1);
//方式二:根据字符串形式的父目录以及子目录创建File对象
File file2 = new File("C:/PAG/","1.txt");
System.out.println("file2:" + file2);
//方式三:根据父目录对象,以及字符串形式的子目录来获取File对象
File file3 = new File("C:/PAG/");
File file4 = new File(file3,"1.txt");
System.out.println("file4:" + file4);
System.out.println("----------------------------");
System.out.println("测试建立功能");
//需求:在C盘PAG文件中创建一个2.txt文件
File file5 = new File("C:/PAG/2.txt");
boolean flag1 = file5.createNewFile();
System.out.println("flag1:" + flag1);
//需求:在C盘下创建a文件夹
File file6 = new File("C:/a");
boolean flag2 = file6.mkdir(); //make directory,创建单级目录
System.out.println("flag2:" + flag2);
//需求:在C盘下创建a/b/c文件夹
File file7 = new File("C:/a/b/c");
boolean flag3 = file7.mkdirs(); //创建多级目录,也可创建单级目录
System.out.println("flag3:" + flag3);
System.out.println("----------------------------");
System.out.println("测试判断功能");
File file8 = new File("C:/PAG/1.txt");
/* boolean flag4 = file8.isDirectory();
System.out.println("测试File8是否是文件夹:" + flag4);*/
System.out.println("测试file8是否是文件夹:" + file8.isDirectory());
System.out.println("测试file8是否是文件:" + file8.isFile());
System.out.println("测试file8是否存在:" + file8.exists());
}
}
运行结果:
file1:C:\PAG\1.txt
file2:C:\PAG\1.txt
file4:C:\PAG\1.txt
----------------------------
测试建立功能
flag1:true
flag2:true
flag3:true
----------------------------
测试判断功能
测试file8是否是文件夹:false
测试file8是否是文件:true
测试file8是否存在:true
Process finished with exit code 0
Test(获取功能):
package File类;
import java.io.File;
public class Test2 {
public static void main(String[] args) {
File file1 = new File("lib/1.txt");
//获取文件的绝对路径
String path1 = file1.getAbsolutePath();
System.out.println("绝对路径:" + path1);
//获取文件的相对路径
String path2 = file1.getPath();
System.out.println("相对路径:" + path2);
//获取文件名
String file1Name = file1.getName();
System.out.println("文件名:" + file1Name);
System.out.println("---------------------------");
//获取lib文件下的所有文件(夹)的:名称数组String[]
File file2 = new File("lib");
String[] names = file2.list();
for (String name :names){
System.out.println(name);
}
System.out.println("---------------------------");
//获取lib文件下的所有文件(夹)的:File对象数组File[]
File[] files = file2.listFiles();
for (File file : files){
System.out.println(file);
}
}
}
运行结果:
绝对路径:C:\Users\PAG\Desktop\Java\lib\1.txt
相对路径:lib\1.txt
文件名:1.txt
---------------------------
1.txt
a
---------------------------
lib\1.txt
lib\a
字符流读写文件
读文件
-
创建字符流读文件对象:
Reader reader = new FileReader("readma.txt");
-
调用方法读取数据:
int data = reader.read();
读取一个字符,返回该字符代表的整数,若到达流的末尾,返回-1 -
调用方法读取数据:
char [] chs = new char[2048];int len = r.read(chs);
读取字符到数组中,返回读取的字符数,若达到流的末尾,返回-1 -
异常处理:
throw IOException
-
关闭资源:
reader.close();
Test1:(每次读取一个字符)
package 字符流;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
//1.txt内为abc
public class Test {
public static void main(String[] args) throws IOException {
//需求:通过字符流读取数据
//1.创建字符流输入流对象
Reader reader = new FileReader("lib/1.txt");
//2.读取数据
/* int ch1 = reader.read();
System.out.println(ch1); //97*/
int ch;
/*
(ch =reader.read()) != -1
1.执行reader.read(),去文件中读取一个字符
2.执行ch = reader.read(),将读取到的字符赋值给变量
3.(ch =reader.read()) != -1,用读取到的字符(内容)和-1进行比较
*/
while ((ch =reader.read()) != -1){
//ch = reader.read();
System.out.println(ch); //结果为97,98,99
}
//3.释放资源
reader.close();
}
}
Test2:(每次读取一个字符数组)
package 字符流;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
//1.txt内为abcdefg
public class Test1 {
public static void main(String[] args) throws IOException {
//需求:通过字符流读取数据,一次读取一个字符数组
//1.创建字符输入流对象
Reader reader = new FileReader("lib/1.txt");
//2.读取数据
/* char[] chs = new char[3];
int len1 = reader.read(chs);
System.out.println(chs); //a,b,c
System.out.println(len1); //3
int len2 = reader.read(chs);
System.out.println(chs); //d,e,f
System.out.println(len2); //3
int len3 = reader.read(chs);
System.out.println(chs); //g,e,f
System.out.println(len3); //1
int len4 = reader.read(chs);
System.out.println(chs); //g,e,f
System.out.println(len4); //-1*/
//定义字符数组
char[] chs = new char[3];
//定义一个变量,记录读取到的有效字符数
int len;
while ((len = reader.read(chs)) != -1){
//将读取到的内容,转换成字符串,然后打印
/*
chs:表示要操作的数组
0:表示起始索引
len:表示要操作的字符的个数
*/
String s = new String(chs,0,len);
System.out.println(s); //运行结果:abc def g
}
//3.释放资源
reader.close();
}
}
写文件
-
创建字符流写文件对象:
Writer writer = new FileWriter("dest.txt");
-
调用方法写入数据:
int x = '中';writer.write(x);
写一个字符 -
调用方法写入数据:
char[] chs = {'1','2','3','4'’}; writer,write(chs);
写一个字符数组 -
调用方法写入数据:
writer.write("PAG针不戳!");
写一个字符串 -
异常处理:
throw IOException
-
关闭资源:
writer.close();
Test:
package 字符流;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Test2 {
public static void main(String[] args) throws IOException {
//需求:通过字符流,写数据
//1.创建字符输出流对象
Writer writer = new FileWriter("lib/1.txt");
//2.写数据
//一次写一个字符
//writer.write("好");
//一次写一个指定的字符数组
/*char[] chs = {'P','A','G','针','不','戳'};
writer.write(chs,2,3);*/
//一个写一个字符串
writer.write("PAG针不戳");
//3.释放资源
writer.close();
}
}
拷贝文件
-
创建字符流读文件对象:
Reader reader = new FileReader("readma.txt");
-
创建字符流写文件对象:
Writer writer = new FileWriter("dest.txt");
-
调用方法读取数据1:
int data = reader.read();
-
调用方法写入数据1:
writer.write(data);
-
调用方法读取数据2:
char[] chs = new char[2048];int len = reader.read(chs);
-
调用方法写入数据2:
writer.write(chs,0,len);
-
异常处理:
throw IOException
-
关闭资源:
reader.close(); writer.close();
Test1(一个字符):
package 字符流;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test1 {
public static void main(String[] args) throws IOException {
//需求:通过字符流拷贝文件,一次读写一个字符
/*
IO流拷贝文件核心步:
1.创建字符输入流文件,关联数据源文件
2.创建字符输出流文件,关联目的地文件
3.定义变量,记录读取到的内容
4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量
5.将读取到的数据写入到目的地文件中
6.释放资源
*/
//Reader reader = new FileReader("lib/1.txt");
FileReader fr = new FileReader("lib/1.txt");
// Writer writer = new FileWriter("lib/2.txt");
FileWriter fw = new FileWriter("lib/2.txt");
int len;
while ((len = fr.read()) != -1){
fw.write(len);
}
fr.close();
fw.close();
}
}
Test2(一个字符数组):
package 字符流;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
//需求:通过字符流拷贝文件,一次读写一个字符数组
/*
IO流拷贝文件核心步:
1.创建字符输入流文件,关联数据源文件
2.创建字符输出流文件,关联目的地文件
3.定义变量,记录读取到的内容
4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量
5.将读取到的数据写入到目的地文件中
6.释放资源
*/
//Reader reader = new FileReader("lib/1.txt");
FileReader fr = new FileReader("lib/1.txt");
// Writer writer = new FileWriter("lib/2.txt");
FileWriter fw = new FileWriter("lib/2.txt");
//定义一个字符数组
char[] chs = new char[1024];
//用来记录读取到的有效字符数
int len;
while ((len = fr.read(chs)) != -1){
fw.write(chs,0,len);
}
fr.close();
fw.close();
}
}
字符缓冲流拷贝文件
-
创建字符流读文件对象:
BufferedReader br = new BufferedReader (new FileReader("readma.txt"));
-
创建字符流写文件对象:
BufferedWriter bw = new BufferedWriter(new FileWriter("dest.txt"));
-
使用while循环读写数据:
int len; while((len = br.read())!=-1){bw.write(len);}
-
异常处理:
throw IOException
-
关闭资源:
br.close(); bw.close();
Test1:
package 字符流;
import java.io.*;
//字符缓冲流自带有缓冲区,大小为8192个字节,也就是16KB
public class Test1 {
public static void main(String[] args) throws IOException {
//需求:通过字符缓冲流,将1.txt文件中的内容拷贝到2.txt文件夹中
//1.创建字符缓冲流输入流对象,关联数据源文件
BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
//2.建立字符缓冲输出流对象,关联目的地文件
BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));
//3.定义变量,记录读取到的数据
int len;
//4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量
while ((len = br.read()) != -1){
//5.将读取到的数据写入到目的地文件中
bw.write(len);
}
//6.释放资源
br.close();
bw.close();
}
}
Test2(一次读一行):
package 字符流;
import java.io.*;
//字符缓冲流自带有缓冲区,大小为8192个字节,也就是16KB
//字符流只能拷贝纯文本文件
public class Test2 {
public static void main(String[] args) throws IOException {
//需求:通过字符缓冲流,将1.txt文件中的内容拷贝到2.txt文件夹中
//1.创建字符缓冲流输入流对象,关联数据源文件
BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
//2.建立字符缓冲输出流对象,关联目的地文件
BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));
//3.定义变量,记录读取到的数据
String str;
//4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量
while ((str = br.readLine()) != null){
//5.将读取到的数据写入到目的地文件中
bw.write(str);
//注意换行 window:\r\n mac:\r unix:\n
bw.newLine();
}
//6.释放资源
br.close();
bw.close();
}
}
字节流
读写文件
- 创建字节流读文件对象:
InputStream is = new FileInputStream("Desktop.jpg");
- 创建字节流写文件对象:
OutputStream os = new FileOutputStream("C:/桌面.jpg");
- 使用while循环读写数据:
int b;while((b=is.read()!=-1)){os.write(b);}
- 异常处理:
throws IOException
- 关闭资源:
is.close(); os.close();
Test1:
package 字节流;
import java.io.*;
public class Test1 {
public static void main(String[] args) throws IOException {
//需求:通过普通的字节流,一次读写一个字节的方式,将a.jpg复制到b.jpg中
//1.创建字节流读文件对象
FileInputStream fis = new FileInputStream("lib/a.jpg");
//2.创建字节流写文件对象
FileOutputStream fos = new FileOutputStream("lib/b.jpg");
//3.定义变量,用来记录读取到的内容
int len;
//4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量
while ((len = fis.read()) != -1){
//5.将读取到的内容写入到目的地文件中
fos.write(len);
}
//6.释放资源
fis.close();
fos.close();
}
}
拷贝文件
- 创建字节流读文件对象:
InputStream is = new FileInputStream("Desktop.jpg");
- 创建字节流写文件对象:
OutputStream os = new FileOutputStream("C:/桌面.jpg");
- 定义字节数组,每次读取2048个字节:
byte[] b = new byte[2048];
- 使用while循环读写数据:
int b;while((b=is.read()!=-1)){os.write(0,b,len);}
- 异常处理:
throws IOException
- 关闭资源:
is.close(); os.close();
Test1:
package 字节流;
import java.io.*;
public class Test1 {
public static void main(String[] args) throws IOException {
//需求:通过普通的字节流,一次读写一个字节数组的方式,将a.jpg复制到b.jpg中
//1.创建字节流读文件对象
FileInputStream fis = new FileInputStream("lib/a.jpg");
//2.创建字节流写文件对象
FileOutputStream fos = new FileOutputStream("lib/b.jpg");
//3.定义变量,用来接收读取到的内容
byte[] bys = new byte[1024];
//用来记录读取到的有效字节数
int len;
//4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量
while ((len = fis.read(bys)) != -1){
//5.将读取到的内容写入到目的地文件中
fos.write(bys,0,len);
}
//6.释放资源
fis.close();
fos.close();
}
}
缓冲流拷贝文件
-
创建字节流读文件对象:
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Desktop.jpg")) ;
-
创建字节流写文件对象:
BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream("C:/桌面.jpg")) ;
-
使用while循环读写数据:
int len;while((len=bis.read()!=-1)){bos.write(len);}
-
异常处理:
throws IOException
-
关闭资源:
bis.close(); bos.close();
Test1:
package 字节流;
import java.io.*;
//拷贝纯文本文件使用字符流,拷贝其他(图片,音频,视频等)使用字节流
public class Test2 {
public static void main(String[] args) throws IOException {
//需求:通过字节缓冲流,将a.jpg复制到b.jpg中
//1.创建字节输入流对象,关联数据源文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("lib/a.jpg"));
//2.创建字节输出流对象,关联目的地文件
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("lib/b.jpg"));
//3.定义变量,用来记录读取到的内容
int len;
//4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量
while ((len = bis.read()) != -1){
//5.将读取到的内容写入到目的地文件中
bos.write(len);
}
//6.释放资源
bis.close();
bos.close();
}
}