IO:指的是设备之间进行数据传入的流
按照流向分类：
输入流
输出流
按照数据类型分类：
字节流
A:字节输入流 InputStream
FileInputStream:
FileInputStream fis = new FileInputStream("读取数据的文件名");
字节缓冲输入流：BufferedInputStream
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("读取数据的文件名"));
//注意：这里的文件必须提前存在
字节输入流读取数据两种方式：
1、一次读取一个字节
int b = 0;
while((b=bis.read())!=-1){
System.out.print((char)b);
}
bis.close();
2、一次读取一个字节数组
byte[] bytes = new byte[1024];
int length = 0;
while((length = bis.read(bytes))!=-1){
System.out.print(new String(bytes,0,length));
}
bis.close();
B: 字节输出流 OutputStream
FileOutputStream:
FileOutputStream fos = new FileOutputStream("写文件的名字");
字节缓冲输出流：BufferedOutputStream
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(写文件的名字));
//注意：这里文件，可以不存在，之后会自动创建
写数据的方式：
1、一次写一个字节
2、一次写一个字节数组
3、一次写一个字节数组的一部分
字符流（转换流） = 字节流 + 编码表
A: 字符输入流 Reader
InputStreamReader:
InputStreamReader isr = new InputStreamReader(new FileInputStream("读取数据的文件名"));
简化写法：FileReader
FileReader fr = new FileReader("读取数据的文件名");
普通字符输入流读取数据两种方式：
1、一次读取一个字符
int ch = 0;
while((ch = fr.read())!=-1){
System.out.print((char) ch);
}
fr.close();
2、一次读取一个字符数组
char[] chars = new char[1024];
int length = 0;
while((length = fr.read(chars))!=-1){
System.out.print(new String(chars,0,length));
}
fr.close();
字符缓冲输入流：BufferedReader
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("读取数据的文件名")));
BufferedReader br = new BufferedReader(new FileReader("读取数据的文件名"));
字符流读取数据的第三种方式：一次读取一行 readLine()
String s = null;
while((s = br.readLine())!=null){
System.out.print(s);
}
br.close();
B: 字符输出流 Writer
OutputStreamWriter:
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("写文件的名字"));
简化写法：FileWriter
FileWriter fw = new FileWriter("写文件的名字");
写数据的方式：
一次写一个字符
一次写一个字符数组
一次写一个字符数组的一部分
一次写一个字符串
高效流，字符缓冲输出流：BufferedWriter
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("写文件的名字")));
BufferedWriter bw = new BufferedWriter(new FileWriter("写文件的名字"));
字符流特殊的写数据方法：
newLine() 写一个换行符，根据系统不同，这里换行符也是不一样的。
字节输入流：InputStream(抽象类)
FileInputStream
FileInputStream的构造方法
FileInputStream(File file)
FileInputStream(String name)
字节输入流读取数据两种方式：
FileInputStream的成员方法
public int read()
public int read(byte[] b)
一次读取一个字节
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class FileInputStreamDemo1 {
public static void main(String[] args) throws Exception {
//1、创建字节输入流对象
//FileInputStream(File file)
//读取数据的时候，如果文件不存在，报错
File file = new File("a.txt");
FileOutputStream fos = new FileOutputStream(file);
fos.write("sddd".getBytes());
FileInputStream fis = new FileInputStream(file);// (系统找不到指定的文件。)
//调用read方法读取数据，并输出在控制台上
//public int read()，一次只能读取一个字节，返回的是ASCII码值,强制类型转换
int read = fis.read();
System.out.println((char) read);
//如果文件中数据很多的话，还是这样一个字节一个字节的读取，没有做任何改进，即将会很麻烦
//使用循环改进读取
//由于我们不知道什么时候将文件数据读取完毕，所以使用while循环
//控制跳出while循环的条件是什么，数据的下一个字节，如果达到文件的末尾， -1 。
//字节输入流读取数据的第一种方式最终版写法：
int i=0;
while ((i=fis.read())!=-1){
System.out.println((char) i);
}
fis.close();
fos.close();
}
}
结果（文件里）：
s
d
d
d字节输入流读取数据的第二种方式：一次读取一个字节数组
public int read(byte[] b)
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class FileInputStreamDemo2 {
public static void main(String[] args) throws Exception {
//1、创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");
//2、读取数据
//public int read(byte[] b)
//定义一个字节数组
// byte[] bytes = new byte[8];
// //一旦调用这个方法，将实际获取到的字节存储到数组中，返回的是，数组实际读取到的字节数
// int i = fis.read(bytes);
// System.out.println(i);
for(byte b:bytes){
System.out.print((char) b);
}
System.out.println("=============");
String s = new String(bytes);
System.out.println(s);
// String s = new String(bytes, 0, i);
// System.out.println(s);
//用循环改进
//字节流读取数据的第二种方式最终代码
//读入缓冲区的总字节数，如果没有更多的数据，因为文件的结尾已经到达， -1 。
byte[] bytes = new byte[1024];//这里要求以后都为1024或者1024的倍数
int length=0;
while ((length= fis.read(bytes))!=-1){
System.out.println(new String(bytes,0,length));
}
}
}
结果（文件里）：
sddd把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
输入流
InputStream -- FileInputStream
一次读取一个字节
一次性读取一个字节数组
a.txt
输出流
OutputStream -- FileOutputStream
一次写一个int类型数值
一次写一个字节数组
一次写一个字节数组的一部分
b.txt
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class CopyFileDemo1 {
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("b.txt");
// //2、读取数据
// //a: 一次读取一个字节
// int i=0;
// while ((i= fis.read())!=-1){
// System.out.println();
// fos.write(i);
// }
//b: 一次读取一个字节数组
byte[] bytes = new byte[1024];
int length=0;
while ((length=fis.read(bytes))!=-1){
System.out.println();
fos.write(bytes,0,length);
}
fos.close();
fis.close();
}
}
把当前项目下的冯提莫.jpg复制到当目录下并且改名字为ftm.jpg
数据源：从哪来
冯提莫.jpg -- 读取数据 -- InputStream -- FileInputStream
目的地：到哪里去
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class CopyJpgDemo1 {
public static void main(String[] args) throws Exception {
//创建字节输入流对象和字节输出流对象
FileInputStream fis = new FileInputStream("src\\Days23\\ftm.jpg");
FileOutputStream fos = new FileOutputStream("冯提莫.jpg");
byte[] bytes = new byte[1024];
int length = 0;
while ((length = fis.read(bytes)) != -1) {
fos.write(bytes, 0, length);
}
fos.close();
fis.close();
}
}
缓冲区类（高效类）
字节缓冲输出流
BufferedOutputStream
字节缓冲输入流
BufferedInputStream
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilterOutputStream;
public class BufferedOutStreamDemo1 {
public static void main(String[] args) throws Exception {
//BufferedOutputStream(OutputStream out)
//创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
// FileOutputStream fos = new FileOutputStream("g.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("c.txt"));
bos.write("大数据".getBytes());
bos.close();
}
}
字节缓冲输入流
BufferedInputStream
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class BufferedInputStreamDemo1 {
public static void main(String[] args) throws Exception {
//BufferedInputStream
//BufferedInputStream(InputStream in)
//创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
// FileInputStream fis = new FileInputStream("g.txt");
// BufferedInputStream bis = new BufferedInputStream(fis);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c.txt"));
// int i=0;
// while ((i=bis.read())!=-1){
// System.out.println((char) i);
//
// }
System.out.println("==========================");
byte[] bytes = new byte[1024];
int length=0;
while ((length=bis.read(bytes))!=-1){
System.out.println(new String(bytes,0,length));
}
bis.close();
}
}字节流一次只读一个字节的时候，如果数据是中文，出现了我们看不懂的符号
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class BufferedInputStreamDemo2 {
public static void main(String[] args) throws Exception {
// 字节流一次只读一个字节的时候，如果数据是中文，出现了我们看不懂的符号
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c.txt"));
int i=0;
while ((i=bis.read())!=-1){
System.out.println((char) i);
}
}
}这里是因为一个中文字符有三个字节组成这里每次只能读取一个字节String(byte[] bytes, Charset charset)
构造一个新的String由指定用指定的字节的数组解码charset 。解码
byte[] getBytes(Charset charset)
使用给定的charset将该String编码为字节序列，将结果存储到新的字节数组中。 编码
编码：把看得懂的变成看不懂的，类似于加密
String -- byte[]
解码：把看不懂的变成看得懂的，类似于解密
byte[] -- String
public class StringDemo {
public static void main(String[] args) throws Exception {
String s = "你好";
//String -- byte[]
// byte[] bytes = s.getBytes("GBK");
// System.out.println(bytes);
// printArray(bytes);
byte[] bytes1 = s.getBytes("Unicode");
printArray(bytes1);
System.out.println();
String s1 = new String(bytes1, "Unicode");
System.out.println(s1);
}
public static void printArray(byte[] bytes) {
for (byte b : bytes) {
System.out.println(b + ",");
}
}
}
结果：
-2,
-1,
79,
96,
89,
125,字符流：
字符输入流
Reader
字符输出流
Writer
Writer
OutputStreamWriter: 字符输出流 是以字节流加上编码表得到的一个转换流，后期写数据的时候可以根据自己指定的编码进行写入
public OutputStreamWriter(OutputStream out)
创建一个使用默认字符编码的OutputStreamWriter。根据默认的编码用字符作为桥梁将字节流的数据转换为字符流
public OutputStreamWriter(OutputStream out,String charsetName)
根据指定的编码用字符作为桥梁将字节流的数据转换为字符流
把字节流转化字符流
字符流 = 字节流 + 编码表
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo1 {
public static void main(String[] args) throws Exception {
//1、创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("aaa.txt"),"UTF-8");
osw.write("中国");
osw.close();
//这里编码表要与文本里一致即为UTF-8
}
}Reader
InputStreamReader: 字符输入流
public InputStreamReader(InputStream in)
读取数据，根据默认的编码用字符作为桥梁将字节流的数据转换为字符流
public InputStreamReader(InputStream in,String charsetName)
读取数据，根据指定的编码用字符作为桥梁将字节流的数据转换为字符流
mport java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo1 {
public static void main(String[] args) throws Exception {
InputStreamReader isr = new InputStreamReader(new FileInputStream("aaa.txt"), "UTF-8");
int i=0;
while ((i= isr.read())!=-1){
System.out.println((char) i);
}
isr.close();
}
}
结果：
中
国OutputStreamWriter写数据的方法：
public void write(int c)
public void write(char[] cbuf)
public void write(char[] cbuf,int off,int len)
public void write(String str)
public void write(String str,int off,int len)
flush()和close()的区别：
1、调用完flush()后，流对象并没有关闭，还能继续写数据。
2、调用完close()后，流对象关闭了，后续无法再通过这个对象写数据。
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWriteDemo2 {
public static void main(String[] args) throws Exception {
//1、创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("bbb.txt"));
//写数据
//public void write(int c) 写一个字符
osw.write(99);
osw.write('a');
//现象，我们在把close去掉之后，发现数据没有写入到文件中
//原因
//文件实际上在硬盘存储的是字节，需要手动转换一下进行存储
//void flush()
//刷新流。
// osw.flush();
//public void write(char[] cbuf) 写一个字符数组
char[] chars = {'a','b','c','d','e'};
osw.write(chars);
//public void write(char[] cbuf,int off,int len) 写字符数组的一部分
osw.write(chars,1,3);
//public void write(String str)
osw.write("明和王真帅");
//public void write(String str,int off,int len) 写字符串的一部分
osw.write("明和王真帅",3,2);
osw.close();
}
}InputStreamReader:字符输入流
读取数据的方法：
public int read()
public int read(char[] cbuf)
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo2 {
public static void main(String[] args) throws Exception {
//1、创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("c.txt"));
// int i = 0;
// while ((i = isr.read()) != -1) {
// System.out.println((char) i);
// }
//一次读取一个字符数组
//读取的字符数，如果已经达到流的结尾，则为-1
char[] chars = new char[1024];
int length = 0;
while ((length = isr.read(chars)) != -1) {
System.out.print(new String(chars, 0, length));
}
isr.close();
}
}
把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：
a.txt -- 读取数据 -- 字符输入流 -- Reader -- InputStreamReader
目的地：
b.txt -- 写出数据 -- 字符输出流 -- Writer -- OutputStreamWriter
import java.io.*;
public class CopyFileDemo2 {
public static void main(String[] args) throws Exception {
//1、创建字符输入流对象和字符输出流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("aaa.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("bbb.txt"));
//读写数据
//第一种方式
// int i =0;
// while ((i= isr.read())!=-1){
// osw.write(i);
// osw.flush();
// }
char[] chars = new char[1024];
int length = 0;
while ((length = isr.read(chars)) != -1) {
osw.write(chars, 0, length);
}
osw.close();
isr.close();
}
}由于我们常见的操作都是使用本地默认的编码，我们基本上使用的时候不去指定编码
但是呢，我觉得创建字符转换流对象的时候，名字有点长，所以Java提供了子类给我们使用
字符流 = 字节流 + 编码表
OutputStreamWriter = FileOutputStream + 编码表
InputStreamReader = FileInputStream + 编码表
把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：
a.txt -- 读取数据 -- 字符输入流 -- Reader -- InputStreamReader -- FileReader
目的地：
b.txt -- 写出数据 -- 字符输出流 -- Writer -- OutputStreamWriter -- FileWriter
import java.io.*;
public class CopyFileDemo3 {
public static void main(String[] args) throws Exception {
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
// int i=0;
// while ((i=isr.read())!=-1){
// osw.write(i);
// osw.flush();
// }
char[] chars = new char[1024];
int length=0;
while ((length=isr.read(chars))!=-1){
osw.write(chars,0,length);
}
osw.close();
isr.close();
}
}字符流为了高效读写，也提供了对应的字符缓冲流
字符缓冲输出流：BufferedWriter
字符缓冲输入流: BufferedReader
BufferedWriter:
将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
可以指定缓冲区大小，或者可以接受默认大小。 默认值足够大，可用于大多数用途。
BufferedWriter(Writer out)
创建使用默认大小的输出缓冲区的缓冲字符输出流。
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo1 {
public static void main(String[] args) throws Exception {
InputStreamReader isr = new InputStreamReader(new FileInputStream("aaa.txt"), "UTF-8");
int i=0;
while ((i= isr.read())!=-1){
System.out.println((char) i);
}
isr.close();
}
}
BufferedReader: 字符缓冲输入流
从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途
BufferedReader(Reader in)
创建使用默认大小的输入缓冲区的缓冲字符输入流。
public class BufferedReadDemo1 {
public static void main(String[] args) throws Exception {
// BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
//1、一次读取一个字符
// int i=0;
// while ((i= br.read())!=-1){
// System.out.println((char) i);
// }
char[] chars=new char[1024];
int length=0;
while ((length= br.read(chars))!=-1){
System.out.println(new String(chars,0,length));
}
br.close();
}
}把当前项目目录下的bbb.txt内容复制到当前项目目录下的c.txt中
数据源：
a.txt -- 读取数据 -- 字符输入流 -- Reader -- InputStreamReader -- FileReader -- BufferedReader
目的地：
b2.txt -- 写入数据 -- 字符输出流 -- Writer -- OutputStreamWriter -- FileWriter -- BufferedWriter
import java.io.*;
public class CopyFileDemo4 {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new FileReader("bbb.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));
char[] chars = new char[1024];
int lenngth=0;
while ((lenngth=br.read(chars))!=-1){
bw.write(chars,0,lenngth);
}
bw.close();
br.close();
}
}字符缓冲流的特殊读写方法：
BufferedWriter:
void newLine()
写一行行分隔符。 行分隔符字符串由系统属性line.separator定义，并不一定是单个换行符（'\ n'）字符。
BufferedReader:
public String readLine()
读一行文字。 一行被视为由换行符（'\ n'），回车符（'\ r'）中的任何一个或随后的换行符终止。
import java.io.*;
public class BuffereedDemo1 {
public static void main(String[] args) {
try {
read();
} catch (Exception e) {
e.printStackTrace();
}
try {
write();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void read() throws Exception {
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
//public String readLine() 一次读取一行文字
//包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null
// String s = br.readLine();
// System.out.println(s);
// String s1 = br.readLine();
// System.out.println(s1);
//用循环读取
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
}
public static void write() throws Exception {
BufferedWriter bw = new BufferedWriter(new FileWriter("a3.txt"));
for (int i = 0; i <= 10; i++) {
bw.write("大数据" + i);
bw.newLine();
}
bw.close();
}
}把ArrayList集合中的字符串数据存储到文本文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class IOTest1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//向集合中添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("bigdata");
BufferedWriter bw=null;
try {
bw = new BufferedWriter(new FileWriter("a4.txt"));
for (String s:list){
bw.write(s);
bw.newLine();
bw.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
已知s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”
请编写程序读取数据内容，把数据排序后写入ss.txt中。
import java.io.*;
import java.util.Arrays;
public class IOTest2 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("s.txt"));
String s = br.readLine();
br.close();
//将字符串转成字符数组
char[] chars = s.toCharArray();
//Arrays工具类中sort方法排序
Arrays.sort(chars);
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
bw.write(chars);
bw.flush();
bw.close();
}
}import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilterOutputStream;
public class DataOutputStreamDemo1 {
public static void main(String[] args) throws Exception {
//创建字节输出流操作基本数据类型数据
DataOutputStream bos = new DataOutputStream(new FileOutputStream("b1.txt"));
//写基本类型的数据
bos.writeByte(1);
bos.writeShort(5);
bos.writeInt(10);
bos.writeLong(100);
bos.writeFloat(13.45F);
bos.writeDouble(12.34);
bos.writeChar('d');
bos.writeBoolean(true);
//释放资源
bos.close();
}
}
import java.io.*;
public class DataInputStreamDemo1 {
public static void main(String[] args) throws Exception {
write();
read();
}
public static void read() throws Exception {
DataInputStream dis = new DataInputStream(new FileInputStream("b1.txt"));
byte b=dis.readByte();
System.out.println(b);
short s= dis.readShort();
System.out.println(s);
int i= dis.readInt();
System.out.println(i);
long l= dis.readLong();
System.out.println(l);
float f= dis.readFloat();
System.out.println(f);
double d= dis.readDouble();
System.out.println(d);
char c= dis.readChar();
System.out.println(c);
boolean o= dis.readBoolean();
System.out.println(o);
dis.close();
}
private static void write() throws IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream(
"dos.txt"));
dos.writeByte(1);
dos.writeShort(20);
dos.writeInt(300);
dos.writeLong(4000);
dos.writeFloat(12.34f);
dos.writeDouble(12.56);
dos.writeChar('a');
dos.writeBoolean(true);
dos.close();
}
}
序列化：把对象按照流一样的方式存到文本文件或者数据库或者在网络中传输
对象 -- 流数据: ObjectOutputStream
反序列化：把文本文件中的流对象数据或者网络中的流数据还原成一个对象
流数据 -- 对象: ObjectInputStream
测试类
import java.io.*;
public class ObjectStreamDemo1 {
public static void main(String[] args) throws Exception {
//写方法，将对象存入到文件中，其实就是将对象进行持久化
write();
//读方法：把文本文件中的流对象数据或者网络中的流数据还原成一个对象
read();
}
public static void read() throws Exception {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
Object o = ois.readObject();
ois.close();
}
public static void write() throws Exception {
ObjectOutput oo = new ObjectOutputStream(new FileOutputStream("obj.txt"));
//创建一个对象
Person person = new Person("小明", 18);
oo.writeObject(person);
oo.close();
}
}
Person类
未序列化异常：
NotSerializableException
类的序列化由实现java.io.Serializable接口的类启用。
不实现此接口的类将不会使任何状态序列化或反序列化。
可序列化类的所有子类型都是可序列化的。
序列化接口没有方法或字段，仅用于标识可串行化的语义。
InvalidClassException: com.shujia.wyh.day24.Person;
local class incompatible:
stream classdesc serialVersionUID = -6572568087538942853,
local class serialVersionUID = 2880662336900677170
为什么会出现这样的问题呢？
Person类实现了Serializable接口，而Serializable接口是一个标记接口，这里的标记其实是一个标记值
假设一开始的时候这个标记的值是id = 100.
在没有修改Person之前：
Person.class -- id:100
写数据的时候：obj.txt -- id:100
读数据的时候：obj.txt -- id:100
进行了修改后：（把private删除了）
Person.class -- id:200
写数据的时候：obj.txt -- id:100
读数据的时候：obj.txt -- id:100
在实际开发中，我们有时候，就会出现这样的问题，怎么办呢？我们正常去做的时候再写一遍数据，再读一次
但是呢，真实业务中，肯定是不允许出现多次插入相同的数据。
那我们应该怎么办呢？
这个问题我们就要去思考本质是什么，本质是两个序列号要是一样的，如果有一种办法使得我们怎么去改类的时候，都不会去影响到这个id值
就好了。
java按照我们所想的那样提供了一个ID值，可以让我们去设定，serialVersionUID。
需求：
现在我不想在序列化的时候把年龄也存储到文件中
java提供了一个关键字，可以让我们在序列化过程中选择哪些成员不被序列化
叫做transient.
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = 7649840165648125569L;
private String name;
int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}user: root
password: 123456
import java.util.Properties;
public class PropertiesDemo {
public static void main(String[] args) {
Properties properties = new Properties();
properties.setProperty("user","root");
properties.setProperty("password","123456");
String user = properties.getProperty("user");
String password = properties.getProperty("password");
System.out.println(user+"--"+password);
}
}
结果：
root--123456后台线程：（守护线程）
public final void setDaemon(boolean on)
Java中有两类线程：用户线程，守护线程
用户线程：在学习多线程之前，运行起来的一个个的线程都是用户线程
守护线程：所谓守护线程，指的是程序在运行的时候，在后台提供了一个通用的服务线程。比如说垃圾回收线程，他就是一个守护线程
并且这种线程并不是一定存在的，所以反过来说，只要程序存在守护线程，程序就不会终止。
守护线程怎么去设置呢？
public final void setDaemon(boolean on)
注意：
1、守护线程必须在启动之前进行设置
2、当运行的程序只有一个线程的时候并且这个线程是守护线程的时候，Java虚拟机退出（程序停止）
//MyDaemonThread
public class MyDaemonThread extends Thread{
@Override
public void run() {
for (int i=1;i<=200;i++){
System.out.println(getName()+":"+i);
}
}
}//ThreadDaemonDemo
public class ThreadDaemonDemo {
public static void main(String[] args) {
MyDaemonThread t1 = new MyDaemonThread();
MyDaemonThread t2 = new MyDaemonThread();
MyDaemonThread t3 = new MyDaemonThread();
t1.setName("刘备");
t2.setName("关羽");
t2.setDaemon(true);
t3.setName("张飞");
t3.setDaemon(true);
t1.start();
t2.start();
t3.start();
}
}
