一:File
1.1
File:文件和目录(文件夹)路径名的抽象表示形式。
1.2 File的构造方法:
File(String pathname):把一个路径名称封装成File对象
File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
package day12.edu_01;
import java.io.File;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) throws IOException {
//File(String pathname):把一个路径名称封装成File对象
// File file = new File("D://a.txt");
// System.out.println(file.createNewFile());//当文件不存在的时候,创建文件,如果文件存在,不创建
//File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
// File file = new File("D://test", "a.txt");
//java.io.IOException: 系统找不到指定的路径
// System.out.println(file.createNewFile());
//File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
File file = new File("D://test");
File file2 = new File(file,"a.txt");
System.out.println(file2.createNewFile());
}
}
1.3 创建功能:
A:创建文件
public boolean createNewFile():如果文件不存在,就创建。否则,不创建。
需求:D盘下造一个文件a.txt
B:创建目录
public boolean mkdir():如果目录不存在,就创建。否则,不创建。
需求:D盘下造一个文件夹test
public boolean mkdirs():如果目录不存在,就创建。否则,不创建。
即使父目录不存在,也可以连父目录一起创建。
需求:D盘下造一个文件夹(D:/aaa/bbb/ccc)
需求:D盘下造一个文件夹("D:\\ddd\\eee\\f.txt");
package day12.edu_02;
import java.io.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());
//public boolean mkdirs():如果目录不存在,就创建。否则,不创建。
//即使父目录不存在,也可以连父目录一起创建。
// File file = new File("D:\\ddd\\eee\\f.txt");
// System.out.println(file.mkdirs());
}
}
注意事项:
A:你要造什么东西,就应该用对应的方法。
1.4 删除功能:
public boolean delete():既可以删除文件,又可以删除目录。
路径问题:
A:绝对路径 就是以盘符开始的路径(d:\\test\\aaa\\b.txt)
B:相对路径 就是不以盘符开始的路径(a.txt)
一般都是相对应当前的项目而言的。
package day12.edu_02;
import java.io.File;
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());
}
}
注意事项:
A:Java程序的删除不走回收站。
B:如果目录内还有内容就不能删除。
1.5 判断功能
public boolean isDirectory():是否是目录
public boolean isFile():是否是文件
public boolean exists():是否存在
public boolean canRead():是否可读
public boolean canWrite():是否可写
public boolean isHidden():是否隐藏
package day12.edu_02;
import java.io.File;
import java.io.IOException;
public class FileDemo3 {
public static void main(String[] args) throws IOException {
File file = 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():获取名称
package day12.edu_02;
import java.io.File;
import java.io.IOException;
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());
//public String getPath():获取相对路径
System.out.println(file.getPath());//a.txt
//public String getName():获取名称
System.out.println(file.getName());
}
}
二:字节流及字节高效流
2.1 I/O流的分类(画图)
IO流分类:
流向:
输入流
输出流
数据类型:
字节流
字节输入流
字节输出流
字符流
字符输入流
字符输出流
注意:一般我们在讨论IO的分类时,默认是按照数据类型分的。
字节流:
字节输入流 InputStream(抽象类)
字节输出流 OutputStream(抽象类)
字符流:
字符输入流 Reader
字符输出流 Writer
学习习惯:
字节流
字符流
2.2
需求:请用字节流往一个文本文件中写一句话:”helloworld”。
分析:
首先要知道是字节流
写数据我们就应该知道是字节输出流
所以最终选择了OutputStream
而OutputStream是抽象类,所以我们应该找其子类
文件这个单词是File,所以我们就大胆的猜测下:FileOutputStream存在否。
我们如何往一个文件写数据呢?
或者说就是字节输出流的操作步骤是什么呢?
* A:创建字节输出流对象
* B:调用写数据的方法
* C:释放资源
做法:
A: 两个构造的区别?
FileOutputStream(File file)
FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream(“fos.txt”);
请问上面这个操作做了哪几件事情?
* 1.创建了一个文件输出流fos,指向文件a.txt
* 2.创建了a.txt这个文件
B: fos.write(“helloworld”.getBytes());
C: fos.close();关流
D: fos.write(“java”.getBytes());
package cokm.edu_01;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class OutputStreamDemo {
public static void main(String[] args) throws IOException {
/**
* 怎么使用文件输出流往文件中途写数据?
* 1.创建文件输出流对象
* 2.调用输出流对象的方法给文件中写数据
* 3.释放资源
*/
//public FileOutputStream(String name)
//public FileOutputStream(File file)
//创建文件输出流对象
FileOutputStream fos = new FileOutputStream("a.txt");
//public FileOutputStream(File file)
//File file = new File("a.txt");
//FileOutputStream fos = new FileOutputStream(file);
/**
* FileOutputStream fos = new FileOutputStream("a.txt");
* 做了那些事情?
* 1.创建fos对象指向文件a.txt
* 2.创建一个文件a.txt
*/
//调用输出流的写数据的方法给文件中写数据
//public void write(byte[] b)
byte[] byf = "helloworld".getBytes();
fos.write(byf);
//释放资源,关流操作
fos.close();
//关流之后,我们还能继续往文件中写数据码
//这样是不行的。。
//fos.write("java".getBytes());//java.io.IOException: Stream Closed
}
}
2.3
FileOutputStream写数据的方法
write(byte[] b)
write(int b) :一次写一个字节
write(byte[] b, int off, int len) :一次写一个字节数组的一部分
package cokm.edu_01;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class OutPutStreamDemo2 {
public static void main(String[] args) throws IOException {
/**
* 1.创建文件输出流对象,并关联指定文件
* 2.调用写书数据的方法,写书文件
* 3.关流
*/
//1.创建文件输出流对象,并关联指定文件
FileOutputStream fos = new FileOutputStream("b.txt");
//2.调用写书数据的方法,书写文件
//write(int b) :一次写一个字节
//fos.write(97);
//write(byte[] b, int off, int len) :一次写一个字节数组的一部分
byte[] byf = {97,98,99,100};
fos.write(byf, 1, 2);
//3.关流
fos.close();
}
}
2.4
字节输入流:
具体操作步骤:
字节输入流操作步骤:
A:创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");
B:调用方法读取数据
一次读取一个字节:read() -- 测试读取不到内容的时候的返回值(并且用循环改进)
C:释放资源
fis.close
package cokm.edu_02;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class InputStreamDmeo {
public static void main(String[] args) throws IOException {
//读取文件a.txt
//1.创建文件输入流对象,并关联文件
FileInputStream fis = new FileInputStream("a.txt");
//2.调用输入流的读取文件的方法,读取文件
//public int read() 一次读取一个字节
/* System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println(fis.read());
System.out.println(fis.read());*/
int by;
while ((by=fis.read())!=-1) {
System.out.println((char)by);
}
//3.释放资源
fis.close();
}
}
练习:
A:把a.txt的内容复制到b.txt中
package cokm.edu_03;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
public static void main(String[] args) throws IOException {
//A:把a.txt的内容复制到b.txt中
//封装数据源和目的地
FileInputStream fis = new FileInputStream("OutputStreamDemo.java");
FileOutputStream fos = new FileOutputStream("c.java");
//2.读取数据源中的数据,将读取到的数据写入目的地中
int by;
while ((by=fis.read())!=-1) {
//System.out.println(by);
//将读取到的字节写入fos中
fos.write(by);
}
//释放资源
fos.close();
fis.close();
}
}
B:把d:\复制视频文件
package cokm.edu_03;
import java.io.FileInputStream;
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("d.mp4");
//2.读取数据源,写如目的地
int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}
//3.释放资源
fos.close();
fis.close();
}
}
数据源:
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
package cokm.edu_04;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
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();
}
}
(利用一次读写一个字节数组完成)
练习:
A:把a.txt的内容复制到b.txt中
package cokm.edu_04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
public static void main(String[] args) throws IOException {
//A:把a.txt的内容复制到b.txt中
//1.封装数据源和目的地
FileInputStream fis = new FileInputStream("OutputStreamDemo.java");
FileOutputStream fos= new FileOutputStream("f.java");
//一次读写一个字节数组
byte[] byf = new byte[1024];
int len;
while ((len=fis.read(byf))!=-1) {
fos.write(byf, 0, len);
}
//3.关流
fos.close();
fis.close();
}
}
B:把d:\复制视频文件
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();
}
}
2.6
字节缓冲区流(也叫高效流):
BufferedInputStream(read() 一次读取一个字节, public int read(byte[] b):返回实际读取长度,数据被读取到数组中。)
BufferedOutputStream(write(byte[] b))
流
低级流: 基本的流,可以直接操作文件。
高级流:是操作基本流的流。
package cokm.edu_05;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException {
//一次读取一个字节数组的时候,复制一个mp4文件
//疯转数据源和目的地
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://b.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("j.mp4"));
//1.一次读写一个字节
/* int by;
while ((by=bis.read())!=-1) {
bos.write(by);
}*/
//2.一次读写一个字节数组
byte[] byf = new byte[1024];
int len;
while ((len = bis.read(byf))!=-1) {
bos.write(byf, 0, len);
}
//3.关流
bos.close();
bis.close();
}
}
2.6
字节流复制文件(视频文件,并测试所用时间):
A:基本字节流一次读写一个字节
B:基本字节流一次读写一个字节数组
C:高效字节流一次读写一个字节
D:高效字节流一次读写一个字节数组
获取时间的方法:
System.currentTimeMillis()
package cokm.edu_06;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
//复制文件开始之前的时间
long startTime = System.currentTimeMillis();
// method1();//A:基本字节流一次读写一个字节 15099
// method2();// B:基本字节流一次读写一个字节数组 31(这种处理方案使用的是最多的)
// method3();//C:高效字节流一次读写一个字节 234
method4();//D:高效字节流一次读写一个字节数组16
long endTime = System.currentTimeMillis();
System.out.println(endTime-startTime);
}
private static void method4() throws IOException {
// TODO Auto-generated method stub
//C:高效字节流一次读写一个字节
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://b.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.mp4"));
//高效字节流一次读写一个字节
byte[] byf = new byte[1024];
int len;
while ((len = bis.read(byf))!=-1) {
bos.write(byf, 0, len);
}
//3.关流
bos.close();
bis.close();
}
private static void method3() throws IOException {
//C:高效字节流一次读写一个字节
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://b.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.mp4"));
//高效字节流一次读写一个字节
int by;
while ((by = bis.read())!=-1) {
bos.write(by);
}
//3.关流
bos.close();
bis.close();
}
private static void method2() throws IOException {
// B:基本字节流一次读写一个字节数组
//封装数据源和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("a.mp4");
//一次读写一个字节
byte[] byf =new byte[1024];
int len;
while ((len=fis.read(byf))!=-1) {
fos.write(byf, 0, len);
}
//3.释放资源
fos.close();
fis.close();
}
private static void method1() throws IOException {
//A:基本字节流一次读写一个字节
//疯转数据剧院和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("a.mp4");
//一次读写一个字节
int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}
//3.释放资源
fos.close();
fis.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"));
结论:用什么编码,就必须用什么解码。
package cokm.edu_07;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class EncodingDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
//创建一个字符串
String s = "中国好";
//byte[] byf = s.getBytes();
//使用gbk去进行编码的时候,我们是将一个汉字编码成两个负数的字节。
//当我们解码的时候,如果字节数组中遇见负数的话,会将前面和后面的负数进行拼接,去gbk码表中找到相应的明文
//System.out.println(Arrays.toString(byf));
System.out.println("=---------------");
//byte[] bytes = s.getBytes("gbk");
//System.out.println(Arrays.toString(bytes));
System.out.println("------------");
byte[] bytes = s.getBytes("utf-8");
//当使用uft-8进行编码的时候,一个汉字会被编码成3个负数的字节
//解码的时候,一旦遇见负数,三个拼接,去码表中进行解码
System.out.println(Arrays.toString(bytes));
System.out.println("--------------");
System.out.println(new String(bytes));//涓浗濂?
System.out.println(new String(bytes, "utf-8"));//中国好
//结论:咱们以后使用哪种编码就使用哪种解码(编解码方式必须一致,不然会出现乱码)
//我们以后编解码方式一般来说不需要指定特定的码表,一般来说使用默认的就可以
}
}