/**
* 一个汉字是一个字符,就是2个字节,就是16位,所以,要读取汉字,还得用字符流
*-------------------------------------- 基础流----------------------------------------------
*/
FileInputStream ://(字节输入流,一次读取1个字节(就是8位))
FileInputStream fis = new FileInputStream("文件路径");//字节输入流
FileOutputStream : //(字节输出流,一次读取1个字节(就是8位))
FileOutputStream fis = new FileOutputStream("文件路径",true);//字节输出流 true不写默认为覆盖指定文件的内容,写了就是在内容后追加
FileReader : //(字符输入流,一次读取1个字符,就是2个字节(就是16位))
FileReader fis = new FileReader("文件路径");//字符输入流
FileWriter : //(字符输出流,一次读取1个字符,就是2个字节(就是16位))
FileWriter fis = new FileWeriter("文件路径,true");//字符输出流,true不写默认为覆盖指定文件的内容,写了就是在内容后追加
/**
*-------------------------------------- 缓冲流----------------------------------------------
*/
BufferedInputStream : //(字节输入流的缓冲流)
1.BufferedInputStream br = new BufferedInputStream( new FileInputStream("文件路径") );//字节输入流的缓冲流
2.FileInputStream fis = new FileInputStream("文件路径");//创建原始流
BufferedInputStream br = new BufferedInputStream( fis );//缓冲流 这两种是一样的,不过上面的那个相对简单一些,就是简写版
BufferedOutputStream : //(字节输出流的缓冲流)
1 BufferedOutputStream br = new BufferedOutputStream( new FileOutputStream("文件路径,true") );//字节输出流的缓冲流
2.FileOutputStream fis = new FileOutputStream("文件路径,true");//创建原始流 true不写默认为覆盖指定文件的内容,写了就是在内容后追加
BufferedOutputStream br = new BufferedOutputStream( fis );//缓冲流 这两种是一样的,不过上面的那个相对简单一些,就是简写版
BufferedReader : //(字符输入流的缓冲流)
1 BufferedReader br = new BufferedReader( new FileReader("文件路径") );//字符输入流的缓冲流
2.FileReader fis = new FileReader("文件路径");//创建原始流
BufferedReader br = new BufferedReader( fis );//缓冲流 这两种是一样的,不过上面的那个相对简单一些,就是简写版
BufferedWriter : //(字符输出流的缓冲流)
1 BufferedWriter br = new BufferedWriter( new FileWriter("文件路径,true") );//字符输出流的缓冲流
2.FileWriter fis = new FileWriter("文件路径,true");//创建原始流 true不写默认为覆盖指定文件的内容,写了就是在内容后追加
BufferedWriter br = new BufferedWriter( fis );//缓冲流 这两种是一样的,不过上面的那个相对简单一些,就是简写版
/**
*-------------------------------------- 转换流----------------------------------------------
*/
InputStreamReader : //(将字节输入流转为字符输入流)
1.InputStreamReader is = new InputStreamReader( new FileInputStream("文件路径") );//将字节输入流,转为字符输入流,是下面的简写
2.FileInputStream fis = new FileInputStream("文件路径");//创建字节原始流
InputStreamReader is = new InputStreamReader( fis );//转换为字符流
OutputStreamWriter : //(将字节输出流转为字符输出流)
1.InputStreamWriter is = new InputStreamWriter( new FileOutputStream("文件路径,true") );//将字节输出流,转为字符输出流,是下面的简写,这里不写true,就是覆盖指定文件中的内容,写了就是内容内容后面追加
2.FileOutputStream fis = new FileOutputStream("文件路径,true");//创建字节原始流
InputStreamWriter is = new InputStreamWriter( fis );//转换为字符流
/**
*------------------------------------------------------------------------------------------
*/
PrintStream :
//打印流
PrintStream ps = System.out;//(打印流)尽管没有new,是因为out是个静态成员变量(静态变量),在类加载的时候,成员类就被加载了,所以可以直接加载这个方法m
Geng_Gai_Wei_Zhi :
System.setOut() : //更改输出位置
System.setOut(new PrintStream(new FileOutputStream("./fos_tmp_01.txt")));//这里指定了系统默认输出位置,这里 是个jvm系统,会更改系统默认的位置
SimpleDateFormat :
//日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
lastModified :
//最后的修改时间
Date t = new Date(f1.lastModified());
System.out.println( new SimpleDateFormat("yyy-MM-dd HH:mm:ss SSS").format(t) );//返回的是时间 , 年月日,时分秒,毫秒,也就是上面指定的格式
DataOutputStream :
//(输出,输入,就是针对当前文件的进出,这里是输出,是把当前文件的东西,输出到指定的文件夹中,并加密,)
DataOutputStream dos = new DataOutputStream(new FileOutputStream("./fos_tmp_01.txt"));//把添加进去的数据进行封装,就跟加密一样,要想查看,就要按照添加的顺序去查看
byte b = 10;//变量(数据)
short s = 11;
int i = 12;
long l = 100L;
float f = 3.2f;
double d = 2.3;
boolean flag = false;
char c = ‘a‘;
dos.writeByte(b);//添加数据
dos.writeShort(s);
dos.writeInt(i);
dos.writeLong(l);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(flag);
dos.writeChar(c);
dos.flush();//磕两下
dos.close();//关闭资源
DataInputStream :
//(输出,输入,就是针对当前文件的进出,这里是输入,是把外面的文件的东西,输入到当前,且 一定要按照上面输出的时候的顺序,来读取)
DataInputStream dis = new DataInputStream(new FileInputStream("./fos_tmp_01.txt"));
//读取:要使用这个类,必须要提前知道该文件的存储格式,和顺序
//读的顺序必须和写的相同
byte b = dis.readByte();//读取资源
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
boolean flag = dis.readBoolean();
char c = dis.readChar();
System.out.println( b );//输出读取的资源
System.out.println( s );
System.out.println( i );
System.out.println( l );
System.out.println( f );
System.out.println( d );
System.out.println( flag );
System.out.println( c );
dis.close();//关闭资源
File :
//文件和目录路径名的抽象表示形式。(抽象就是没有的,这里说的是内存对象里面创建的,并不是硬盘创建的)
File f1 = new File("E:/第二期学习课程总汇/java/day11_IO/IO_01_FileInputStream_01.java");// 构造函数并不是创建新文件用的,文件是在硬盘中的,但是这里只是把文件对象复制到内存而已,然后返回找到这个文件的路径;
getAbsolutePath :
//返回此抽象路径名的绝对路径名字符串
getAbsolutePath() : //说白了,就是获得文件的全路径(绝对路径) 如 : ( E:/第二期学习课程总汇/java/day11_IO/IO_01_FileInputStream_01.java )
getName :
//返回由此抽象路径名表示的文件或目录的名称。
getName() : //说白了就是只获得文件的文件名,和扩展名,如 : ( IO_01_FileInputStream_01.java )
getParent :
//返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
getParent() : //说白了,就是获得当前文件的目录,就是 ./ 如 : ( E:/第二期学习课程总汇/java/day11_IO )
isFile :
isFile();//判断是不是文件 返回值是boolean true/false
System.out.println( f1.isFile() );//判断f1是不是文件 true
isDirectory :
isDirectory();//判断是不是目录 返回值是boolean true.false
System.out.println( f1.isDirectory() ); //判断f1是不是目录 false
createNewFile :
createNewFile();//这个是创建文件(不是创建目录) 返回值是boolean true/false 如果有这个文件,或者是没有这个目录,就返回false 如果有这个目录,没有这个文件,创建成功,返回true
System.out.println( f1.createNewFile() );
length :
length();//获取文本的长度,返回值是文本的长度
System.out.println( f1.length() );
listFiles :
File f2 = new File("E:/第二期学习课程总汇/java/day11_IO/");// 构造函数并不是创建新文件用的,文件是在硬盘中的,但是这里只是把文件对象复制到内存而已,然后返回找到这个文件的路径;
//列出子文件 就是把指定的目录每一个文件添加到数组中,在遍历数组
File[] fs = f2.listFiles();//创建一个数组,把指定的目录里面的文件都添加到数组,在遍历数组
for(File f:fs){//foreach循环(for的增强版 只能遍历集合和数组)
System.out.println( f.getAbsolutePath() );//返回文件的全路径(这里是遍历,就是把每个文件都输出全路径)
}
endsWith :
endsWith();//筛选
File[] fs = f2.listFiles();//创建一个数组,把指定的目录里面的文件都添加到数组,在遍历数组
for(File f:fs){
if (f.getAbsolutePath().endsWith(".java")) {//筛选,以.java结束的文件
System.out.println( f.getAbsolutePath() );//获得文件的全路径
}
}
Wen_Jian_Fu_Zhi : //文件复制(数组)
//输入流的方法 : FileInputStream
1.read(); 2.read(bytes);//下面有方法的例子和解释
//输出流的放法 : FileOutputStream
3.writer(); 4.write(bytes,0,tmp);//下面有方法的例子和解释
5. flush();//磕两下,往输出流里面添加懂东西了,就要磕两下,要么容易出错
//字节(文本)复制
FileInputStream :
FileOutputStream :
try(
FileInputStream fis = new FileInputStream("./IO流.java");//输入流 , 把指定文件中的数据,读取(输入)到当前文件中
FileOutputStream fos = new FileOutputStream("./新建文本文档.txt");//输出流 , 把指定的数据,输出到指定的文件中去
){
byte[] bytes = new byte[1024];//动态声明一个byte数组,且1024个字节
int tmp;//为什么用int声明?因为read(bytes);返回值是bytes这个数组中,添加元素的个数(字节数),如果达到了指定的个数(这里是1024),tmp就会为0,数组也会清空,然后依次循环,且 当读取到最后一位的时候,返回值为-1
while((tmp = fis.read(bytes)) != -1){//这是判断语句,当输入流指定的文件中,读取到最后一位的时候,就会返回-1,然后这个tmp != -1 判断语句 就为false 就不在循环了
fos.write(bytes,0,tmp);//将bytes数组,从下标为0开始,输出tmp个,(tmp就代表是数组里面已添加的字节个数)
}
fos.flush();//磕两下,往输出流指定的文件中添加东西,都要磕两下
}catch(Exception e){//捕捉异常
e.printStackTrace();//对异常进行打印追踪栈帧
}
read :
read();//读取指定文件,默认一次读取1字节,并且返回值是下一个字节的值(因为读取的时候,读取指针是在顶端的,并不是在第一个字节) 如果到达最后一位字节的时候(就是最后的,后面没有了),就返回-1
fis.read();//就读取指定文件的第一个字节
read_Bytes :
read(byte[] bytes);//返回值是bytes这个数组中,添加元素的个数(字节数),如果达到了数组指定的长度(字节数),(这里是1024),tmp就会为0,数组也会清空,然后接着当前读取的位置依次循环添加,一直到读取完最后一位,且 当读取到最后一位的时候,返回值为-1,(一般用于遍历,但是一次也是读取一个,只不过会一直读取,一直到数组满了(达到了指定的数组长度),然后再输出到指定的文件,然后数组清空,tmp为0,依次循环,一直到读取完指定文件的最后一个字节)
fis.read(bytes);//就是读取第一个字节,并把这个字节存入到bytes数组中
write :
write();
fos.write(添加);//把元素添加到输出流指定的文件中,可以是任何东西
write_bytes_0_tmp :
write(bytes,0,tmp);
fos.write(bytes,0,tmp);//把bytes数组中的元素,从下标为0开始,添加tmp位(个)元素
//纯文本字符流复制
FileReader :
FileWriter :
try(
FileReader fr = new FileReader("./IO流.java");//字符输入流 指定文件
FileWriter fw = new FileWriter("./新建文本文档.txt");//字符输出流 指定文件
){
char[] chars = new char[512];//这里是char类型的数组,因为纯字符流复制,就是纯文本,一个汉字就是一个字符,就是两个字节,就是16位,所以这里用的是char字符型数组
int tmp = 0;//和上面一样,这里为什么要用int声明?
while(-1 != (tmp = fr.read(chars))){//遍历循环 将输出流指定的文件中的内容,先复制到char数组,
fw.write(chars,0,tmp);//把数组的内容,复制到输出流指定的文件中,并清空数组
}
fw.flush();//磕两下 输出流的方法
}catch(Exception e){//捕捉异常
e.printStackTrace();
}
Wen_Jian_Fu_Zhi : //文件复制(缓冲流)
BufferedReader : //字符输入缓冲流
readLine :
方法 : readLine();//一次读取一行
//返回值 : 返回该行内容的字符串，不包含任何行终止符，如果已到达流末尾(最后的,没有东西了)，则返回 null
BufferedWriter : //字符输出缓冲流
newLine :
方法 : newLine();//新建一行,相当于换行符,
try(
BufferedReader br = new BufferedReader(new FileReader("./IO流.java"));//字符输入流的缓冲流
BufferedWriter bw = new BufferedWriter(new FileWriter("./新建文本文档.txt"));//字符输出流的缓冲流
){
String tmp = null;//为什么用String?因为里面都是字符串,读取一行,是以字符串的形式 ,所以要用String
int count = 0;//这里现在是判断作用,用于添加换行符(下面)
while(true){//while循环,如果不,判断语句是true 如果不终止,就是死循环把
count++;
tmp = br.readLine();//读取字符输入流指定文件的一行,并赋值给tmp
if (tmp == null) {//判断,如果tmp==null 就执行一下语句 当readLine()方法,读取到文件尾端的时候,读取完成,就返回null,所以,当读取完成后就要终止循环
break;//终止循环
}
//另起一行开始写,就是一个符号,在两行之间,显示的是换行
if (count > 1) {//这是判断,除了第一行,别的我们都需要换行,这里就是判断,如果大于1 那就是第二行,和以下行了,就需要换行
bw.newLine();//换行符,是在行首
}
bw.write(tmp);//添加(复制)到输出流指定的文件中,(一次是一行),然后数组清空
}
bw.flush();//添加(复制)完,就要磕两下
}catch(Exception e){//捕捉异常
e.printStackTrace();//处理异常(打印追踪栈帧)
}
substring :
substring();//返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。
如 : String s = "12345";
String s1 = s.substring(1);//是从原字符串的,下标为1的那位开始,至字符串的末尾,生成一个新的字符串
s1就是"2345";
String s2 = "A"+s.substring(1);
s2就是"A2345";
exists :
exists();//判断该路径是否存在,判断目标位置所在的盘是不是有这个目录(或文件),返回值为boolea true/false
File f = new File("E:/Zuo/You/Xia");//这个目录(文件)路径是在内存里面的,不是硬盘里面的
f.exists();//这里是判断,硬盘里面是否有这个目录(或文件)(全路径)
mkdirs :
mkdirs();//在硬盘中创建指定(抽象,也就是内存中)文件(或目录)的全路径
f.mkdirs();//在硬盘中,就会创建一个跟内存(抽象的)中一样的文件(或目录)的全路径
//注意，此操作失败时也可能已经成功地创建了一部分必需的父目录。
//就是在硬盘中创建 E:/Zuo/You/Xia
mkdir :
mkdir();//在硬盘中,创建指定文件(目录)的父路径,而不是全路径
f.mkdir();//只会创建 Xia,但是前提得自己创建 E:/Zuo/You,否则不会创建,
/**
* --------------------------序列化----------------------
*/
Serializable :
//序列化
java.io.Serializable;//实现这个接口的,在实例化的时候,就会同步封装逻辑
transient :
//如果序列化的时候,不想所有的数据都序列化,就在该数据前面加上:transient处理,就不会参与序列化
如 :
transient int age; //这个数据就不会被序列化
serialVersionUID :
序列化后,jvm会给对象文件和class文件都生成一个相同的serialVersionUID编号,这个编号是唯一的,如果对象文件(数据)和class(逻辑)文件的serialVersionUID编号对应不上,就会报错,如果序列化之后,没有更改class类文件对应的类里面的数据,就不会出现这种问题,但是如果改了,就不行了
所以,这个serialVersionUID编码,可以指定,指定之后,就算我改了class文件对应的类的数据,也能对应的上,也能读取出来
static final long serialVersionUID = 1L;//这样,不管更改没更改,每次生成的serialVersionUID编号,都会是1,就不会出现对应不上去这种错误
//对象对应的文件 是保存的数据
//类对象的class文件 是保存的逻辑
//序列化就是把 对象 保存到 硬盘 中,
User u1 = new User("aaa");//既然是序列化,那么这个User类必须实现与java.io.Serializable;(Serializable)这个接口
往指定地方(硬盘)存储对象文件的,叫序列化
从指定文件中(硬盘),读取对象文件的叫,反序列化
ObjectOutputStream :
//序列化
需要有个实现Serializable接口的类,和往指定地方(硬盘)存放这个对象文件的类,也就是ObjectOutputStream类(这个类现用先写都行)
writerObject();//输出对象流的方法 , 把指定的对象,添加到指定的文件中
flush();//磕两下,输出流都有的方法
//往指定地方(硬盘)存储对象文件的,叫序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./xv_lie_hua"));//创建对象输出流 并把东西保存到指定的文件("./xv_lie_hua")
oos.writeObject(u1);//这里就是把u1这个对象,输出到上面指定的文件中("./xv_lie_hua"),没有会创建
oos.flush();//磕两下
oos.close();//关闭资源
ObjectInputStream :
//反序列化
//反序列化需要:
对象文件,对象对应的class文件,反序列化类文件(这个类现写的都行)
readObject();//输入对象流的方法 , 读出指定的对象文件
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./xv_lie_hua"));//创建对象输入流,把指定的对象文件,输入到当前页面,
Object o = ois.readObject();//读取里面的对象,并赋值给用Object声明的 o 变量
System.out.println( o );//输出o变量,就是输出了读取的对象
ois.close();//关闭资源
}