1.理论：
1.File 文件的操作
创建文件夹（目录）
mkdir/mkdirs
创建文件
createNewFile
把我们自己写的功能打成jar包！
2.IO流
编码格式 gb2312 gbk iso-8859-1 utf-8
一组有序的数据序列，我们称之为流！
按照流的走向，我们分为： 输入流和输出流！
源头 参照物
自来水公司 ======》 水龙头 ======》使用水（取水）
输入流 输出流
我们输入内容（文字，视频，音频，图片，java对象.....） 到 内存中=====》输入流
我们从内存中获取（文字，视频，音频，图片，java对象.....） =====》输出流
我们所研究的流 以内存 为参照物！
所有的输入流都有read() 读
所有的输出流都有write() 写
基类
按照数据处理 分为以下 几种！！
字节流 byte字节 int类型 4个字节 中文占几个字节？ GBK 2个字节！ utf-8 3个字节！数字和字母都是一个！
a b c = 我
InputStream
OutputStream
都是抽象类，我们使用他们的实现类！
释放资源的时候有个原则：
先开后关！
input
output
output.close();
input.close();
字符流
Reader
Writer
缓冲流
BufferedReader
BufferedWriter
2进制流 （图片，视频.....）
DataInputStream
DataOutputStream
序列化和反序列化
是持久化技术中的其中一种实现方式！
ObjectInputStream
ObjectOutputStream
2.字节流
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
* 字节 输入流 从电脑中的某个盘符下的某个文件中 到 内存！！！
*/
public class FileInputStreamDemo {
public static void main(String[] args) {
InputStream stream = null;
try {
stream = new FileInputStream("e:/io.txt");
System.out.println("输入流中可读取的字节数：" + stream.available());
// 定义一个变量 接收int类型的返回值
int num = 0;
// 获取文件中的内容
while ((num = stream.read()) != -1) {
System.out.println((char) num);
}
/**
* stream.read()
* 从stream中读取一个8位的字节！然后转换成了0-255之间的整数返回！
* 如果读到了stream的结尾，返回-1！
*
* stream.read(byte[] b)
* 从stream中读取若干个字节，保存到了b字节数组中！
* 返回的整数表示读取了多少个字节！如果读到了stream的结尾，返回-1！
*
* stream.read(byte[] b,int off,int length)
* 从stream中读取若干个字节，保存到了b字节数组中！
* 参数off:在b字节数组中开始保存数据的起始下标！
* length：读取的字节数量！返回的整数表示读取了多少个字节！
* 如果读到了stream的结尾，返回-1！
*/
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally { // 释放资源
try {
stream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* 字节 输出流
*/
public class FileOutputStreamDemo {
public static void main(String[] args) {
OutputStream stream = null;
try {
stream = new FileOutputStream("e:/io.txt"); // 不会覆盖之前的内容
stream.write("我爱你中国!！".getBytes());
stream.flush(); // 无效
/**
* OutputStream本身没有设置缓冲区！
* 它的子类中有！ 比如 BufferedOutputStream 和PrintStream中有带缓冲区！
*
* 举个例子：
* 你家在黄土高坡！
* 现在需要从松花江上给老家送 松花蛋！
*
* 比如说 你现在需要1000个松花蛋！
* 没有缓冲区 就是 每生产一个就会送一个到你家！
* 这样需要送1000次！
* 有缓冲区，就是先把生产出来的松花蛋放进仓库！等仓库满了之后或者flush（）的时候
* 才去发送！
*
* flush（） 举例：
* 现在我的仓库有50个松花蛋！ 但是 用户flush（）， 那么不需要等待仓库装满！
* 立即发送！
*/
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
stream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.字符流
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/*
* 字符 输入流
*/
public class FileReaderDemo {
public static void main(String[] args) {
// 创建输入流对象
Reader reader = null;
try {
reader = new FileReader("e:/io.txt");
int num = 0;
// 创建char类型的字符数组 用来保存 输入流中的数据
char[] words = new char[1024];
// 创建字符串对象
StringBuffer sb = new StringBuffer();
while ((num = reader.read(words)) != -1) {
sb.append(words);
}
System.out.println(sb.toString());
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/**
* 字符输出流
*/
public class FileWriterDemo {
public static void main(String[] args) {
Writer writer = null;
try {
writer = new FileWriter("e:/io.txt", true);
// 开始从内存中输出到 文件中
writer.write("我也爱你！");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
writer.close(); // 释放资源
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4.缓冲区输入输出流
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/**
*
* BufferedReader
*
* 01.带有缓冲区的 输入流
* 02.可以逐行读取
*/
public class BufferedReaderDemo {
public static void main(String[] args) {
Reader reader = null;
BufferedReader br = null;
try {
reader = new FileReader("e:/io.txt");
br = new BufferedReader(reader);
StringBuffer sb = new StringBuffer();
String line = null;
// 开始循环读取
while ((line = br.readLine()) != null) {
sb.append(line);
}
System.out.println(sb.toString());
} catch (Exception e) {
e.printStackTrace();
} finally {
try { // 释放资源
br.close();
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/**
* 带有缓冲区的 输出流
*/
public class BufferedWriterDemo {
public static void main(String[] args) {
Writer writer = null;
BufferedWriter bw = null;
try {
writer = new FileWriter("e:/io.txt", true);
bw = new BufferedWriter(writer);
// 开始输出
bw.write("今天天气不错1111！");
bw.newLine();
bw.write("今天天气不错呀2222！");
bw.flush();
bw.write("今天天气不错呀3333！");
bw.write("今天天气不错呀4444！");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
bw.close();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
5.二进制输入输出流
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
/**
* 2进制 的输入 输出流
*/
public class DataStreamDemo {
public static void main(String[] args) throws Exception {
InputStream in = new FileInputStream("e:/U2/music.mp3");
// 从电脑中读取某个2进制文件
DataInputStream dis = new DataInputStream(in);
OutputStream out = new FileOutputStream("e:/haha.mp3");
// 需要从内存中 放到电脑中的指定位置
DataOutputStream dos = new DataOutputStream(out);
int num = 0;
// 读取之后 直接 写入
while ((num = dis.read()) != -1) {
// 写入
dos.write(num);
}
dos.close();
dis.close();
out.close();
in.close();
}
}
6.序列化和反序列化
import java.io.Serializable;
/**
* 这个类创建的对象 就可以 序列化
*/
public class User implements Serializable {
private String name; // 用户名
private String password; // 密码
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public User(String name, String password) {
super();
this.name = name;
this.password = password;
}
public User() {
super();
}
@Override
public String toString() {
return "User [name=" + name + ", password=" + password + "]";
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.Scanner;
/**
* 序列化 和 反序列化
*/
public class ObjectStreamDemo {
static Scanner input = new Scanner(System.in);
public static void main(String[] args) throws Exception {
// 调用add
add();
// 登录的方法
System.out.println("请输入您的用户名：");
String name = input.next();
System.out.println("请输入您的密码：");
String password = input.next();
/**
* 用户输入的这个用户名和密码 需要和 文件中的对象 进行比较
* 01.怎么从文件中获取这个对象到 内存中呢？
* 02.使用ObjectInputStream 输入流
*/
InputStream in = new FileInputStream("e:/student.txt");
ObjectInputStream ois = new ObjectInputStream(in);
User user = (User) ois.readObject();
if (user.getPassword().equals(password) && user.getName().equals(name)) {
System.out.println("登录成功！");
} else {
System.out.println("登陆失败！");
}
ois.close();
in.close();
}
// 注册用户
public static void add() throws Exception {
System.out.println("请输入您的用户名：");
String name = input.next();
System.out.println("请输入您的密码：");
String password = input.next();
// 创建用户对象
User user = new User(name, password);
// 想把我们这个user对象放进文件中
OutputStream out = new FileOutputStream("e:/student.txt");
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(user);
oos.close();
out.close();
}
}