一:File
File是java.io.包下的类，File类的对象，用于代表当前操作系统的文件（可以是文件或文件夹）。
注意：File类只能对文件本事进行操作，不能读写文件里面存储的数据。
二:创建对象
File(String pathname) 根据文件路径创建文件对象
File(String parent, String child) 根据父路径和子路径名字创建文件对象
File(File parent, String child) 根据父路径对应文件对象和子路径名字创建文件对象
import java.io.File;
public class Test1 {
public static void main(String[] args) {
//不同的路径分隔符
// File f1 = new File("D:\\哈迪斯\\Hades v1.38290.3\\Hadesx64.exe");
// File f1 = new File("D:/哈迪斯/Hades v1.38290.3/Hadesx64.exe");
File f1 = new File("D:"+File.separator+"哈迪斯"+File.separator+"Hades v1.38290.3"+File.separator+"Hadesx64.exe");
File f4 = new File("D:/sad/sadc/v");
System.out.println(f4.exists());//判断文件是否存在
//需要定位的文件在模块中
//方法一：绝对路径
File f2 = new File("D:\\练习\\TEST\\FileAndIO\\File\\src\\Test\\ss");
//方法二:相对路径
File f3 = new File("FileAndIO\\File\\src\\Test\\ss");
}
}注意：File对象既可以代表文件，也可以代表文件夹。
File封装的对象仅仅是一个路径名，这个路径可以是存在的，也允许是不存在的。可通过 exists() 判断
绝对路径：从盘符开始
相对路径：不带盘符，默认直接到当前工程下的目录寻找文件。
二:常用方法一：判断文件类型、获取文件信息
1.File提供的判断文件类型、获取文件信息功能
exists() 判断当前文件对象，对应的文件路径是否存在，存在返回true
isFile() 判断当前文件对象指代的是否是文件，是文件返回true
isDirectory() 判断当前文件对象指代的是否是文件夹，是文件夹返回true
getName() 获取文件名称（包含后缀）
length() 获取文件的大小，返回字节个数
lastModified() 获取文件的最后修改时间
getPath() 获取创建文件对象时，使用的路径
getAbsolutePath() 获取绝对路径
2.示例：
import java.io.File;
import java.text.SimpleDateFormat;
public class Test2 {
public static void main(String[] args) {
File f1 = new File("D:\\哈迪斯");
File f2 = new File("D:\\哈迪斯\\存档位置中文设置启动说明.txt");
f2.isFile();
f1.isDirectory();
f2.getName();
long time = f2.lastModified();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
String format1 = format.format(time);
System.out.println(format1);
f2.getPath();
f1.getAbsolutePath();
}
}三:创建和删除文件
1.File类创建文件的功能
createNewFile() 创建一个新的空的文件夹
mkdir() 只能创建一级文件夹
mkdirs() 可以创建多级文件夹
2.File类删除文件的功能
delete() 删除文件，空文件夹
3.示例：
import java.io.File;
public class Test3 {
public static void main(String[] args) throws Exception {
File f1 = new File("D:\\哈迪斯\\hhh.txt");
System.out.println(f1.createNewFile());
File f2 = new File("D:\\哈迪斯\\aaa");
f2.mkdir();
File f3 = new File("D:\\哈迪斯\\aaa\\bb\\cc");
f3.mkdirs();
f1.delete();
f2.delete();
f3.delete();
}
}四:遍历文件夹
1.File提供的遍历文件夹的功能
list() 获取当前目录下所有的“一级文件名称”到一个字符串数组中去返回
listFiles() 获取当前目录下所有的“一级文件对象”到一个文件对象数组中去返回
2.使用listFiles方法时的注意事项
当主调是文件，或者路径不存在时，返回null
当主调是空文件夹时，返回一个长度为0的数组
当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹的路径放在File数组中返回
当主调是一个文件夹时，且里面有隐藏文件时，将里面所有文件和文件家的路径放在File数组中返回，包含隐藏文件
当主调是一个文件夹时，但是没有权限访问该文件夹时，返回null
3.示例：
import java.io.File;
public class Test4 {
public static void main(String[] args) {
File f1 = new File("D:/练习");
String[] list1 = f1.list();
for (String s : list1) {
System.out.println(s);
}
File[] files = f1.listFiles();
for (File file : files) {
System.out.println(file);
}
File f2 = new File("D:/我的世界/1");
File[] files1 = f2.listFiles();
System.out.println(files1.length);// 0
}
}---------------------------------------------------------------------------------------------------------------------------------
一:IO流概述
1.I指Input，称为输入流：负责把数据读到内存中去
2.O指Ouput，称为输出流：负责写数据出去
3.IO流的分类
IO流总体来看就有四大流
①字节输入流：以内存为基准，来自磁盘文件/网络中的数据到以字节形式读入内存中去的流
②字节输出流：以内存为基准，把内存中的数据以字节写出到磁盘文件或网络中去的流
③字符输入流：以内存为基准，来自磁盘文件/网络中的数据以字符形式读入到内存中去的流
④字符输出流：以内存为基准，把内存中的数据以字符写出到磁盘文件或网络介质中去的流
4.IO流的体系
二:FileInputStream（文件字节输入流）
1.作用：以内存为基础，可以把磁盘文件中的数据以字节的形式读入到内存中去。
2.使用
构造器：
FileInputStream(File file) 创建字节输入流管道与源文件接通
FileInputStream(String pathname) 创建字节输入流管道与源文件接通
方法：
read() 每次读取一个字节返回，如果发现没有数据可读返回-1
read(byte[] buffer) 每次用一个字节数组去读取数据，返回字节数组读取了多少个字节，如果发现没有数据可读返回-1
3.示例：
import java.io.FileInputStream;
import java.io.InputStream;
public class Test1 {
public static void main(String[] args) throws Exception {
// InputStream is = new FileInputStream(new File("FileAndIO\\IO\\src\\TEST\\abc"));
InputStream is = new FileInputStream(("FileAndIO\\IO\\src\\TEST\\abc"));
//使用循环来读取字节
int a;
while ((a = is.read()) != -1){
System.out.print(a);
}
//读取数据性能很差1
//读取中文会出现乱码！无法避免！
//流使用完毕后必须关闭，节省资源
is.close();
}
}import java.io.FileInputStream;
import java.io.InputStream;
public class Test2 {
public static void main(String[] args) throws Exception {
InputStream is = new FileInputStream("FileAndIO\\IO\\src\\TEST\\abc");
byte[] a = new byte[10];
// int length = is.read(a);
// String rs = new String(a);
// System.out.println("读取的字节数"+length);
// System.out.println(rs);
int len;
while ((len = is.read(a)) != -1){
//注意读取多少倒出多少
String rs = new String(a,0,len);
System.out.println(rs);
}
//性能得到了明显的提升
//这种方式任然不能解决乱码问题
is.close();
}
}4.如何解决用字节码读取中午数据出现乱码情况的问题
方式一：自己定义一个字节数组与被读数组的文件大小一样大，然后使用该字节数组，一次性读完文件的全部字节。
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class Test3 {
public static void main(String[] args) throws Exception {
InputStream is = new FileInputStream("FileAndIO\\IO\\src\\TEST\\abc");
File a = new File("FileAndIO\\IO\\src\\TEST\\abc");
long length = a.length();
byte[] c = new byte[(int)length];
is.read(c);
String rs = new String(c);
System.out.println(rs);
}
}方式二：Java官方为InputStream提供了如下方法，可以直接把文件的全部字节读取到一个字节数组中返回。
readAllBytes() throws IOException 直接将当前字节输入流对应的文件对象字节数据装到一个字节数组返回。（这个方法对于JDK8无法使用）
注意：如果文件过大，创建的字节数组也会过大，可能引起内存溢出。
三:FileOutputStream（文件字节输出流）
1.作用：以内存为基础，把内存中的数据以字节的形式写出到文件中去。
2.使用：
覆盖构造器：
FileOutputStream(File file) 创建字节输出流管道与源文件接通
FileOutputStream(String filepath) 创建字节输出流管道与源文件接通
追加数据的构造器：
FileOutputStream(File file, boolean append) 创建字节输出流管道与源文件接通，可追加数据
FileOutputStream(String filepath, boolean append) 创建字节输出流管道与源文件接通，可追加数据
方法：
write(int a) 写一个字节出去
write(byte[] buffer) 写一个字节数组出去
write(byte[] buffer, int pos, int len) 写一个字节数组的一部分出去
colse(throws IOException ) 关闭流
3.示例：
import java.io.FileOutputStream;
import java.io.OutputStream;
public class Test4 {
public static void main(String[] args) throws Exception {
//覆盖管道
// OutputStream os = new FileOutputStream("FileAndIO\\IO\\src\\WGAT.txt");
//追加管道
OutputStream os = new FileOutputStream("FileAndIO\\IO\\src\\WGAT.txt",true);
os.write('a');
os.write(98);
byte[] bytes = "蔡建宇王凯".getBytes();
os.write(bytes);
os.write("好好好怎么玩是吧".getBytes());
os.write("\r\n".getBytes());
os.close();
}
}4.复制文件案例
import java.io.*;
public class Test5 {
public static void main(String[] args) throws Exception {
InputStream is = new FileInputStream("D:/resource/meinv.png");
OutputStream os = new FileOutputStream("C/Date/meinv.png");
byte[] bytes = new byte[1024];//1kb
int len;
while ((len = is.read(bytes)) != -1){
os.write(bytes, 0, len);
}
is.close();
os.close();
}
}注意：字节流非常适合做一切文件的复制操作（任何文件的底层都是字节，字节流做复制，是一字不漏的转移完全部字节，只要复制后的文件格式一致就没问题！）
四:释放资源
1.try {} catch (IOException e) { e.printStackTrace(); } finally{}
·finally代码区的特点：无论try中的程序是正常执行了，还是出现了异常，最后都一定会执行finally区，除非JVM终止。
·作用：一般用于在程序执行完成后进行资源等等释放操作。
注意：fianlly中不能return相应的值否则会产生错误。
import java.io.*;
//try {} catch (IOException e) { e.printStackTrace(); } finally{}
public class Test6 {
InputStream is = null;
OutputStream os = null;
public static void main(String[] args) throws Exception{
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream("FileAndIO\\IO\\src\\WGAT.txt");
os = new FileOutputStream("FileAndIO\\IO\\src\\WGAT.txt");
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} finally {
try {
if (is != null) is.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
if (os != null) os.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}2.try(定义资源1;定义资源2;...) { 可能出现的异常代码; }catch(异常类名 变量名){异常的处理代码; }
import java.io.*;
//try(定义资源1;定义资源2;...) { 可能出现的异常代码; }catch(异常类名 变量名){异常的处理代码; }
public class Test6 {
public static void main(String[] args) throws Exception{
try (InputStream is = new FileInputStream("FileAndIO\\IO\\src\\WGAT.txt");
OutputStream os = new FileOutputStream("FileAndIO\\IO\\src\\WGAT.txt")){
//可能出现的异常代码
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}注意：该资源使用完毕后，会自动调用其close()方法，完成对资源的释放!
·()中只能放置资源否则会报错
·资源一般指的是最终实现了AutoCloseable接口
public class Main implements AutoCloseable{
@Override
public void close() throws Exception {
System.out.println("当调用该资源时最后会自动执行该方法");
}
}五:FileReader（文件字符输入流）
1.作用：以内存为基准，可以把文件中的数据以字符的形式读入到内存中去。
2.使用：
构造器：
FileReader(File file) 创建字符输入流管道与源文件接通
FileReader(String pathname) 创建字符输入流管道与源文件接通
方法：
read() 每次读取一个字符返回，如果发现没有数据可读会返回-1
read(char[] buffer) 每次用一个字符数组去读取数据，返回字符数组读取了多少个字符，如果发现没有数据可读会返回-1
3.示例：
import java.io.FileReader;
public class Test1 {
public static void main(String[] args){
try ( FileReader fr = new FileReader("FileAndIO\\IO\\src\\WGAT.txt");) {
// int a;//记录读取字符的编号
// while ((a = fr.read()) != -1){
// System.out.print((char) a);
// }
char[] b = new char[3];
int len;//记录读取了多少个字符
while ((len = fr.read(b)) != -1){
//读取多少 倒出多少！
System.out.print(new String(b,0,len));//new String()将字符转化成字符串
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}六:FileWriter（文件字符输出流）
1.作用：以内存为基准，把内存中的数据以字符的形式写出到文件中去。
2.使用：
覆盖构造器：
FileWriter(File file) 创建字符输出流管道与源文件接通
FileWriter(String filepath) 创建字符输出流管道与源文件接通
追加数据构造器：
FileWriter(File file, boolean append) 创建字符输出流管道与源文件接通，可追加数据
FileWriter(String filepath, boolean append) 创建字符输出流管道与源文件接通，可追加数据
方法：
write(int c) 写一个字符
write(String str) 写一个字符串
write(String str, int off, int len) 写一个字符串的一部分
write(char[] cbuf) 写入一个字符数组
write(char[] cbuf, int off, int len) 写入字符数组的一部分
import java.io.FileWriter;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) {
try (FileWriter fw = new FileWriter("FileAndIO\\IO\\src\\WGAT.txt",true)) {
fw.write(97);
fw.write("小小王凯");
fw.write("小小王凯152",0,4);
fw.write("\r\n");
char[] a = {'s','c','5','9'};
fw.write(a);
fw.write("\r\n");
fw.write(a,0,4);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}| 注意：字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效
| 方法：
flush() throws IOException 刷新流，就是将内存中缓存的数据立即写到文件中区生效（刷新流后，流还存在，还可以添加数据，添加后再次刷新，添加的数据又会出现在文件区中）
close() throws IOException 关闭流，包含了刷新。
---------------------------------------------------------------------------------------
字节流、字符流的使用场景小结：
·字节流适合做一切文件数据的拷贝（音视频，文本）；字节流不适合读取中文内容输出
·字符流适合做文本文件的操作（读，写）。
---------------------------------------------------------------------------------------------------------------------------------
缓冲流
一:字节缓冲流
1.作用：提高字节流读写数据的性能
2.原理：字节缓冲输入流自带了8KB缓冲池；字节缓冲输出流也自带了8KB缓冲池。
3.使用：
构造器：
BufferedInputStream(InputStream is) 把低级的字节输入流包装成一个高级的缓冲字节输入流，从而提高读数据的性能
BufferedOutputStream(OutputStream os) 把低级的字节输出流包装成一个高级的缓冲字节输出流，从而提高写数据的性能
4.示例：
import java.io.*;
public class Test5 {
public static void main(String[] args) throws Exception {
try (InputStream is = new FileInputStream("D:/resource/meinv.png");
OutputStream os = new FileOutputStream("C/Date/meinv.png");
InputStream bis = new BufferedInputStream(is);
OutputStream bos = new BufferedOutputStream(os);
){
byte[] bytes = new byte[1024];//1kb
int len;
while ((len = bis.read(bytes)) != -1){
bos.write(bytes, 0, len);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}二:BufferedReader（字符缓冲输入流）
1.作用：自带8K（可更改）的字符缓冲池，可以提高字符输入流读取字符数据的性能。
2.使用：
构造器：BufferedReader(Reader r) 把低级的字符输入流包装成字符缓冲输入流管道，从而提高字符输入流读字符数据的性能。
字符缓冲输入流新增的功能：按照行读取字符
readLine() 读取一行数据返回，如果没有数据可读了，会返回null
3.示例：
import java.io.BufferedReader;
import java.io.FileReader;
public class Test1 {
public static void main(String[] args){
try ( FileReader fr = new FileReader("FileAndIO\\IO\\src\\WGAT.txt");
BufferedReader bfr = new BufferedReader(fr)
) {
// int a;//记录读取字符的编号
// while ((a = fr.read()) != -1){
// System.out.print((char) a);
// }
char[] b = new char[3];
// int len;//记录读取了多少个字符
// while ((len = bfr.read(b)) != -1){
// //读取多少 倒出多少！
// System.out.print(new String(b,0,len));//new String()将字符转化成字符串
// }
String lien;
while ((lien = bfr.readLine()) != null){
System.out.println(lien);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}三:BufferedWriter（字符缓冲输出流）
1.作用：自带8K（可更改）的字符缓冲池，可以提高字符输出流写字符数据的性能
2.使用：
构造器：BufferedWriter(Writer r) 把低级的字符输出流包装成字符缓冲输出流管道，从而提高字符输出流读字符数据的性能。
字符缓冲输出流新增的功能：换行
newLine() 换行
3.示例：
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) {
try (FileWriter fw = new FileWriter("FileAndIO\\IO\\src\\WGAT.txt",true);
BufferedWriter bfw = new BufferedWriter(fw);
) {
bfw.write(97);
bfw.write("小小王凯");
bfw.write("小小王凯152",0,4);
bfw.newLine();
char[] a = {'s','c','5','9'};
bfw.write(a);
bfw.newLine();
bfw.write(a,0,4);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}四:原始流和缓冲流的性能分析
1.使用低级的字节流按照一个一个字节的形式复制文件。（速度极慢，直接淘汰!）
2.使用低级的字节流按照字节数组的形式复制文件。(速度较慢)
3.使用高级的缓冲字节流按照一个一个字节的形式复制文件。（速度较慢）
4.使用高级的缓冲字节流按照字节数组的形式复制文件。（速度极快，推荐使用！）
---------------------------------------------------------------------------------------------------------------------------------
转换流
一:引出问题——不同编码读取出现乱码的问题：
如果代码编码和被读取的文本文件的编码是一致的，使用字符流读取文本文件时不会出现乱码！
如果代码编码和被读取的文本文件的编码是不一致的，使用字符流读取文本文件时就会出现乱码！
二:InputStreamReader（字符输入转换流）
1.作用：解决不同编码时，字符流读取文本内容乱码的问题。
2.解决思路：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了。
3.使用：
构造器：
InputStreamReader(InputStream is) 把原始的字节输入流，按照代码默认编码转成字符输入流（与直接使用FileReader的效果一样）
InputStreamReader(InputStream is, String Charset) 把原始的字节输入流，按照指定字符集编码转成字符输入流
4.示例：
import java.io.*;
public class Test3 {
public static void main(String[] args) {
try(InputStream is = new FileInputStream("FileAndIO\\IO\\src\\WGAT.txt");
Reader isr = new InputStreamReader(is,"GBK");//将代码编码的字符全部转换成GBK形式
BufferedReader br = new BufferedReader(isr)
){
String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}三:OutputStreamReader（字符输出转换流）
1.作用：可以控制写出去的字符使用什么字符集编码。
2.解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。
3.使用：
构造器：
OutputStreamReader(OutputStream os) 可以把原始的字节输出流，按照代码默认编码转换成字符输出流
OutputStreamReader(OutputStream os , String charset) 可以把原始的字节输出流，按照指定编码转换成字符输出流
4.示例：
---------------------------------------------------------------------------------------------------------------------------------打印流
PrintStream/PrintWriter（打印流）
1.作用：打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。
2.PrintStream提供的打印数据的方案
构造器：
PrintStream(OutputStream/File/String) 打印流通向字节输出流/文件/文件路径
PrintStream(String fileName, Charset cahrset) 可以指定写出去的字符编码
PrintStream(OutputStream out, boolean autoFlush) 可以指定实现自动刷新
PrintStream(OutputStream out, boolean autoFlush, String encoding) 可以指定实现自动刷新，并可指定字符的编码
方法：
print(Xxx xx) 打印任意类型的数据出去
write(int/byte[] /byte[]一部分) 可以支持写字节数据出去
4.示例：
import java.io.PrintStream;
public class Test5 {
public static void main(String[] args) {
try (PrintStream ps = new PrintStream("FileAndIO\\IO\\src\\WGAT.txt")){
ps.println("dasasda");
ps.println('a');
ps.println(7686);
ps.println(97);
ps.write(98);// b
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}5.PrintWriter提供的打印数据的方案
构造器：
PrintWriter(OutputStream/File/String) 打印流通向字节输出流/文件/文件路径
PrintWriter(String fileName, Charset cahrset) 可以指定写出去的字符编码
PrintWriter(OutputStream out, boolean autoFlush) 可以指定实现自动刷新
PrintWriter(OutputStream out, boolean autoFlush, String encoding) 可以指定实现自动刷新，并可指定字符的编码
方法：
print(Xxx xx) 打印任意类型的数据出去
write(int/Sring/char[]/...) 可以支持写字符数据出去
6.示例：
import java.io.PrintWriter;
public class Test6 {
public static void main(String[] args) {
try (PrintWriter pw = new PrintWriter("FileAndIO\\IO\\src\\WGAT.txt")){
pw.println(3123);
pw.write(4);
pw.println("Sda");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}7.PrintStream和PrintWriter的区别
①打印数据的功能上是一模一样的：都是使用方便，性能高效（核心优势）
②PrintStream继承自字节输出流OutputStream，因此支持写字节数据的方法。
③PrintStream继承自字符输出流Writer，因此支持写字符数据出去。
8.打印流的一种应用：输出语句的重定向
可以把输出语句打印位置改到某个文件中去。
import java.io.PrintStream;
public class Test7 {
public static void main(String[] args) {
System.out.println("sdadas");
System.out.println("SdAdsd");
try (PrintStream ps = new PrintStream("FileAndIO\\IO\\src\\WGAT.txt");){
//把系统默认的打印流对象改为自己设置的打印流
System.setOut(ps);
System.out.println("sada");
System.out.println("Adawd");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}---------------------------------------------------------------------------------------------------------------------------------
数据流和序列化流
一:DataOutputStream（数据输出流）
1.允许把数据和其他类型一并写出去
2.使用：
构造器：
DataOutputStream(OutputStream out) 创建新数据输出流包装基础的字节输出流
方法：
writeByte(int v) 把byte类型的数据写入基础的字节输出流
writeInt(int v) 把int类型的数据写入基础的字节输出流
writeDouble(Double v) 把double类型的数据写入基础的字节输出流
writeUTF(String str) 把字符串数据以UTF-8编码成字节写入基础的字节输出流
write(int/byte[]/byte[]一部分) 支持写字节数据出去
3.示例：
import java.io.DataOutputStream;
import java.io.FileOutputStream;
public class Test8 {
public static void main(String[] args) {
try(DataOutputStream dos = new DataOutputStream(new FileOutputStream("FileAndIO\\IO\\src\\WGAT.txt"));){
dos.writeByte(32);
dos.writeBoolean(true);
dos.writeInt(2134);
dos.writeUTF("sad好好好");
dos.write(97);//a
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}二:DataInputStream（数据输入流）
1.用于读取数据输出流写出去的数据
2.使用：
构造器：
DataInputStream(InputStream is) 创建新数据输入流包装基础的字节输入流
方法：
readByte() 读取字节数据返回
readInt() 读取int类型的数据返回
readDouble() 读取double类型的数据返回
readUTF() 读取字符串数据(UTF-8)返回
readInt()/read(byte[]) 支持读字节数据进来
3.示例：
import java.io.DataInputStream;
import java.io.FileInputStream;
public class Test9 {
public static void main(String[] args) {
try(DataInputStream dis = new DataInputStream(new FileInputStream("FileAndIO\\IO\\src\\WGAT.txt"))){
byte b = dis.readByte();
System.out.println(b);
boolean b1 = dis.readBoolean();
System.out.println(b1);
int i = dis.readInt();
System.out.println(i);
String s = dis.readUTF();
System.out.println(s);
int read = dis.read();
System.out.println(read);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}三:ObjectOutputStream（对象字节输出流）
1.可以把Java对象进行序列化：把Java对象存入到文件中去。
2.使用：
构造器：
ObjectOutputStream(OutputStream out) 创建字节对象输出流，包装基础的字节输出流
方法：
writeObject(object o) 把对象写出去
3.注意：对象如果要参与序列化，必须实现序列化接口(java.io.Serializable)
4.示例：
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class Test10 {
public static void main(String[] args) {
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("FileAndIO\\IO\\src\\WGAT.txt"))){
User u = new User("王凯",18,95,"sada2");
oos.writeObject(u);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}四:ObjectInputStream（对象字节输入流）
1.可以把Java对象进行反序列化：把存储在文件中的Java对象读入到内存中来。
2.使用：
构造器：
ObjectInputStream(InputStream is) 创建字节输出流，包装基础的字节输入流
方法：
readObject() 把存储在文件中的Java对象读出来
3.示例：
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class Test11 {
public static void main(String[] args) {
try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream("FileAndIO\\IO\\src\\WGAT.txt"));){
User u = (User) ois.readObject();
System.out.println(u);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}4.注意：如果要一次序列化多个对象可以使用ArrayList集合存储多个对象，然后直接对集合进行序列化(ArrayList集合已经实现了序列化接口)
5.若某个成员变量不想参与序列化可在其前面加上transient
如：private transient String code;
---------------------------------------------------------------------------------------------------------------------------------IO框架
一:什么是框架？
1.解决某类问题，编写的一套类，接口等，可以理解成一个半成品，大多框架都是第三方研发的。
2.好处：在框架的基础上开发，可以得到优秀的软件框架，并能提高开发效率
3.框架的形式：一般是把类、接口等编译成class形式，再压缩成一个.jar结尾的文件发行出去。
二:什么是IO框架？
1.封装了Java提供的对文件、数据进行操作的代码，对外提供了更简单的方式来对文件进行操作，对数据进行读写等。
2.Commons-io
Commons-io是apache开源基金组织提供的一组有关IO操作的小框架，目的是提高IO流的开发效率。
3.使用
FileUtils提供的部分方法展示
copyFile(File srcFile, File destFile) 复制文件
copyDirectory(File srcDir, File destDir) 复制文件夹
deleteDirectory(File directory) 删除文件夹
readFileToString(File file, String encoding) 读数据
writeStringToFile(File file, String data, String charname, boolean append) 写数据
IOUtils类提供的部分方法展示
copy(InputStream inputstream, OutputStream outputStream) 复制文件
copy(Reader reader, Writer writer) 复制文件
write(String data, OutputStream output, String charsetName) 写数据
4.示例：
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
public class Main {
public static void main(String[] args) {
FileUtils.copyFile(, );
FileUtils.copyDirectory(, );
FileUtils.deleteDirectory();//无论是否是空文件夹都能删除
FileUtils.readFileToString(, );
FileUtils.writeStringToFile(, , );
IOUtils.copy(, );
IOUtils.copy(, );
IOUtils.write(, , );
}
}
786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
