本帖最后由 小石姐姐 于 2019-4-12 09:40 编辑
File类:
是文件和目录路径名的抽象表示
主要用于文件和目录的创建,删除,获取,判断是否存在,遍历,大小
File类是一个与系统无关的类,任何操作系统都可以使用这个类的方法
三个单词：File:文件：directory:文件夹/目录：path:路径
File静态成员变量:
static String pathSeparator 与系统有关的路径分隔符
static String separator 与系统有关的文件分隔符
static char pathSeparatorChar 与系统有关的路径分隔符
static char separatorChar 与系统有关的文件分隔符
操作路径:路径不能写死了
C:\develop\a\a.txt windows
C:/develop/a/a.txt linux
正确写法:
C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"
绝对路径和相对路径区别：
绝对路径：是一个完整的路径,以盘符开始的路径
相对路径：是一个简化的路径,相对指的是相当于当前项目的根目录
如果使用当前项目的根目录,路径可以简化书写
注意:
1.路径是不区分大小写
2.路径中的文件夹名称分隔符windo使用反斜杠,
反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠
File构造方法：
File(String name) 根绝指定的路径来创建File对象
注意:可以是文件头和尾,相对,绝对路径,可以存在,不存,不考虑真假。
File(S sparent,S child) 根据字符串类型的父级路径和子级路径来创建File对象
File(F parent,S hild) 根据File类型的父级路径和子级路径来创建File对象
File获取功能
String getAbsolutePath() 获取绝对路径
String getPath() 获取构造方法中的路径
String getName() 获取文件或文件夹名称
long length() 获取文件的大小(字节)(如果不存在则返回0)
文件夹大小没有概念
File判断功能
boolean exists() 判断文件或文件夹路径是否存在
boolean isDirectory() 判断路径是否是文件夹路径
boolean isFile() 判断路径是否是文件路径
File创建和删除
boolean createNewFile() 创建一个新的文件
boolean mkdir() 创建文件夹路径(单级)
boolean mkdirs() 创建文件夹路径(多级)
boolean delete() 删除文件或文件夹(文件夹必须为空)
File获取所有功能
String[] list() 获取文件夹所有内容返回的是字符串类型的数组
File[] listFiles() 获取文件夹所有内容返回时File类型数组 (如果单独传入文件路径会报空)
递归:
什么是递归:指在当前方法调用自己的这种现象
递归的分类:
直接递归:方法自身调用自己
间接递归:间接A调用B,B调用C,C调用A方法
注意事项:
一定要有条件限定,能够停止下来,否则会发生栈内存溢出异常
有限定条件,但是次数太多,也会发生栈内存溢出
构造方法是不能递归的
递归的使用前提：
当调方法的时候,方法主体不变,每次调用的参数不同,可以使用递归
FileFilter过滤器：过滤文件的方法
boolean accept(File pathname) 过滤文件的方法
boolean accept(File pathname,String name) 测试指定文件是否应该包含在某一文件
两个过滤器接口是没有实现类的, 需要重写accept,在方法中自己定义过滤
补充：
D:\develop\Java
大写字母:代表的是盘符
:代表的是路径分隔符
\代表的是文件|文件夹得名称分隔符
操作系统的区别：windows:\ linux/mac:/
什么是IO流:
I：input 输入(将文件数据读取到程序在)
O：output输出(将程序中的数据写入程序组)
流:数据(字符,字节)1个字符=2个字节 1个字节 = 8个二进制位
换行符号：Windows:\r\n linux:/n mac:/r
读取数据的原理(硬盘-->>内存)
java-->>JVM-->>OS-->>OS读取数据的方法-->>读取文件
字节流：万能流(可以操作任意类型的文件,可以复制文件)
inputStream
outputStream
字符流(只能操作纯文本文件)
Reader
Writer
output
=============>>
java程序 input 文件
<<=============
字节输出流抽象父类：OutputStream<<-->>子类文件字节输出流：FileoutputStream
构造方法:
FileOutputStream(String name)如果文件不存在自动创建,如果存在会删除从新创建。
FileOutputStream(File file) 根据File对象来创建字节输出流对象
FileOutputStream(String name,boolean append)如果第二个文件存在,则文件续写.
参数:写入数据的目的
String name:目的地是一个文件的路径
File file:目的地是一个文件
构造方法的作用:
1.创建一个FileOutputStream对象
2.会根据构造方法中传递的文件/文件路径,创建一个空的文件
3.会把FileOutputStream对象指向创建好的文件
close(); 关闭此输出流并释放资源
flush(); 用于将缓冲区的数据刷新到文件中
write(byte b); 一次写出一个字节数据(写入的是对应字符ASCll码表)
补充：
如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
如果写的第一个字节是负数,那第一个字节会和第二个字节
两个字节组成一个中文显示,查询系统默认码表(GBK)
write(byte[] b); 一次写出一个字节数组的数据
write(byte[] b,int off,int len);一次写出一个字节数组的一部分数据
abstract write(int b) 将指定的字节输出流
字节输入流抽象父类InputStream?<<-->>子类字节输入流：FileInputStream
构造方法:
FileInputStream(String name)根据指定字符串路径来创建字节输入流对象
FukeInputStream(File file)根据File对象来创建字节输入流对象
参数:写入数据的目的
String name:目的地是一个文件的路径
File file:目的地是一个文件
构造方法的作用:
1.创建一个FileInputStream对象
2.会把FileInputStream对象,指向要读区的文件
成员方法:
close() 释放资源
int read() 一次读取一个字节数据(到末尾会返回-1)
int tead(byte[] bytes) 一次读取一个字节数组的数据
1.方法的参数byte[]的作用?
起到缓冲作用,存储每次读取到的多个字节
数组的长度一把定义为1024(1kb)或者1024的整数倍
2.方法的返回值int是什么?
每次读取的有效字节个数
字符输入流最顶层的父类抽象类：Reader 只能操作纯文本文件。
Reader共性的成员方法:
read() 读取单个字符并返回
read() 将字符读入数组
close() 释放资源
FileReader：文件字符输入流
作用把硬盘文件中的数据义字符的方式读取到内存中
构造方法:
FileReader(String fileNmae) 根据字符串创建字符输入流对象
FileReader(File file) 根据File对象来创建
参数:读取文件的数据源
String fileName:文件的路径
File file:一个文件
FileReader构造方法的作用:
1.创建一个FileReader对象
2.会把FileReader对象指向要读取的文件
close() 释放资源
read() 一次读取一个字符数据
read(char[]char)一次读取一个字符数组的数据
字符输出流最顶层父类抽象：Writer
文件字符输入流FileWriter是继承OutpuStreamWriter的子类
构造方法:
FileWriter(String fileName) 根据字符串来创建字符输出对象
FileWriter(File file) 根据File对象来创建字符输出对象
FileWriter(String fileName,boolean flag) 文件续写
参数:写入数据的目的地
String fileName:文件的路径.File file:是一个文件
会创建一个FileWriter对象会根据构造方法中传递的文件/文件的路径
创建文件会把FileWriter对象指向创建好的文件
成员方法:
close() 释放资源
flush() 刷新缓冲区
writer(int ch) 一次写出一个字符数据
writer(cha[]ch) 一次写出一个字符数组
writer(cha[]ch,int index,int len)一次写出一个字符数组一部分数据
writer(String str) 一次写出一个字符串数据
writerString[]str,index,int len)一次写出一个字符串数组一部分数据
区别:
flush():将缓冲区的数据刷新到文件中,刷新完以后还可以继续写出数据
close():释放资源,释放之前将缓冲区的数据刷新到文件中,释放资源后不可以在继续写数据
IO流异常处理:
try (创建流对象语句，如果多个,使用';'隔开) {
// 读写数据
} catch (IOException e) {
e.printStackTrace();
}
属性集：Properties 可以保存在流中或从流中加载
属性列表中每个键及其对应值都是一个字符串。
Properties集合是一个双列集合,key和value默认都是字符串
store(OutpuStream out,String Comments)把集合中的临时数据,持久化写入到硬盘中存储
参数:
OutpuStream out:字节输出流，不能写入中文
Writer writer:字节输出流,可以写中文
String comments:注释.用来解释说明,不能使用中文会乱码Uunicode,一般使用空字符串""
创建Properties集合对象添加数据
创建字节输出流/字符输出流对象,构造方法中绑定要输出的目的地
使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
释放资源
操作字符串特有的方法：
Object setProperty(S key,S value)调用 Hashtable的方put。
String getProperty(S key) 通过键找到值,相当于Map集合中的get(key)方法
Set<String> stringPropertyNames()
返回此属性列表中的键集其中该键及其对应值是字符串,此方法相当于Map集合中的keySet方法
*重点*
load(Writer w,String comments) 把硬盘中保存的文件(键值对),读取到集合中使用
load(InputStream inStream)
load(Reader reader)
参数:
InputStream inStream:字节输入流,不能读取含有中文的键值对
Reader reader:字符输入流,能读取含有中文的键值对
使用步骤:
1.创建Properties集合对象
2.使用Properties集合对象中的方法load读取保存键值对的文件
3.遍历Properties集合
注意:
1.存储键值对的文件中,键与值默认的连接符号可以使用=,空格(其他符号)
2.存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取
3.存储键值对的文件中,键与值默认都是字符串,不用再加引号
缓冲区:给基本的字节输入流增加缓冲区(数组)提高读取速度
字节缓冲输出流：BuffredOutputStream(new Out)
构造方法:
BuffredOutputStream(OutputStream out)创建字节缓冲输出流对象
BuffredOutputStream(OutputStream out,int size)指定字节缓冲区大小
字节缓冲输入流：BuffredInputStrem(new FileInputStrea())
构造方法:
BuffredInputStrem(InputStrem in)创建字节缓冲输入流对象
BuffredInputStrem(InputStrem in，int size)指定字节缓冲区大小
字符缓冲输出流：BufferdWriter
构造方法：
BufferWriter(Writer in) 创建字符缓冲输出流对象
BufferWriter(Writer in,int size)指顶字符缓冲区大小
特有的成员方法：
void newline()写出一个通用的系统换行符号
字符缓冲输入流：BuffredReader
构造方法：
BufferReader(Reader in) 创建字符缓冲输入流对象
BufferReader(Reader in,int size)指顶字符缓冲区大小
特有成员方法：
String readLine()读取一个文本行,读取一行数据
使用：
while((line = br.readLine()) != null)
字符编码与字符集：
字符编码：就是一套自然语言的字符与二进制数之间对应的规则
编码：字符(能看懂)-->>字节(看不懂)
解码：字节(看不懂)-->>字符(能看懂)
字符集：Charset 系统支持的所有字符的集合，包括各国家文字，符号。
转换输出流：OutputStreamWriter
构造方法：
OutputStreamWriter(OutputStream out) 创建使用默认字符编码的
OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的
使用步骤:
1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
2.使用方法write,把字符转换为字节存储缓冲区中(编码)
3.使用方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
4.释放资源
转换输入流：InputStreamReader
构造方法：
InputStreamReader(InputStream in) 创建一个使用默认字符集的
InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的
使用步骤:
1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
2.使用方法read读取文件
3.释放资源
ObjectOutputStream序列化 ：把对象写到文件中
构造方法:
ObjectOutputStream(OutputStream out)
成员方法:
writePbject(Object obj) 将对象写入
使用步骤:
1.创建ObjectOutputStream对象,构造方法中传递字节输出流
2.使用方法writeObject,把对象写入到文件中
3.释放资源
注意事项：
参与序列化和反序列化的类,必须实现Serializable接口!!
ObjectInputStream反序列化：把文件中保存的对象,读取到程序中
构造方法：
ObjectInputSteam(InputStream in)
成员方法：
Object readObject() 读取对象
使用步骤:
1.创建ObjectInputStream对象,构造方法中传递字节输入流
2.使用方法readObject读取保存对象的文件
3.释放资源
4.使用读取出来的对象(打印)
static关键字：静态关键字
静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
被static修饰的成员变量不能被序列化的,序列化的都是对象
transient：瞬态关键字
被transient修饰成员变量,不能被序列化
序列化号格式：
private static final long serialVersionUID = 1L;
PrintStream：打印流
PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
PrintStream特点:
1.只负责数据的输出,不负责数据的读取
2.与其他输出流不同，PrintStream 永远不会抛出 IOException
3.有特有的方法,print,println
void print(任意类型的值)
void println(任意类型的值并换行)
构造方法:
PrintStream(File file):输出的目的地是一个文件
PrintStream(OutputStream out):输出的目的地是一个字节输出流
PrintStream(String fileName) :输出的目的地是一个文件路径
PrintStream extends OutputStream
继承自父类的成员方法:
- public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
- public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
- public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
- public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节， 从偏移量 off开始输出到此输出流。
- public abstract void write(int b) ：将指定的字节输出流。
注意:
如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a
如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97
可以改变输出语句的目的地(打印流的流向)
输出语句,默认在控制台输出
使用System.setOut方法改变输出语句的目的地改为参数中传递的打印流的目的地
static void setOut(PrintStream out)
重新分配“标准”输出流。
如果是操作文件(文本.图片.视频)使用字节流：
字节输入流：InputStream
文件字节输入流：FileInputStream
缓冲字节输入流：BufferedInputStream
复制文件要先输入在输出-->>(可以建立数组提升速度)(优先使用缓冲流)
int len;
while((len = In(数组)) != -1){
out.(len)
}
字节输入流:Outputstream
文件字节输出流：FileOutputStream
缓冲字节输出流：BufferedOutputStream
****************************************************************************************
如果操作的是文本文件使用字符流
字符输入流：Reader
文件字符输入流：FileReader
缓冲字符输入流：BufferedReader
案列带行号的复制文件-->>先输入在输出(优先使用缓冲流)
int num = 1;//设定行号
String line;
注意是不等于空,不是不等于-1
while((line = re.readLine()) != null){
Wr.write(num + " " + line);
Wr.newLine;
num++;//每次换行+1
}
文件输出流：Writer
文件字符输出流：FileWriter
缓冲字符输出流：BufferedWriter
****************************************************************************************
如果操作的文件编码格式不统一使用
转换流：
转换输入流：InputStreamReader
转换输出流：OutputStreamWriter
案列写出一个GBK格式文件：
OutputStreamWriter ow = new OutputStreamWriter
(new FileOutputStreamWriter("目标目录") 转换格式))
ow.write("你好");
ow.close();
案列读取一个GBK格式文件：
InputStreamReader ir = new InputStreamReader
(new FileInputStreamReader("目标目录") 读取格式))
BuffereRead br = new BufferedReaer(ir);
String line = br.readLine();
System.out.prinltn(line);
br.close
***********************************************************************************
将对象写出或读取对象使用序列化流
对象输入流：ObjectInputStream
读取对象：readObject();
对象输出流：ObjectOutputStream
写出对象：WriteObject();
案列：建立一个类私有空参满参get/set方法
类要实现接口Serializable接口
ArrayList<Student> list = new ArrayLits<>();//存对象集合
ObjectOutputStream os = new ObjectOutputStream
(new FileOutputStream("存入目录"));
os.writeObject(list);
os.close
案列：读取一个对象
ObjectInputStream oi = new ObjectInputStream
(new FileInputStream("读取目录"))
object obj = oi.readObject();
Obj.close
//obj向下转型
ArrayList<Student> list = (ArrayList<Student>)obj;
for(Student s : list){
System.out.Println(s);
}
建立FileOutputStream(new file"目录文件")
调用write写到文件中
建立FileInputSyream(new file"目录文件")
调用read()读取文件
int len = 0;
while((len = .read()) != -1){
System.out.print((char)len)
}
布尔表达式(len = fis.read())!= -1
1.read();读取每一个字节
2.len = .read();把读取到的字节赋值给变量len
3.(len = .read()!= -1);判断变量len是否不等于-1
************************************************************************************
复制文件.一读一写
FileInputStream fis = new FileInputStream("复制文件目录");
FileOutputStream fos = new FileOutputStream(复制后文件目录");
//读取
//使用数组缓冲读取多个字节,写入多个字节
byte[] bytes = new byte[1024];
int len = 0;//每次读取有效的字节个数
while((len = fis.read(bytes) != -1)){//读取的是文件
//写入
fos.write(bytes,0,len)//写入目的地
}
文件复制的步骤：
1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
2.蒋健一个字节输出流对象,构造方法中绑定要写入的目的地
3.使用字节输入流对象中的方法read读取文件
4.使用字节输出流中的方法write,把读取的到的字节写入到目的地的文件中
5.释放资源(先关写的.后关读的)
************************************************************************************
字节缓冲输出流：
BufferedOutputStream bos = new BufferedOutStream(new FileOutputStream"写入的目标目录")
调用write写入
字节缓冲输入流：
BufferedInputStream bis = new BufferedInStream(new FileInputStream"读取的目标目录")
byte[] bytes = new byte[1024];//存取每次读取的数据
int len = 0;//每次读取的有效字节个数
while((len = bis.read(bytes)) != -1){
System.out.println(new String(bytes,0,len))
}
**************************************************************************************
复制文件.一读一写
BufferedInputStream fis = new BufferedInputStream("复制文件目录");
BufferedOutputStream fos = new BufferedOutputStream(复制后文件目录");
//读取
//使用数组缓冲读取多个字节,写入多个字节
byte[] bytes = new byte[1024];
int len = 0;//每次读取有效的字节个数
while((len = fis.read(bytes) != -1)){//读取的是文件
//写入
fos.write(bytes,0,len)//写入目的地
}
文件复制的步骤：
1.创建一个字节缓冲输入流对象,构造方法中绑定要读区的数据源
2.蒋健一个字节缓冲输出流对象,构造方法中绑定要写入的目的地
3.使用字节缓冲输入流对象中的方法read读取文件
4.使用字节缓冲输出流中的方法write,把读取的到的字节写入到内部缓冲区中
5.释放资源(先关写的.后关读的)会把缓冲区中的数据,刷新到文件中
**************************************************************************************
字符缓冲输出流：特有方法readLine();
BufferedWrite bw = new BufferedWrite(new FileWrite"写入到的文件目录")
for(int i= 0 ;i < 10; i++){//写到文件中十次你好
bw.write("你好");
bw.newline();//换行特有方法
}
字符缓冲输入流：特有方法readLine();
BufferedReader br = new BufferedReader(new FileReader"读取目标目录")
String line;
while((line = br.readLine()) != null){
System.out.prinln(line)
}
**************************************************************************************
TCP通信的文件上传
原理：客户端读取本地的文件,把文件上传到服务器, 服务器在把上传的文件保存到服务器的硬盘上
文件上传：
客户端使用本地的字节输入流,读取要上传的文件
客户端使用网络字节输出流,把读取到的文件上传到服务器
服务器使用网络字节输入流,读取客户端上传的文件
服务器使用本地字节输出流,把服务到的文件,保存到服务器的硬盘上
服务器使用网络字节输出流,给客户端回一个"上传成功"
客户端使用网络字节输出流,读取服务器会写的数据
释放资源
注意:
客户端和服务器的本地硬盘进行读写，需要使用自己创建的字节流对象(本地流)
客户端和服务器之间进行读写,碧玺是用Socket中提供的字节流对象(网络流)
文件上传原理,就是文件的复制
明确：
数据源
数据的目的
|
|
收藏
淘帖
踩
