文章目录
1 File类
1.1 File类的概述
File:文件和目录路径名的抽象表示形式
也就是说文件和目录是可以通过File封装成对象的
目录：其实就是文件夹
1.2 File类的构造方法
File(String pathname):通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。File(String parent, String child):根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。File(File parent, String child):根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实
代码演示
package com.twy.test.test8_17;
import java.io.File;
public class FileDemo {
public static void main(String[] args) {
//File(String pathname)
File f1 = new File("G:\\BigData\\test\\a.txt");
//File(String parent,String child)
File f2 = new File("G:\\BigData\\test","a.txt");
File(File parent,String child)
File f3 = new File("G:\\BigData\\test");
File f4 = new File(f3,"a.txt");
//以上f1,f2,f4做的是同一件事
}
}
1.3 File类的成员方法
-
public boolean createNewFile():创建文件
如果文件不存在，创建文件并返回true
如果文件存在，创建文件失败并返回false -
public boolean mkdir():创建目录
如果目录不存在，创建目录并返回true
如果目录存在，创建目录失败并返回false -
public boolean mkdirs():创建多级目录
-
public boolean delete():删除文件和目录
如果一个目录中有内容(目录，文件)，就不能直接删除。
应该先删除目录中的内容，最后才能删除目录。
- 判断功能
- public boolean isDirectory():判断是否是目录
- public boolean isFile():判断是否是文件
- public boolean exists():判断是否存在
- 获取功能
- public String getAbsolutePath():获取绝对路径
- public String getPath():获取相对路径
- public String getName():获取名称
绝对路径：是以盘符开始的路径。d:\aa\b.txt
相对路径：不以盘符开始。相对于当前的项目而言，在项目的目录下。如何显示出来呢？刷新项目就可以了。
代码演示
package com.twy.test.test8_17;
import java.io.File;
import java.io.IOException;
public class FileDemo2 {
public static void main(String[] args) throws IOException {
File f1 = new File("G:\\a.txt");
System.out.println(createFile(f1));
File f2 = new File("G:\\BigData\\test2");
System.out.println(f2.mkdirs());
File f3 = new File("a.txt");
f3.createNewFile();
//删除功能public Boolean delete()
boolean delete = f1.delete();
System.out.println(delete);
//判断是否是目录
boolean directory = f1.isDirectory();
System.out.println(directory);
//判断是否是文件
boolean file = f1.isFile();
System.out.println(file);
//判断是否存在
boolean exists = f1.exists();
System.out.println(exists);
//获取绝对路径
String absolutePath = f3.getAbsolutePath();
System.out.println(absolutePath);
//获取相对路径
String path = f3.getPath();
System.out.println(path);
//获取名称
String name = f3.getName();
System.out.println(name);
}
public static Boolean createFile(File f) throws IOException {
return f.createNewFile();
}
}
2 IO(字节流)
2.1 IO流的概述
2.1.1 什么是IO流，其作用是？
IO可以拆开来理解
I — Input – 输入 —相对java程序为读取
O — Output – 输出 —相对java程序为写出
读取和写出都是针对数据而言的, 所以, IO流就是用来处理设备之间的数据传输
常见应用于：文件复制，文件上传。文件下载
2.1.2 IO流的分类
按照类型分:
字节流
字符流 (字符流数据通过Windows自带的记事本软件打开是可以读懂里面内容的)
按照流向分:
输入流 : 用来读取数据的:
输出流 : 用来写出数据的
2.1.3 字节流&字符流的抽象父类
字节流：
InputStream 字节输入流
OutputStream 字节输出流
字符流：
Reader 字符输入流
Writer 字符输出流
2.2 FileOutputStream写数据
字节流写数据
OutputStream:此抽象类是表示输出字节流的所有类的超类
FileOutputStream:文件输出流是用于将数据写入 File
构造方法：
FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的输出文件流。
字节流写数据的步骤：
A:创建字节输出流对象
B:调用写数据的方法
C:释放资源
代码演示
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("a.txt");
//写内容
fos.write(65);
fos.write(97);
//释放资源
fos.close();
}
2.2.1 FileOutputStream写数据的三种方法
三种方法：
public void write(int b):一次写一个字节
public void write(byte[] b):一次写一个字节数组
public void write(byte[] b,int off,int len):一次写一个字节数组的一部分
String类中的方法：
byte[] getBytes() 将字符串转换为字节数组
代码演示
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("a.txt");
FileOutputStream fos2 = new FileOutputStream("b.txt");
//写内容
fos.write(55);
//写内容void write(byte[] by)
byte[] by = {97,98,99,100};
fos.write(by);
fos.write("hello".getBytes());
//void write(byte[] b,int off.int len)
fos2.write(by,1,by.length-1);
//释放资源
fos.close();
}
2.2.2 FileOutputStream如何实现换行和追加写数据
2.2.2.1 如何实现数据的换行
不同的操作系统，针对换行的符号识别是不一样的。
windows:\r\n
linux:\n
mac:\r
2.2.2.2 如何实现数据的追加写入
FileOutputStream(String name)此构造函数，每次启动程序，写入的数据都是相同的
FileOutputStream(String name, boolean append) 此构造函数，每次启动程序，当第二个参数为true时，写入的数据可以与上次的数据拼接，实现追加
代码演示
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("a.txt",true);
//实现换行和追加
for (int i = 0; i < 5; i++) {
fos.write("abcde".getBytes());
fos.write("\r\n".getBytes());
}
//释放资源
fos.close();
}
2.2.3 FileOutputStream写数据加入异常处理
格式
try{
可能发生问题的代码
}catch(){
处理异常代码
}finally{
一定会被执行的代码. // 通常用于释放资源, 做善后的动作
}
代码演示
FileOutputStream fos = null;
try {
fos = new FileOutputStream("G://a.txt",true);
fos.write("sssdfgfg".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
finally {
if(fos!=null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
注意：在释放资源时，要判断对象是否为空，如果为空，则说明写入数据为成功，字节输入流对象任为空，系统释放资源时将会报空指针异常
2.3 FileInputStream读数据
2.3.1 字节流读取数据的三个步骤
字节流读数据的步骤：
A:创建字节输入流对象
B:调用读数据的方法
C:释放资源
2.3.2 读取方式一
public static void main(String[] args) throws IOException {
//1.创建输出流对象
FileInputStream fis = new FileInputStream("a.txt");
//2.读出字节流
int read = fis.read();
System.out.println((char)read);
//3.释放资源
fis.close();
}
2.3.3 读取方式二
public int read(byte[] b):
从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
返回值是读入缓冲区的字节总数，也就是实际的读取个数
如果因为已经到达文件末尾而没有更多的数据，则返回 -1。
public static void main(String[] args) throws IOException {
//1.创建输出流对象
FileInputStream fis = new FileInputStream("a.txt");
File file = new File("b.txt");
FileInputStream fis2 = new FileInputStream(file);
//1.
int read = 0;
while( (read = fis2.read())!=-1){
System.out.println((char)read);
}
System.out.println("-------------------");
//2.
byte[] by = new byte[1024];
int len;
while ((len = fis.read(by))!=-1){
System.out.println(new String(by,0,len));
}
//3.释放资源
fis.close();
}
读取的字符数组的元素用String的一个构造函数转换为字符串类型，输出
2.4 字节流练习之复制文本文件
需求： 拷贝文本文件
分析：
第一步: 创建输入输出流对象关联数据源和数据目的
第二步: 定义字节数组,为了提高效率
第三步: 将数据通过while循环不断读取到字节数组中
第四步: 将数据从字节数组中取出并写出
第五步: 释放资源
package com.twy.test.test9_io_17;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyTextDemo {
public static void main(String[] args) throws IOException {
//创建字节流对象
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("c.txt");
//将读取到的数据内容写入c.txt
byte[] by = new byte[1024];
int lens;
while ((lens = fis.read(by))!= -1){
fos.write(by,0,lens);
}
//3.释放资源
fis.close();
fos.close();
}
}
2.5 字节流练习之复制图片
package com.twy.test.test9_io_17;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyJpgDemo {
public static void main(String[] args) throws IOException {
//1.创建读写对象
FileInputStream fis = new FileInputStream("G:\\联想漂亮锁屏\\1.jpg");
FileOutputStream fos = new FileOutputStream("a.jpg");
//2.读写
byte[] by = new byte[1024];
int lens;
while ((lens = fis.read(by))!= -1){
fos.write(by,0,lens);
}
//3.释放资源
fos.close();
fis.close();
}
}
2.6 字节缓冲区流
2.6.1 字节缓冲区流的概述和使用
2.6.1.1 字节缓冲流的作用是?
字节流一次读写一个数组的速度比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想，所以提供了字节缓冲区流
- 字节缓冲流 :
- BufferedOutputStream:字节缓冲输出流
- BufferedInputStream:字节缓冲输入流
2.6.1.2 为什么字节缓冲流的构造方法需要传入一个OutputStream
字节缓冲区流仅仅提供缓冲区，而真正的底层的读写数据还得需要基本的流对象进行操作。
代码演示
public class BufferedStreamDemo {
public static void main(String[] args) throws IOException {
// BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
//方式1：一次读取一个字节
// int by;
// while((by=bis.read())!=-1) {
// System.out.print((char)by);
// }
//方式2：一次读取一个字节数组
byte[] bys = new byte[1024];
int len;
while((len=bis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
//释放资源
bis.close();
}
}
2.6.2 字节流四种方式复制AVI并测试效率
package com.twy.test.test10_io_18;
//分析：
/* 1.public static long currentTimeMillis():返回以毫秒为单位的当前时间。开始结束时间，做差输出
2.定义4个方法，分别记录其复制文件所用时间
3.method1():字节流一次读取一个字节输出
4.method2():字节流一次读取一个字节数组输出
5.method3():缓冲字节流一次读取一个字节数组输出
6.method4():缓冲字节流一次读取一个字节数组输出
*
*
* */
import java.io.*;
public class CopyAviTest {
public static void main(String[] args) throws IOException {
//设置记录时间开始
long l = System.currentTimeMillis();
//调用方法
// method1(); //86075毫秒
// method2(); // 225 毫秒
// method3(); //476 毫秒
method4(); // 39 毫秒
//设置结束时间记录
long l1 = System.currentTimeMillis();
System.out.println(l1-l);
}
//基本字节流一次输出一个字节
private static void method1() throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("a.flv");
//封装目的地
FileOutputStream fos = new FileOutputStream("b.flv");
//复制文件
int len;
while ((len = fis.read())!= -1){
fos.write((char)len);
}
//释放内存
fis.close();
fos.close();
}
//基本字节流一次输出一个字节数组
private static void method2() throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("a.flv");
//封装目的地
FileOutputStream fos = new FileOutputStream("b.flv");
//复制文件
byte[] by = new byte[1024];
int len;
while ((len = fis.read(by))!= -1){
fos.write(by,0,len);
}
//释放内存
fis.close();
fos.close();
}
//缓冲流基本字节流一次输出一个字节
private static void method3() throws IOException {
//封装数据源
BufferedInputStream fis = new BufferedInputStream(new FileInputStream("a.flv"));
//封装目的地
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("b.flv"));
//复制文件
int len;
while ((len = fis.read())!= -1){
fos.write((char)len);
}
//释放内存
fis.close();
fos.close();
}
//缓冲区字节流一次输出一个字节数组
private static void method4() throws IOException {
//封装数据源
BufferedInputStream fis = new BufferedInputStream(new FileInputStream("a.flv"));
//封装目的地
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("b.flv"));
//复制文件
byte[] by = new byte[1024];
int len;
while ((len = fis.read(by))!= -1){
fos.write(by,0,len);
}
//释放内存
fis.close();
fos.close();
}
}
总结：字节数组相比一次一个字节输出快，缓冲区相对非缓冲区要快，当字节数组与缓冲区同时使用时，效率最高
扫一扫
978
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
