File~
三种构造方法:File(String pathname):把一个路径名称封装成File对象
File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
功能:创建与删除 获取及判断功能。
代码演示
public class FileDemo {
public static void main(String[] args) {
//public boolean mkdir():如果目录不存在,就创建。否则,不创建。
//需求:D盘下造一个文件夹test
//File file = new File("D://test");
//System.out.println(file.mkdir());
System.out.println("----------");
//public boolean mkdirs():如果目录不存在,就创建。否则,不创建。
//即时父目录不存在,也可以连父目录一起创建。
//File file = new File("D://aa//bb//a.txt");
//System.out.println(file.mkdirs());
} 创建功能注意点:你要造什么东西,就应该用对应的方法。
}
public class FileDemo2 {
public static void main(String[] args) {
//删除D://a.txt
//File file = new File("D://a.txt");
//System.out.println(file.delete());
//删除D://test//a.txt
//File file = new File("D://test//a.txt");
//System.out.println(file.delete());
//删除D://test,删除文件夹的时候只能删除空的文件夹
File file = new File("D://test");
System.out.println(file.delete());
}删除注意点:Java程序的删除不走回收站以及如果目录内还有内容就不能删除。
判断功能~
public boolean isDirectory():是否是目录 public boolean isFile():是否是文件 public boolean exists():是否存在
public boolean canRead():是否可读 public boolean canWrite():是否可写 public boolean isHidden():是否隐藏
public class FileDemo4 {
public static void main(String[] args) throws IOException {
//创建一个文件
File file = new File("a.txt");
//创建一个文件
//System.out.println(file.createNewFile());
// public String getAbsolutePath():获取绝对路径
System.out.println(file.getAbsolutePath());//D:\workspace\十二天_File\a.txt
//public String getPath():获取相对路径
System.out.println(file.getPath());//a.txt
//public String getName():获取名称
System.out.println(file.getName());
}
} 获取部分 代码
字节流及字节高效流~
图解IO流
字符输入流 Reader 字节输入流 InputStream(抽象类)
字符输出流 Writer 字节输出流 OutputStream(抽象类)
FileOutputStream(File file)
FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");
请问上面这个操作做了哪几件事情?
* 1.创建了一个文件输出流fos,指向文件a.txt
* 2.创建了a.txt这个文件
fos.write("helloworld".getBytes());
FileOutputStream写数据的方法
write(byte[] b)
write(int b) :一次写一个字节
write(byte[] b, int off, int len) :一次写一个字节数组的一部分
字节输入流:
具体操作步骤:
* 字节输入流操作步骤:
* A:创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");
* B:调用方法读取数据
一次读取一个字节:read() -- 测试读取不到内容的时候的返回值(并且用循环改进)
* C:释放资源
fis.close
* A:把a.txt的内容复制到b.txt中
* C:把d:\\复制视频文件
* 数据源:
* IODemo.java -- 读取数据 -- InputStream -- FileInputStream -- 一次读取一个字节
* 目的地:
* Copy.java -- 写出数据 -- OutputStream -- FileOutputStream -- 一次写一个字节
字节输入流:
具体操作步骤:
* 字节输入流操作步骤:
* A:创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");
* B:调用方法读取数据(一次读取一个字节数组,提升效率)
一次读取一个字节数组: public int read(byte[] b):返回实际读取长度,数据被读取到数组中。
-- 测试方法返回长度?根据String类的构造方法构造字符串
* C:释放资源
fis.close
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
//读取a.txt中的文件
//1.创建文件输入流
FileInputStream fis = new FileInputStream("a.txt");
//一次读取一个字节数组
/* byte[] bys= new byte[4];
System.out.println(fis.read(bys));//读取到的是字节数组的实际长度
System.out.println(fis.read(bys));
System.out.println(fis.read(bys));
System.out.println(fis.read(bys));*/
//创建一个字节数组,一般来说字节数组的长度都是1024或者1024的倍数
byte[] bys= new byte[1024];
int len;//实际读取到的长度
while ((len=fis.read(bys))!=-1) {
//只需要将实际读取到的长度转换为字符串就可以
System.out.println(new String(bys, 0, len));
}
//3.关流
fis.close();
}
}
package cokm.edu_04;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyMp4 {
public static void main(String[] args) throws IOException {
//一次读写一个字节数组
//1.封装数据源和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("e.mp4");
//一次读写一个字节数组
byte[] bys = new byte[1024];
int len;
while ((len=fis.read(bys))!=-1) {
//读取多少就给fos中写多少数据
fos.write(bys, 0, len);
}
//释放资源
fos.close();
fis.close();
}
}
字节缓冲区流(也叫高效流)~
BufferedOutputStream(write(byte[] b))
低级流: 基本的流,可以直接操作文件。 高级流:是操作基本流的流。
BufferedReader:字符缓冲输入流: BufferedWriter:字符缓冲输出流
BufferedReader(Reader in) BufferedWriter(Writer out)
public String readLine():包含该行内容的字符串, 特殊方法:public void newLine():会根据系统来确定写入不同的换行符
不包含任何行终止符,如果已到达流末尾,
则返回 null
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
/**
* 需求:使用高效字符输入流读取f.txt文件
* 1.创建高效字符输入流对象,指向f.txt
* 2.一次读取一行,readLine()
* 3.关流
*/
//1.创建高效字符输入流对象,指向f.txt
//BufferedReader(Reader in)
BufferedReader br = new BufferedReader(new FileReader("f.txt"));
//2.一次读取一行,readLine(),当读取文件末尾的时候返回null
/* System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());
System.out.println(br.readLine());*/
//使用循环改进
String line;
while ((line= br.readLine())!=null) {
System.out.println(line);
}
//3.关流
br.close();
}
}
public class BufferedWriterDemo2 {
public static void main(String[] args) throws IOException {
//使用高效字符输出流写入10个helloworld,每写一个换一行
/**
* 1.创建字符高效输出流,并指向一个txt文件
* 2.调用里面写数据的方法,给文件中写入数据
* 3.调用换行的方法,给写入的数据换行
* 4.刷新换新区
* 5.关流
*/
//1.创建字符高效输出流,并指向一个txt文件
BufferedWriter bw = new BufferedWriter(new FileWriter("f.txt"));
//2.调用里面写数据的方法,给文件中写入数据
for (int i = 0; i < 10; i++) {
//给文件中写入helloworld
bw.write("helloworld");
//写入换行符
bw.newLine();
//刷新缓冲区
bw.flush();
}
//关流
bw.close();
}
}
编码问题
String中的编码和解码问题。
*
* 编码:
* 把我们能够看懂的字符转换为看不懂的数据
* 解码:
* 把我们看不懂的数据转换为看得懂的字符
public byte[] getBytes(String charsetName) 按照给定的编码方式,编码字节数组(gbk,utf-8)
String(byte[] bytes, String charsetName) 按照给定的编码方式解码字符数组
String s = "中国好";
byte[] bytes = s.getBytes("utf-8");
System.out.println(Arrays.toString(bytes));
//String(byte[] bytes, String charsetName)
System.out.println(new String(bytes,"gbk"));
注意:有什么编码 就用什么解码
异常:
* 编译时期异常:程序运行之前
* 运行时期异常:成运行起来之后
*
*体系结构:
* Throwable:
* Error:错误
* Exception:异常
* 非RuntimeException:
* RuntimeException:
异常演示:除数不能为0
ublic class ExceptionDemo2 {
public static void main(String[] args) {
System.out.println("start");
int a = 10;
int b = 0;
System.out.println(a/b);//java.lang.ArithmeticException: / by zero
System.out.println("end");
}
}
Exception in thread "main" start
java.lang.ArithmeticException: / by zero
异常的处理方式:A:try...catch...finally
B:throws
简化第一个:
* try{
* 可能出现异常的代码
* }catch(异常类名 变量名) {
* 针对异常的代码处理
public class ExceptionDemo3 {
public static void main(String[] args) {
System.out.println("start");
int a= 10;
int b = 0;
try{
//可能出现异常的代码
System.out.println(a/b);//当除数为0的时候会抛出ArithmeticException这个异常
//接着程序会拿着这个异常和catch里面的异常类已经对比
}catch(ArithmeticException e){
//当程序抛出ArithmeticException这个异常之后给出的具体的处理方法
System.out.println("你的除数不能为0");
}
System.out.println("end");
}
}
多个异常的处理:A:针对每一个出现问题的地方写一个try...catch语句
B:针对多个异常,采用一个try,多个catch的情况。
try...catch...catch...
注意点:如果异常间有子父关系,父类必须再后
public class ExceptionDemo4 {
public static void main(String[] args) {
//多个异常处理的第一种解决方案
//A:给每一个可能出现异常的代码全部加上try..catch..
/* try{
System.out.println(10/0);
}catch(ArithmeticException e){
System.out.println("除数不能为0");
}
int[] arr = {1,2,3};
try{
System.out.println(arr[3]);//抛出IndexOutOfBoundsException这个异常
}catch(IndexOutOfBoundsException e){
System.out.println("数组越界了");
}*/
//B:针对多个异常,采用一个try,多个catch的情况。
//当存在多个catch情况下,如果异常类之间存在子父关系,那么父类应该放到最后
int[] arr = {1,2,3};
try{
//System.out.println(arr[3]);//抛出IndexOutOfBoundsException
//System.out.println(10/0);//抛出ArithmeticException
arr = null;
System.out.println(arr[2]);//抛出空指针异常NullpointerException
}catch(IndexOutOfBoundsException e){//Exception e = new IndexOutOfBoundsException();
System.out.println("数组越界了");
}catch(ArithmeticException e){
System.out.println("除数不能为0");
}catch(Exception e){//当前面的异常类都没有匹配到之后,会自动匹配这个异常
System.out.println("出现了其他异常");
}
}
}
throws:(演示文件未找到异常,除数为0异常) * 用在方法声明后面,跟的是异常类名 * 可以跟多个异常类名,用,号隔开 * 表示抛出异常,由该方法的调用者来处理 * throws表示出现异常的一种可能,并不一定会发生这些异常 */ public class ExceptionDemo7 { public static void main(String[] args){ method(); //method2();//将这个异常交给了调用者去进行处理 //1.可以继续往上throws,将异常继续向上进行抛出了 //2.自己try..catch...,相当与自己处理了这个异常 try{ method2(); }catch(FileNotFoundException e){ System.out.println("文件未找到"); } /** * 我们以后遇到异常是抛还是抓呢? * 答:原则上能抛就抛,等到已经抛到了程序最底层的时候,最好就不要抛了,自己抓取。 */ } private static void method2() throws FileNotFoundException { //此时会抛出一个编译时期的异常, //我们必须在方法上进行声明,如果不声明的话,会一直编译报错 FileInputStream fis = new FileInputStream("D://a.txt"); } private static void method() throws ArithmeticException { //在方法声明上声明这个方法可能出现的异常,不代表这个异常一定会出现 //此时仅仅是告诉我的调用者我的这个方法可能会出现异常,并不做具体的处理,交给 //调用者自己去处理这个异常 //此时抛出的 出数为0的异常,属于运行时期异常 System.out.println(10/5); } }
hrow和throws的区别?
* throws:
* 用在方法声明后面,跟的是异常类名
* 可以跟多个异常类名,用逗号隔开
* 表示抛出异常,由该方法的调用者来处理
* throws表示出现异常的一种可能性,并不一定会发生这些异常
*
* throw:
* 用在方法体内,跟的是异常对象名
* 只能抛出一个异常对象名
* 表示抛出异常,由方法体内的语句处理
* throw则是抛出了异常,执行throw则一定抛出了某种异常?
public class ThrowDemo {
public static void main(String[] args) {
method();
try {
method2();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
private static void method2() throws FileNotFoundException{
try{
FileInputStream fis = new FileInputStream("D://a.txt");
}catch(FileNotFoundException e){
//当遇见这个异常之后,直接抛出(这就是我给出的处理方法)
//如果【抛出的是编译时期异常的话,必须在方法声明上给予声明
throw new FileNotFoundException();
}
}
private static void method() throws ArithmeticException{
int a = 10;
int b = 2;
if (b==0) {
//在这里抛出的是运行时期异常,抛出这个异常的同时,可以在方法声明上给予声明,也可以不声明
throw new ArithmeticException();
}else {
System.out.println(a/b);
}
}
}
public class ThrowDemo {
public static void main(String[] args) {
method();
try {
method2();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
private static void method2() throws FileNotFoundException{
try{
FileInputStream fis = new FileInputStream("D://a.txt");
}catch(FileNotFoundException e){
//当遇见这个异常之后,直接抛出(这就是我给出的处理方法)
//如果【抛出的是编译时期异常的话,必须在方法声明上给予声明
throw new FileNotFoundException();
}
}
private static void method() throws ArithmeticException{
int a = 10;
int b = 2;
if (b==0) {
//在这里抛出的是运行时期异常,抛出这个异常的同时,可以在方法声明上给予声明,也可以不声明
throw new ArithmeticException();
}else {
System.out.println(a/b);
}
}
}