文章目录
前言
干就完事~~
以下是本篇文章正文内容,下面案例可供参考
一、文件【File】的基本操作
由于涉及到文件【File】的知识点很少也非常简单,我就直接上案例了 里面有具体的注释,今天的重点是I/O流。
案例如下:
import java.io.File;
import java.text.SimpleDateFormat;
public class Test01 {
public static void main(String[] args) {
/**
* 知识点:File类(文件类)
*
* 含义:是文件和目录路径名(文件夹)的抽象表示
*
* 注意:File只关注文件本身的信息,而不能操作文件里面的内容
*
* 需求1:通过程序,获取已知文件的信息
*/
//创建File类的对象
File file=new File("C:\\Users\\雍仲\\Desktop\\编码王子的宝库.txt");
System.out.println("获取绝对路径:"+file.getAbsolutePath());
System.out.println("获取文件名字:"+file.getName());
System.out.println("该文件是否可读:"+file.canRead());
System.out.println("该文件是否可写:"+file.canWrite());
System.out.println("是否隐藏:"+file.isHidden());
System.out.println("获取文件长度(字节):"+file.length());
System.out.println("判断是否为文件:"+ file.isFile());
//最后修改时间
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("最后修改的时间:"+sdf.format(file.lastModified()));
/**
* 知识点:File类(文件类)
*
* 含义:是文件和目录路径名(文件夹)的抽象表示
*
* 注意:File只关注文件本身的信息,而不能操作文件里面的内容
*
* 理解:绝对路径 和 相对路径
*
* 相对路径:相对于项目的路径
* 绝对路径:路径中包含盘符(具体路径)
*/
//test.txt -> 相对路径
File file = new File("test.txt");
//绝对路径 -> C:\2107workspace\Day22\test.txt
System.out.println("获取绝对路径:" + file.getAbsolutePath());
}
}
文件的层级遍历与创建文件
import java.io.File;
import java.io.IOException;
public class Test03 {
public static void main(String[] args) throws IOException {
/**
* 知识点:File类
*
* 需求2:通过程序,判断指定路径的文件是否存在,如果不存在,则创建该文件
* 下面按各种情况来解决该问题
* 1)目录已存在的情况
* 2)有一个层级的目录不存在的情况
* 3)有多个层级的目录不存在的情况
*/
File file = new File("file01\\file02\\file03\\test.txt");
//获取父路径对象(file01\\file02\\file03)
File parentFile = file.getParentFile();
if(!parentFile.exists()){//文件夹不存在
//创建多层文件夹
parentFile.mkdirs();
}
if(!file.exists()){//文件不存在
//创建文件
file.createNewFile();
}
}
}
二、I/O流部分
(1)、什么是I/O流
概念图:
I: InputStream:是所有输入流的基类,是一个抽象类。
O:OutputStream:是所有输出流的基类,同样也是一个抽象类
流:一种比较抽象的概念,类似于水管,由于数据的传入与传出是一点一点地输出,类似于将水库中的水通过水管一点一点地送到家里,最后关闭水龙头(在流的操作中最后一步需要用.close方法来关闭流对象就类似于关水龙头)
注意:此处所说的输入流与输出流是站在程序的角度上来看,从程序往外输出便是输出流(OutputStream),同理如果是从外向程序里输入数据便是输入流(InputStream)。
理解图:
(2)、流的分类
2.1 按单位分:
- 字节流:以字节为单位,可以读写所有数据
- 字符流:以字符为单位,只能读写文本数据
2.2 按功能分:
- 节点流:具有实际传输数据的读写功能
- 过滤流:再借点流的基础上增强功能
2.3按方向分:
- 输入流:将<存储设备>中的内容读入到<内存>中。
- 输出流:将<内存>中的内容写入到<存储设备>中。
三、流的详解
(1)字节流:
(2)字节节点流
2.1 FileOutputStream(底层继承于OutputStream):
public void write(byte [ ] b)//一次性写多少个字节,将数组 b 中所有字节写入到输出流。后面有案例
2.2 FileInputStream (底层继承于InputStream):
public int read(byte [ ] b) //从流中读取多个字节,将读到的内容存入b数组,返回实际独到的字节数;如果达到文件的尾部,则返回 -1.后面案例演示
案例演示:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Copy02 {
public static void main(String[] args) throws IOException {
/**
* 需求:拷贝文本文件 - 读一个字节写一个字节
* 1)抛异常的方式
* 以1024位一个单位来读取
*/
//创流对象
FileInputStream fis=new FileInputStream("io.txt");
FileOutputStream fos=new FileOutputStream("copyio02.txt");
//读取数据
byte [] bs = new byte[1024];
int len;
while ((len=fis.read(bs))!=-1){
fos.write(bs,0,len);
}
//关闭流
fis.close();
fos.close();
}
}
(3)字节过滤流
3.1缓冲流:BufferedOutputStream/BufferedInputStream
缓冲流:带有一个缓冲区,其默认的缓冲区的大小为(8192个字节)
其继承关系如下图所示:
BufferedOutputStream继承于FilterOutputStream(过滤字节输出流)
案例如下:
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test01 {
public static void main(String[] args) throws IOException {
/**
* 知识点:BufferedOutputStream 带有缓冲区的字节输出流
* 需求:利用带有缓冲区的字节输出流向文件写入数据
* 特点:输出流的共有特点就是,没有输出的对象位置文件的时候可以自动创建,如果是输入流就会报错
*/
//方式一、使用默认缓冲区(8192个字节大小)
//1、创建流对象
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("io.txt"));
//在文件末尾追加数据
//2、写入数据
bos.write("我是雍仲杨".getBytes());
//3、关闭水管(流对象)
bos.close();
//方式二、使用自定义长度的缓冲区(大小:10000个字节)
//1、创建流对象
BufferedOutputStream bos2=new BufferedOutputStream(new FileOutputStream("io.txt"),10000);
//2、读写数据
bos2.write("这是第二个方式创建的缓冲输出流,自定义了10000个字节长度".getBytes());
//3、关闭流对象
bos2.close();
//方式三、在文件末尾追加数据的方式
//1、创建流
BufferedOutputStream bos03=new BufferedOutputStream(new FileOutputStream("io.txt"));
//2、读写数据
bos03.write("这是第三种方式".getBytes());
//3、关闭流
bos03.close();
}
}
提示:自定义的方式创建缓冲流虽然可以创建缓冲区更大的流但是完全没有必要,默认的空间大小(8192)完全够用了。
BufferedInputStream继承于FilterInputStream(过滤字节输入流)
案例如下:
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class Test02 {
public static void main(String[] args) throws IOException {
/**
* 知识点:BufferedInputStream带有缓冲区的字节输入流
* 需求:利用带有缓冲区的字节输入流读取文件里的数据
*/
//方式一、采用默认缓冲区长度的方式来完成
//1、创建流
//默认缓冲区大小:8192个字节
BufferedInputStream bis01=new BufferedInputStream(new FileInputStream("io.txt"));
//2、读写数据
int len;
byte [] bs=new byte[1024];
while ((len=bis01.read(bs))!=-1){
System.out.println(new String(bs,0,len));
}
//3、关闭流对象
bis01.close();
//方式二、采用自定义长度的方式来完成文件的读写
//1、创建流对象
BufferedInputStream bis02=new BufferedInputStream(new FileInputStream("io.txt"));
//2、读写数据
int len02;
byte [] bs02=new byte[1024];
while ((len02=bis02.read(bs02))!=-1){
System.out.println(new String(bs02,0,len02));
}
//3、关闭流对象
bis02.close();
}
}
提高IO效率,减少访问磁盘的次数
数据存储于缓冲区中,flush是将缓冲区的内容写入文件中,也可以直接close。
3.2对象流:ObjectOutputStream/ObjectInputStream
ObjectInputStream 对象输入流
ObjectOutputStream 对象输出流
序列化概念:
序列化:将程序中的对象写入到文件中 — 钝化
反序列化:将文件中的对象读取到程序中 — 活化
一个类的对象要想通过对象流写入到文件中,该类就必须实现序列化接口(Serializable)
Serializable叫做序列化接口,该接口没有让我们去实现任何的方法,这种接口叫做标记型接口
transient修饰属性后,该属性不会随着对象写入到文件中
static静态属性也不会随着对象写入到文件中
特点;
1、增强了缓冲区的功能
2、增强了读写的8种基本数据类型和字符串功能
3、增强了读写对象的功能:
例如:
------------ 1、readObject()从流中读取一个对象
-------------2、writeObject(Object obj) 向流中写入一个对象
(4)字符流(Reader/Writer)
字符流的父类:
1、Reader:字符输入流
2、Writer:字符输出流
模板图解
4.1字符节点流
字符转换流 : InputStreamReader/OutputStreamWriter
1、InputStreamReander 继承于 Reader类
2、OutputStreamWriter 继承于 Writer类
案例展示:
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class Test01 {
public static void main(String[] args) throws IOException {
/**
* 知识点:字符输出转换流OutputStreamWriter
* 需求:利用字符输出转换流 向文件写入数据
*/
/* //1、创建流对象
//方式一、普通方式使用字符转换输出流
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("io.txt"));
//2、读写数据
osw.write("我是雍大帅,正在使用字符输出转换流".toCharArray());
//3、关闭流对象
osw.close();
//方式二、自定义编码格式来进行编码,此处通过使用GBK来作为实验对象
//1、创建对象
OutputStreamWriter osw02=new OutputStreamWriter(new FileOutputStream("io.txt"), "utf-8");
//2、读写数据
osw02.write("这是方式二,我通过设置了GBK编码格式来实现");//结果会乱码
//3、关闭流对象
osw02.close();*/
//方式三、通过设置编码格式+末尾追加内容的方式
//1、创建流对象
OutputStreamWriter osw03=new OutputStreamWriter(new FileOutputStream("io.txt",true),"GBK");
//2、读写数据
osw03.write("我是雍大帅,这是我用第三种方式写的东西应该会乱码由于我设置的是GBK编码但是不重要 哈哈哈哈哈~~");
//2、关闭流对象
osw03.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test02 {
public static void main(String[] args) throws IOException {
/**
* 知识点:字符输入转换流 InputStreamReader
* 需求:利用字符输入转换流,读取文件中的数据
*/
//1、创建流对象
InputStreamReader isr=new InputStreamReader(new FileInputStream("isr01.txt"));
//2、读写数据,一个一个地读数据
int read;
while ((read=isr.read())!=-1){
System.out.println((char) read);//将ASCLL码转换为对应的字符
}
//3、关闭流对象
isr.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test03 {
public static void main(String[] args) throws IOException {
/**
* 知识点:字符输入转换流 InputStreamReader
* 需求:利用字符输入转换流,读取文件中的数据
*/
//1、创建流对象
InputStreamReader isr=new InputStreamReader(new FileInputStream("io.txt"));
//2、读写数据
//以1024为一个单位来进行读写
char [] cs=new char[1024];
int len;
while ((len=isr.read(cs))!=-1){
System.out.println(new String(cs,0,len));//将字节文件转换为字符串形式
}
//3、关闭流对象
isr.close();
}
}
以下案例需要先创建一个需要复制的文档对象,例如我的操作对象为“io.txt”最终通过复制得到的为“Copy.txt”
import java.io.*;
public class Copy {
public static void main(String[] args) throws IOException {
/**
* 知识点:拷贝文本文件
*/
//1、创建流对象
InputStreamReader isr=new InputStreamReader(new FileInputStream("io.txt"));
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("Copy.txt"));
//2、进行读写数据(复制文件)
int len;
char [] cs=new char[1024];
while ((len=isr.read(cs))!=-1){
osw.write(new String(cs,0,len));
}
//3、关闭流对象
isr.close();
osw.close();
}
}
总结
本次的内容大致为这样,在I/O流的知识体系中是非常庞大的,这只是比较常用的一部分,大致的使用方式 都差不多,需要多练习。尤其是文件的复制那一块