一：File
1.1
File:文件和目录(文件夹)路径名的抽象表示形式。
1.2
File的构造方法：
File(String pathname):把一个路径名称封装成File对象
File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
1.3
创建功能：
A:创建文件
public booleancreateNewFile():如果文件不存在，就创建。否则，不创建。
需求：D盘下造一个文件a.txt
B:创建目录
public boolean mkdir():如果目录不存在，就创建。否则，不创建。
需求：D盘下造一个文件夹test
public booleanmkdirs():如果目录不存在，就创建。否则，不创建。
即时父目录不存在，也可以连父目录一起创建。
需求：D盘下造一个文件夹(D:/aaa/bbb/ccc)
需求：D盘下造一个文件夹("D:\\ddd\\eee\\f.txt");
package com.edu_01;
import java.io.File;
import java.io.IOException;
/**
1.1
File:文件和目录(文件夹)路径名的抽象表示形式。
1.2
File的构造方法：
File(String pathname):把一个路径名称封装成File对象
File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
*
*/
public class FileDemo {
publicstatic void main(String[] args) throws IOException {
//File(Stringpathname):把一个路径名称封装成File对象
//Filefile = new File("D://a.txt");
//System.out.println(file.createNewFile());//当文件不存在的时候，创建文件，如果文件存在，不创建
System.out.println("------------");
//File(Stringparent, String child):把一个父路径和一个子路径封装成一个File对象
//Filefile = new File("D://test", "a.txt");
//java.io.IOException:系统找不到指定的路径,
//创建文件的时候一定要保证路径存在
//System.out.println(file.createNewFile());
System.out.println("-----------------");
//File(Fileparent, String child):把一个父路径File对象和一个子路径封装成一个File对象
Filefile = new File("D://test");
Filefile2 = new File(file, "a.txt");
System.out.println(file2.createNewFile());
}
}
注意事项：
A:你要造什么东西，就应该用对应的方法。
1.4
删除功能：
public boolean delete():既可以删除文件，又可以删除目录。
路径问题：
A:绝对路径 就是以盘符开始的路径(d:\\test\\aaa\\b.txt)
B:相对路径 就是不以盘符开始的路径(a.txt)
一般都是相对应当前的项目而言的。
注意事项：
A:Java程序的删除不走回收站。
B:如果目录内还有内容就不能删除。
1.5
判断功能
public boolean isDirectory():是否是目录
public boolean isFile():是否是文件
public boolean exists():是否存在
public boolean canRead():是否可读
public boolean canWrite():是否可写
public boolean isHidden():是否隐藏
package com.edu_02;
import java.io.File;
import java.io.IOException;
/**
* 1.5
判断功能
public boolean isDirectory():是否是目录
public boolean isFile():是否是文件
public boolean exists():是否存在
public boolean canRead():是否可读
public boolean canWrite():是否可写
public boolean isHidden():是否隐藏
*/
public class FileDemo3 {
publicstatic void main(String[] args) throws IOException {
//在D://a.txt
Filefile = new File("D://a.txt");
//System.out.println(file.createNewFile());
System.out.println("是否是目录:"+file.isDirectory());
System.out.println("是否是文件:"+file.isFile());
System.out.println("是否存在:"+file.exists());
System.out.println("是否可读:"+file.canRead());
System.out.println("是否可写:"+file.canWrite());
System.out.println("是否隐藏:"+file.isHidden());
}
}
1.6获取功能
public String getAbsolutePath():获取绝对路径
public String getPath():获取相对路径
public String getName():获取名称
二：字节流及字节高效流
2.1 I/O流的分类
* IO流分类：
* 流向：
* 输入流
* 输出流
* 数据类型：
* 字节流
* 字节输入流
* 字节输出流
* 字符流
* 字符输入流
* 字符输出流
*
* 注意：一般我们在讨论IO的分类时，默认是按照数据类型分的。
*
* 字节流：
* 字节输入流 InputStream(抽象类)
* 字节输出流 OutputStream（抽象类）
* 字符流：
* 字符输入流 Reader
* 字符输出流 Writer
*
* 学习习惯：
* 字节流
* 字符流
*
2.2
* 需求：请用字节流往一个文本文件中写一句话："helloworld"。
* 分析：
* 首先要知道是字节流
* 写数据我们就应该知道是字节输出流
* 所以最终选择了OutputStream
* 而OutputStream是抽象类，所以我们应该找其子类
* 文件这个单词是File，所以我们就大胆的猜测下：FileOutputStream存在否。
*
* 我们如何往一个文件写数据呢?
* 或者说就是字节输出流的操作步骤是什么呢?
* A:创建字节输出流对象
* B:调用写数据的方法
* C:释放资源
package cokm.edu_01;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 2.2
* 需求：请用字节流往一个文本文件中写一句话："helloworld"。
* 分析：
* 首先要知道是字节流
* 写数据我们就应该知道是字节输出流
* 所以最终选择了OutputStream
* 而OutputStream是抽象类，所以我们应该找其子类
* 文件这个单词是File，所以我们就大胆的猜测下：FileOutputStream存在否。
*
* 我们如何往一个文件写数据呢?
* 或者说就是字节输出流的操作步骤是什么呢?
* A:创建字节输出流对象
* B:调用写数据的方法
* C:释放资源
*
*/
public class OutputStreamDemo {
publicstatic void main(String[] args) throws IOException {
/**
* 怎么使用文件输出流往文件中途写数据？
* 1.创建文件输出流对象
* 2.调用输出流对象的方法给文件中写数据
* 3.释放资源
*/
//publicFileOutputStream(String name)
//publicFileOutputStream(File file)
//创建文件输出流对象
FileOutputStreamfos = new FileOutputStream("a.txt");
//publicFileOutputStream(File file)
//Filefile = new File("a.txt");
//FileOutputStreamfos = new FileOutputStream(file);
/**
* FileOutputStream fos = newFileOutputStream("a.txt");
* 做了那些事情？
* 1.创建fos对象指向文件a.txt
* 2.创建一个文件a.txt
*/
//调用输出流的写数据的方法给文件中写数据
//publicvoid write(byte[] b)
byte[]byf = "helloworld".getBytes();
fos.write(byf);
//释放资源,关流操作
fos.close();
//关流之后，我们还能继续往文件中写数据码
//这样是不行的。。
//fos.write("java".getBytes());//java.io.IOException:Stream Closed
}
}
做法：
A： 两个构造的区别？
FileOutputStream(File file)
FileOutputStream(Stringname)
FileOutputStreamfos = newFileOutputStream("fos.txt");
请问上面这个操作做了哪几件事情？
* 1.创建了一个文件输出流fos,指向文件a.txt
* 2.创建了a.txt这个文件
B： fos.write("helloworld".getBytes());
C: fos.close();关流
D： fos.write("java".getBytes());
2.3
FileOutputStream写数据的方法
write(byte[] b)
write(int b) ：一次写一个字节
write(byte[] b, int off, int len) ：一次写一个字节数组的一部分
2.4
字节输入流：
具体操作步骤：
* 字节输入流操作步骤：
* 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 -- 一次写一个字节
2.5
字节输入流：
具体操作步骤：
* 字节输入流操作步骤：
* A:创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");
* B:调用方法读取数据（一次读取一个字节数组，提升效率）
一次读取一个字节数组：public int read(byte[] b):返回实际读取长度,数据被读取到数组中。
-- 测试方法返回长度？根据String类的构造方法构造字符串
* C:释放资源
fis.close
2.5
* 字节缓冲区流（也叫高效流）：
* BufferedInputStream(read() 一次读取一个字节,public int read(byte[] b):返回实际读取长度,数据被读取到数组中。)
* BufferedOutputStream（write(byte[]b)）
*
* 流
* 低级流: 基本的流，可以直接操作文件。
* 高级流：是操作基本流的流。
2.6
* 字节流复制文件：
* A:基本字节流一次读写一个字节
* B:基本字节流一次读写一个字节数组
* C:高效字节流一次读写一个字节
* D:高效字节流一次读写一个字节数组
获取时间的方法：
System.currentTimeMillis()
三：编码问题？？
*String中的编码和解码问题。
*
* 编码：
* 把我们能够看懂的字符转换为看不懂的数据
* 解码：
* 把我们看不懂的数据转换为看得懂的字符
*
* 举例：
* 电报/潜伏(余则成 深海)
*
* 编码表：
* 小本子，这个本子上记录了很多的汉字和对应的数据值。
*
* 延安：
* 今晚兴庆公园见
*
* 发报员：
* 今晚兴庆公园见
* 转换成数据
* 发送数据
*
* 余则成：
* 接收数据
* 记录完毕后，就找出小本子，通过对应的数据值找到对应的字符
* 今晚兴庆公园见
public byte[] getBytes(StringcharsetName) 按照给定的编码方式，编码字节数组（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(newString(bytes,"gbk"));
结论：用什么编码，就必须用什么解码。。
异常：
1.1
异常：就是程序出现的不正常的情况。
* 异常：
* 错误：这是非常严重的问题，一般我们处理不了,一般在这里指的是硬件问题。
* 异常：
* 编译时期异常 开始就必须要处理的，如果不处理，后面就走不了。
* 运行时期异常 开始可以不用处理。这种问题一旦发生，就是我们的程序问题，需要我们修改程序。
*
* 体系结构：
*Throwable：
* Error：
* Exception：
* 非RuntimeException：编译时期异常
* RuntimeException：运行时期异常
* 异常演示：
* 除数不能为0
*
*java.lang.ArithmeticException: / by zero
*
* 针对异常，JVM默认的处理方案：
* 一旦遇到程序出现了问题，就会把问题的类名，错误原因，错误的位置等信息打印在控制台，以便我们观察。
* 并且，会自动从当前出问题的地方停止掉。
*
* 这种处理方案虽然可以，但是不够好。
* 哪里不好呢?
* 其实程序出问题，不应该直接停止，因为我们的程序可能是由多部分组成的，
* 其中一个部分出问题了，不应该影响其他部分的执行。
* 所以，我们应该想办法让其他的部分能够执行下去。
1.2
* 我们是如何处理异常，保证各个部分不影响的呢?
* 两种方案：
* A:try...catch...finally
* B:throws
*
*try...catch...finally:
* try{
* 可能出现异常的代码
* }catch(异常类名 变量名) {
* 针对异常的代码处理
* }finally {
* 释放资源的地方
* }
*
* 我们简化一下第一个：
*try{
* 可能出现异常的代码
* }catch(异常类名 变量名) {
* 针对异常的代码处理
* }
package com.edu_01;
/**
* * 我们是如何处理异常，保证各个部分不影响的呢?
* 两种方案：
* A:try...catch...finally
* B:throws
*
* try...catch...finally:
* try{
* 可能出现异常的代码
* }catch(异常类名变量名) {
* 针对异常的代码处理
* }finally{
* 释放资源的地方
* }
*
* 我们简化一下第一个：
* try{
* 可能出现异常的代码
* }catch(异常类名变量名) {
* 针对异常的代码处理
* }
*
*/
publicclass ExceptionDemo3 {
publicstaticvoid 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");
}
}
1.3
* 多个异常的处理(演示数组索引越界异常，除数为0异常)
* A:针对每一个出现问题的地方写一个try...catch语句
* B:针对多个异常，采用一个try，多个catch的情况。
* try...catch...catch...
*
* 遇到try里面的问题，就自动和catch里面进行匹配。
* 一旦匹配就执行catch里面的内容，执行完毕后，接着执行后面的代码。
*
* 注意：
* 如果异常间有子父关系，父必须在最后。
1.4
* 编译时期异常和运行时期异常的区别:
* 编译时期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译
* FileNotFoundException（文件未找到异常）
* 运行时期异常：无需显示处理，也可以和编译时异常一样处理
* ArithmeticException
1.5
*Throwable中的方法：(演示除数为0异常)
*printStackTrace():打印异常信息，程序从出问题的地方开始就会打印创建一个该异常对应的对象，
该对象直接调用打印方法
1.6（演示编译器异常，运行期异常）
*try...catch 是直接进行了处理。
* 而throws则是把异常处理的事情交给了调用者。
*
*throws用在方法上，声明方法有异常，交给调用者处理。
* 但是呢，如果是编译时期异常，调用就必须处理。
* 如果是运行时期异常，调用者可以处理，也可以不处理。
1.7
*throws:(演示文件未找到异常，除数为0异常)
* 用在方法声明后面，跟的是异常类名
* 可以跟多个异常类名，用,号隔开
* 表示抛出异常，由该方法的调用者来处理
* throws表示出现异常的一种可能，并不一定会发生这些异常
1.8
* 异常处理：
*try...catch...finally
*
*finally:一般用于释放资源。在数据库操作或者IO流比较常见。
*
* 特点：
* 被finally控制的语句体一定会执行
*
* 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
1.9
*finally相关的面试题:
*final,finally的区别?
* final:最终的意思。可以修饰类，方法，变量。
* 修饰类，类不能被继承
* 修饰方法，方法不能被重写
* 修饰变量，变量是常量
* finally:
* 异常处理的一部分。被finally控制的代码一定会执行。
* 特殊情况：在执行到finally之前，jvm退出了。
1.9.1
* 注意：
* A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
* B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
上述仅仅针对编译时期异常
与运行时期异常无关。
1.9.2
throw和throws的区别？
*throws:
* 用在方法声明后面，跟的是异常类名
* 可以跟多个异常类名，用逗号隔开
* 表示抛出异常，由该方法的调用者来处理
* throws表示出现异常的一种可能性，并不一定会发生这些异常
*
*throw:
* 用在方法体内，跟的是异常对象名
* 只能抛出一个异常对象名
* 表示抛出异常，由方法体内的语句处理
* throw则是抛出了异常，执行throw则一定抛出了某种异常?
案例演示：演示编译时期异常(文件未找到异常)和运行时期异常(除数为0异常)使用上的区别
*throw:
* 如果throw的是编译时期异常，在方法声明上必须用throws进行标记
* 如果throw的是运行时期异常，在方法声明上可以用throws进行标记，也可以不用。
package com.edu_03;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
/**
* throw和throws的区别？
*throws:
* 用在方法声明后面，跟的是异常类名
* 可以跟多个异常类名，用逗号隔开
* 表示抛出异常，由该方法的调用者来处理
* throws表示出现异常的一种可能性，并不一定会发生这些异常
*
*throw:
* 用在方法体内，跟的是异常对象名
* 只能抛出一个异常对象名
* 表示抛出异常，由方法体内的语句处理
* throw则是抛出了异常，执行throw则一定抛出了某种异常?
*
*/
public class ThrowDemo {
publicstatic void main(String[] args) {
method();
try{
method2();
}catch (FileNotFoundException e) {
e.printStackTrace();
}
}
privatestatic void method2() throws FileNotFoundException{
try{
FileInputStreamfis = new FileInputStream("D://a.txt");
}catch(FileNotFoundExceptione){
//当遇见这个异常之后，直接抛出(这就是我给出的处理方法)
//如果【抛出的是编译时期异常的话，必须在方法声明上给予声明
thrownew FileNotFoundException();
}
}
privatestatic void method() throws ArithmeticException{
inta = 10;
intb = 2;
if(b==0) {
//在这里抛出的是运行时期异常，抛出这个异常的同时，可以在方法声明上给予声明，也可以不声明
thrownew ArithmeticException();
}else{
System.out.println(a/b);
}
}
}
时间： 2024-10-25 20:15:30