day12 字符流、字符缓冲流、转换流、对象操作流、Properties
目录
一、字符流
1.1 字节流操作文本文件出现乱码问题
1.2 编码表
1.3 String字符串中编码和解码的方法
1.3.1.编码
1.3.2.解码
1.4 字节流读取中文出现乱码的原因
1.5 字符流读取中文的过程
1.6 技术选型(应用场景)
1.7 字符流写数据
1.8 字符流写数据的注意事项
1.9 字符流flush和close方法
1.10 字符流读数据
1.10.1 一次读一个字符
1.10.2 一次读多个字符
二、字符缓冲流
2.1 字符缓冲输出流
2.2 字符缓冲输入流
2.3 字符缓冲流的特有方法
2.4 缓冲流练习
2.5 IO流小结
三、转换流
四、对象操作流
4.1 序列化和反序列化
4.2 对象操作流程的两个注意点
4.2.1 注意点1
4.2.2 注意点2
4.3 对象操作流程的问题注意点
五、Properties
5.1 Properties概述
5.2 Properties作为map集合的使用
5.3 Properties特有方法
5.4 Properties-load
5.4 Properties-store
一、字符流
1.1 字节流操作文本文件出现乱码问题
使用字节流读取带有中文数据的文件时,会出现乱码
代码示例public static void main(String[] args) throws IOException {FileInputStream fis = new FileInputStream("D:\\nnn.txt");int b;//读取多个字节while ((b = fis.read()) != -1) {//强转为字符,出现乱码System.out.print((char) b);//ä½ å¥½ææ¯JAVAè湿æº}fis.close();//释放资源,关流}
}1.2 编码表
了解内容1
1.计算机中存储的信息都是以二进制数表示的
2.编码: 按照某种规则, 将字符变为二进制, 再存储到计算机中
3.解码: 按照同样的规则, 将存储在计算机中的二进制数解析显示出来
4.编码和解码的方式如果不统一, 会造成乱码问题
了解内容2
1.ASCII码表: 没过信息交换标准代码, 包含了数字, 大小写字母和常见标点符号(不包含中文)
2.GBK码表: windows系统默认的码表, 在GBK码表中, 一个中文占两个字节,兼容ASCII, 包含了21003个汉字并支持繁体字以及部分日韩文字
3.Unicode码表: 被称为万国码, 计算机科学领域的一项业界标准, 容纳世界上大多数国家的常见文字和符号, 在Unicode万国码中, UTF-8编码一个中文占三个字节
4.IDEA中默认编码是UTF-8
1.3 String字符串中编码和解码的方法
1.3.1.编码
byte[] getBytes(); 使用平台默认的字符集将String编码为字节, 返回字节数组
byte[] getBytes(String charsetName); 使用指定的字符集将String编码为字节, 返回字节数组
代码示例String s = "你好李焕";byte[] bytes1 = s.getBytes();//使用idea默认编码 UTF-8System.out.println(Arrays.toString(bytes1));//[-28, -67, -96, -27, -91, -67, -26, -99, -114, -25, -124, -107]byte[] bytes2 = s.getBytes("GBK");//使用GBK编码System.out.println(Arrays.toString(bytes2));//[-60, -29, -70, -61, -64, -18, -69, -64]
1.3.2.解码
String(byte[] bytes); 使用平台默认的字符集解码字节数组, 构造成新的字符串
String(byte[] bytes, String charsetName); 使用指定的字符集解码字节数组, 构造成新的字符串
1.解码格式应和编码格式一致
代码示例byte[] b1 = {-28, -67, -96, -27, -91, -67, -26, -99, -114, -25, -124, -107};String s1 = new String(b1);//使用idea默认解码格式UTF-8System.out.println(s1);//你好李焕byte[] b2 ={-60, -29, -70, -61, -64, -18, -69, -64};String s2 = new String(b2,"GBK");//使用GBK解码格式System.out.println(s2);//你好李焕2.解码格式和编码格式不一致
出现问题:
编码格式为GBK,不写解码格式将会使用IDEA默认UTF-8格式,所以会出现乱码
解决方案:
构造String时,参数指定为GBK格式
byte[] b3 = {-60, -29, -70, -61, -64, -18, -69, -64};String s3 = new String(b3);//编码解码格式不一致会乱码System.out.println(s3);//������1.4 字节流读取中文出现乱码的原因
因为字节流一次读一个字节, 而不管是GBK还是UT8, 一个中文占多个字节, 字节流一次只读取了中文的一部分
1.5 字符流读取中文的过程
字符流本质
字符流 = 字节流 + 编码表
无论在哪张码表中
中文的第一个字节一定是: 负数
字符流读取中文的过程
当字符流读数据时, 读到了负数的字节就知道读到了中文
再去看使用的什么码表, 决定一次读几个字节 (GBK中2个, UTF-8中3个)
1.6 技术选型(应用场景)
1. 拷贝文件 -> 字节流/字节缓冲流
2. 读取文本文件中的数据到内存 -> 字符输入流
3. 将内存中的数据写入文本文件 -> 字符输出流
1.7 字符流写数据
1. 字符输出流构造
FileWriter(File对象); //不常用
FileWriter(字符串路径);
2. 字符流写数据的5种方式
1. void write(int c); 写一个字符 2. void write(char[] cbuf); 写一个字符数组 3. void write(char[] cbuf, int off, int len); 写一个字符数组的一部分 4. void write(String str); 写一个字符串 5. void write(String str, int off, int len); 写一个字符串的一部分
代码示例public class Demo02 {public static void main(String[] args) throws IOException {FileWriter fw = new FileWriter("day12\\demo02.txt");//FileWriter fw = new FileWriter(new File("day\\demo02.txt"));//不常用// 字符流写数据的5种方式// 1. void write(int c); 写一个字符fw.write(98);//写入 b// 2. void write(char[] cbuf); 写一个字符数组char[] chars = {'a','b','c','d','e'};fw.write(chars);//写入 abcde// 3. void write(char[] cbuf, int off, int len); 写一个字符数组的一部分fw.write(chars,0,3);//写入 abc// 4. void write(String str); 写一个字符串String s = "你好啊";fw.write(s);//写入 你好啊// 5. void write(String str, int off, int len); 写一个字符串的一部分fw.write(s,0,2);//写入 你好fw.flush();fw.close();}
}1.8 字符流写数据的注意事项
字符流写数据的注意事项
1. 构造方法时如果文件不存在, 会创建新的
2. 构造方法时如果路径错误, 会报错
3. 构造方法时如果文件存在, 先清空再写入
4. 构造方法时第二个参数不写, 默认为false, 表示新数据会覆盖老数据 (先清空再写入) , 追加写入需要手动给true
5. 如果内存中写出int类型的整数, 那么在文件里面写入的是该整数在码表对应的字符
6. 如果写出字符串, 是将该字符串本身原样写出
7. 必须释放资源
1.9 字符流flush和close方法
flush和close方法
flush(); 刷新流, 刷新后还可以写数据
close(); 关闭流释放资源, 注意关闭前会先刷新流, 再关闭; 但是关闭后就不能继续写数据了这两个一般一起写上
1.10 字符流读数据
1.10.1 一次读一个字符
代码示例public class Demo03 {public static void main(String[] args) throws IOException {FileReader fis = new FileReader("day12\\demo03.txt");int b;//一次读一个字节while ((b = fis.read()) != -1) {//不加强转//System.out.print(b);//2032022909251052615974658665327692828726426//加入强转System.out.print( (char) b);// 你好我是JAVA老湿机}fis.close();}
}
1.10.2 一次读多个字符
代码示例public class Demo04 {public static void main(String[] args) throws IOException {//1.创建字符输入流对象FileReader fr = new FileReader("day12\\demo03.txt");//2.创建字符数组char[] chars = new char[1024];//3.定义len表示读到的有效字符个数int len;//4.如果没有读到结尾,将继续读while ((len = fr.read(chars)) != -1) {//5.将读到的字符数组作为参数,构造新的字符串/* String s = new String(chars,0,len);System.out.println(s);*/System.out.println(new String(chars, 0, len));//你好我是JAVA老湿机}}
}
二、字符缓冲流
字符缓冲流
BufferedWriter: 字符缓冲输出流, 可以高效的写出数据
BufferedReader: 字符缓冲输入流, 可以高效的读取数据
为什么缓冲流更高效?
和字节缓冲流底层一个道理, 都是提供了一个8K的缓冲区, 尽量让操作在内存中实现
2.1 字符缓冲输出流
代码示例public class Demo05 {public static void main(String[] args) throws IOException {//创建字符缓冲输出流对象BufferedWriter bw = new BufferedWriter(new FileWriter("day12\\damo05.txt"));//写入整数bw.write(98);//写入 b//写入一个字符串数组char[] chars= {'a','b','c','d','e'};bw.write(chars);//写入 abcde//写入一个字符串数组的一部分bw.write(chars,0,3);//写入 abc//一次写入一个字符串String s = "你好";bw.write(s);//写入 你好//写入一个字符串的一部分bw.newLine();//插入换行bw.write(s,0,1);//写入 你bw.flush();bw.close();}
}2.2 字符缓冲输入流
代码示例public class Demo06 {public static void main(String[] args) throws IOException {//创建字符缓冲输入流对象BufferedReader br = new BufferedReader(new FileReader("day12\\demo05.txt"));char[] chars= new char[1024];int len;while ((len=br.read(chars))!=-1){System.out.println(new String(chars,0,len));//babcdeabc你好你}br.close();}
}2.3 字符缓冲流的特有方法
缓冲流特有方法
1. BufferWriter: void newLine(); 底层匹配系统, 写一行分隔(换行)符
2. BufferReader: void String readLine(); 读一行文字, 不读取分隔(换行)符, 到达文件结尾为null
代码示例public class Demo07 {public static void main(String[] args) throws IOException {BufferedWriter bw = new BufferedWriter(new FileWriter("day12\\demo07.txt"));bw.write("你好啊小黑");bw.newLine();//插入换行bw.write("你好啊小白");bw.flush();BufferedReader br = new BufferedReader(new FileReader("day12\\demo07.txt"));//读取整行数据String line;while ((line=br.readLine())!=null){System.out.println(line);}br.close();}
}2.4 缓冲流练习
练习需求: 读取文件中的数据, 排序后将数据写到本地文件
代码示例public class Demo08 {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new FileReader("day12\\demo08.txt"));//1.将读出来的整行数据赋值给String类型的变量lineString line = br.readLine();System.out.println(line);br.close();//读完关流,释放资源String[] arr = line.split(" ");//2.因为文件里的数据是用空格隔开,所以在这里用空格切割int[] newArr = new int[arr.length];//3.创建一个新的数组用来装文件里的数字,所以用int类型for (int i = 0; i < arr.length; i++) {//4.遍历读出来的数据newArr[i] = Integer.parseInt(arr[i]);//5.将原数据里面的字符串.转换成整数类型放在新的数组}Arrays.sort(newArr);//6.将新的数组排序BufferedWriter bw = new BufferedWriter(new FileWriter("day12\\demo0801.txt"));for (int i = 0; i < newArr.length; i++) {//7.遍历新的数组bw.write(newArr[i] + " ");//8.将这些重新排序的数据写进新的文件bw.flush();//刷新流}bw.close();//关流,释放资源}
}
2.5 IO流小结
IO流
1.流向分: 输入流(读)和输出流(写)
2.类型分:字节流和字符流
字节流(用来拷贝)和字符流(读写文本数据)
字节流: 一个一个字节拷贝慢, 通过数组+底层的缓冲区提升(缓冲流)
1.FileInputStream: 字节输入流 -> BufferedInputStream: 字节缓冲输入流
2.FileOuputStream: 字节输出流 -> BufferedOuputStream: 字节缓冲输出流
字符流:
1.FileReader: 字符输入流 -> BufferedReader: 字符缓冲输入流 -> readLine()读一行
2.FileWriter: 字符输出流 -> BufferedWriter: 字符缓冲输出流 -> newLine()换行
三、转换流
1. 什么是转换流?
可以将字符流和字节流相互转换
InputStreamReader
从字节流 -> 字符流的桥梁, 使用指定的charset将"读到的字节解码为字符"
OutputStreamWriter:
从字符流 -> 字节流的桥梁, 使用指定的charset将"写入的字符编码为字节"关系图示
文件 -> 字节流 -> 转换流InputStreamReader -> 字符流FileReader -> 内存
内存 -> 字节流 -> 转换流OutputStreamWriter -> 字符流FileWriter -> 文件
2. 指定编码读写
转换流的使用场景
JDK11之前: 指定编码读写
JDK11之后: 一般不会直接操作转换流了Charset.forName("解码格式),指定解码格式，需要和编码格式一致，否则乱码
代码示例public class Demo09 {public static void main(String[] args) throws IOException {//Charset.forName("解码格式),指定解码格式，需要和编码格式一致，否则乱码FileReader fr = new FileReader("day12\\demo09.txt", Charset.forName("UTF-8"));FileReader fr1 = new FileReader("day12\\demo09.txt", Charset.forName("GBK"));//乱码int ch;while ((ch=fr.read())!=-1){System.out.print((char)ch+" ");//我 是 J A V A 老 湿 机}System.out.println();int ch1;while ((ch1=fr1.read())!=-1){System.out.print((char)ch1+" ");//鎴 戞 槸 J A V A 鑰 佹 箍 鏈 � }}
}
四、对象操作流
对象操作流特点?
可以将对象以字节的形式, 书写到本地文件, 直接打开文件是读不懂的
如果要读取,需要再次用对象操作流读到内存中
对象操作流
1. 对象操作输入流 (对象反序列化流): ObjectInputStream
2. 对象操作输出流 (对象序列化流): ObjectOutputStream
Serializable接口
1. 是一个标记性接口, 接口中没有提供任何抽象方法
2. 实现这个接口代表该类对象可以被序列化, 否则会报错
4.1 序列化和反序列化
writeObject是对象操作输出流里的写出方法 readObject是对象操作输入流里的读取方法对象操作输入流 (对象反序列化流): ObjectInputStream
对象操作输出流 (对象序列化流): ObjectOutputStream
注意: 如果是自定义类,读取时需要强转成自定义类数据类型
Student o = (Student) ois.readObject();
代码示例public class Demo10 {public static void main(String[] args) throws IOException, ClassNotFoundException {//1.创建对象Student stu1 = new Student("张三", 23);Student stu2 = new Student("李四", 24);Student stu3 = new Student("王五", 25);//2.创建对象操作输出流(对象序列化)ObjectOutputStreamObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day12\\demo10.txt"));//3.写出对象oos.writeObject(stu1);oos.writeObject(stu2);oos.writeObject(stu3);oos.flush();oos.close();//4.创建对象操作输入流 (对象序列化流): ObjectInputStreamObjectInputStream ois = new ObjectInputStream(new FileInputStream("day12\\demo10.txt"));//5.读取对象Student o1 = (Student) ois.readObject();Student o2 = (Student) ois.readObject();Student o3 = (Student) ois.readObject();System.out.println(o1);//User{name='张三', age=23}System.out.println(o2);//User{name='李四', age=24}System.out.println(o3);//User{name='王五', age=25}ois.close();}}class Student implements Serializable {....@Overridepublic String toString() {final StringBuilder sb = new StringBuilder("User{");sb.append("name='").append(name).append('\'');sb.append(", age=").append(age);sb.append('}');return sb.toString();}
}
4.2 对象操作流程的两个注意点
4.2.1 注意点1
我们使用序列化流写入一个对象数据, 假如后来修改了对象所属的类文件, 那么再次读该对象时会不会出现问题?
会的,当序列化写出一个对象数据到硬盘,在读取之前,如果修改javaBean类里的属性权限修饰符,将会导致,读取时出现报错
Exception in thread "main" java.io.InvalidClassException: com.zifuliu.Student; local class incompatible: stream classdesc serialVersionUID = 1160229779064343401, local class serialVersionUID = -2400774396325432938
当我们通过序列化写出对象类时如果没有提供序列号,系统会默认给出一个.
这个报错说明, 通过系统会默认给出的序列号和读取时的序列号不一致
解决方案:
自定义一个序列号
private static final long serialVersionUID = 1L;
代码示例class Student implements Serializable {//自定义序列号private static final long serialVersionUID = 1L;private String name;private int age;.....}4.2.2 注意点2
如果一个对象中的某个成员变量的值, 不想被序列化, 应该怎么实现?
可以将该变量使用transient关键字修饰, 代表该变量就不参与序列化
class Student implements Serializable {//自定义序列号private static final long serialVersionUID = 1L;private String name;private transient int age;//age将不会参与序列化,在读取时该属性会变为默认属性值0或null
//1.创建对象 Student stu1 = new Student("张三", 23); Student stu2 = new Student("李四", 24); Student stu3 = new Student("王五", 25);//2.写出对象数据(省略)
//3.读取对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day12\\demo10.txt"));Student o1 = (Student) ois.readObject(); Student o2 = (Student) ois.readObject(); Student o3 = (Student) ois.readObject(); System.out.println(o1);//User{name='张三', age=0} System.out.println(o2);//User{name='李四', age=0} System.out.println(o3);//User{name='王五', age=0} ois.close();
4.3 对象操作流程的问题注意点
当使用whlie循环读取多个对象时,会报错
Object obj;
while ((obj=ois.readObject())!=null){System.out.println(obj);
}Exception in thread "main" java.io.EOFException
练习需求:
创建多个JavaBean对象到文件中, 再次读取到程序中
注意: 读取对象读到文件末尾, 不是-1, 而会报异常
解决方式1:
我们需要try...catch捕获异常, 然后结束while循环
Object obj;
while (true){try {obj = ois.readObject();System.out.println(obj);} catch (EOFException e) {break;//如果读到EOFException,结束循环} catch (ClassNotFoundException e) {e.printStackTrace();}
}解决方式2:
写对象时, 存入一个容器, 整体序列化这个容器即可
代码示例public class Demo11 {public static void main(String[] args) throws IOException, ClassNotFoundException {User stu1 = new User("张三", 23);User stu2 = new User("李四", 24);User stu3 = new User("王五", 25);ArrayList<User> list = new ArrayList<>();list.add(stu1);list.add(stu2);list.add(stu3);method2(list);method1(list);}public static void method2(ArrayList<User> list) throws IOException {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day12\\demo11.txt"));oos.writeObject(list);oos.close();}public static void method1(ArrayList<User> list) throws IOException, ClassNotFoundException {ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day12\\demo11.txt"));ArrayList<User> newList = (ArrayList<User>) ois.readObject();System.out.println(newList);}
}class User implements Serializable {//自定义序列号private static final long serialVersionUID = 1L;private String name;private int age;public User() {}public User(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;}@Overridepublic String toString() {final StringBuilder sb = new StringBuilder("User{");sb.append("name='").append(name).append('\'');sb.append(", age=").append(age);sb.append('}');return sb.toString();}
}五、Properties
5.1 Properties概述
Properties继承自Hashtable, Hashtable实现了Map接口, 所以Properties本质是一个map集合
Properties的使用注意?
Properties创建时不写泛型, 可以存储任意类型的数据
但是一般我们都存字符串 (键值对定义为String类型)
5.2 Properties作为map集合的使用
代码示例Properties作为map集合的基本使用练习public class Demo {public static void main(String[] args) {Properties pro = new Properties();// 增pro.put("黄蓉", "郭靖");pro.put("小龙女", "尹志平");pro.put("赵敏", "张无忌");pro.put("沈璧君", "萧十一郎");pro.put("永琪", "尔康");System.out.println(pro); // 删pro.remove("永琪");System.out.println(pro); // 改pro.put("永琪", "小燕子");System.out.println(pro);// 查// 遍历map1Set<Object> keys = pro.keySet();for (Object key : keys) {Object value = pro.get(key);System.out.println(key + "--" + value);}System.out.println("----------------");// 遍历map2Set<Map.Entry<Object, Object>> entries = pro.entrySet();for (Map.Entry<Object, Object> entry : entries) {System.out.println(entry.getKey() + "--" + entry.getValue());}}}5.3 Properties特有方法
Properties特有方法
1. Object setProperty(String key, String value); 设置集合的键和值,底层调HashTable的put
2. String getProperty(String key); 根据键返回值值
3. Set<String> stringPropertyNames(); 返回一个不可修改的键集, 键和值都是字符串
代码示例public class Demo {public static void main(String[] args) {Properties pro = new Properties();//1. Object setProperty(String key, String value); 设置集合的键和值,底层调HashTable的putpro.setProperty("张三", "北京");pro.setProperty("李四", "西安");pro.setProperty("王五", "厦门");System.out.println(pro); //{李四=西安, 张三=北京, 王五=厦门}pro.setProperty("张三", "草滩六路");System.out.println(pro); //{李四=西安, 张三=草滩六路, 王五=厦门}//2. String getProperty(String key); 根据键返回值值System.out.println(pro.get("张三")); //草滩六路System.out.println(pro.get("李四")); //西安System.out.println(pro.get("王五")); //厦门//3. Set<String> stringPropertyNames(); 返回不可修改的键集, 键和值都是字符串Set<String> keys = pro.stringPropertyNames();for (String key : keys) {Object value = pro.get(key);System.out.println(key + "--" + value);/*李四--西安张三--草滩六路王五--厦门*/}}}5.4 Properties-load
Properties和IO流结合的方法1. void load(Reader reader); 从Properties文件读取键值对到内存中2. void store(OutputStream out, String comments); 从内存写键值对数据到Properties文件
1.Properties配置一个键值对文件的格式
username=admin password=123
代码示例public class Demo14 {public static void main(String[] args) throws IOException, IOException {//创建Properties对象Properties pro = new Properties();//创建输入流对象FileReader fr = new FileReader("day12\\prop.properties");//读数据到Properties集合pro.load(fr);//释放资源fr.close();//展示结果System.out.println(pro); //{password=123, username=admin}2.Properties配置多个键值对文件的格式
username=admin,username=admin1,username=admin2 password=123,password=123,,password=1234
System.out.println(pro);
/*
password=123,password=123,,password=1234, username=admin,username=admin1,username=admin2}
*/
5.4 Properties-store
代码示例public class Demo15 {public static void main(String[] args) throws IOException, IOException {//创建Properties对象Properties pro = new Properties();//添加元素pro.put("黄蓉", "郭靖");pro.put("小龙女", "尹志平");pro.put("赵敏", "张无忌");pro.put("沈璧君", "萧十一郎");pro.put("永琪", "尔康");//创建输出流对象FileWriter fw = new FileWriter("day12\\prop1.properties");//写数据pro.store(fw, "我是注释");//释放资源fw.close();}}在properties配置文件中将会存入
#我是注释 #Sun Feb 20 00:30:47 GMT+08:00 2022 小龙女=尹志平 黄蓉=郭靖 沈璧君=萧十一郎 赵敏=张无忌 永琪=尔康
day12 字符流、字符缓冲流、转换流、对象操作流、Properties相关推荐
- 字符流、转换流、对象操作流、Properties
目录 编码表 字符流编码和解码的方式 字符流-读取中文的过程 字符流-写出数据(字符流写数据) 字符流写出数据的注意事项 字符流-flush和close方法 字符流-读取数据(字符流读数据) 字符缓冲 ...
- 第13天 缓冲、转换、对象（序列化）和打印流
缓冲.转换.对象(序列化)和打印流 第一章 缓冲流 1.1 概述 1.2 字节缓冲流 1.3 字符缓冲流 1.4 练习:文本排序 第二章 转换流 2.1 字符编码和字符集 字符编码 字符集 2.2 编 ...
- java学习--基础知识进阶第十天--标准输入流 转换流 打印流、对象操作流 、Properties集合...
今日内容介绍 u 标准输入流 & 转换流 & 打印流 u 对象操作流 u Properties集合 第1章 标准输入流 & 转换流 & 打印流 1.1 标准输入输 ...
- 13-IO流3-转换流对象操作流Properties(jdk11前指定编码读写文字、序列化和反序列化加密存储、)
文章目录 1.转换流 1.1字符流中和编码解码问题相关的两个类[理解](新学习两个类 ) 1.2转换流读写数据[应用] 2.对象操作流 2.0 引入 2.1对象序列化流[应用] 2.2对象反序列化流[ ...
- 第三次学JAVA再学不好就吃翔(part113)--对象操作流
学习笔记,仅供参考,有错必纠 对象操作流 对象操作流可以将一个对象写出, 或者读取一个对象到程序中,也就是执行了序列化和反序列化的操作. 举个例子 先构造一个Role类: package com.gu ...
- android 输出流对象,Android-IO流之对象操作流ObjectInputStream/ObjectOutputStream
目录 ObjectInputStream/ObjectOutputStream对象操作流 --12.1 ObjectInputStream 对象操作输入流/反序列化 --12.2 ObjectOutp ...
- java byte char io流_吃透Java IO：字节流、字符流、缓冲流
前言有人曾问fastjson的作者(阿里技术专家高铁):"你开发fastjson,没得到什么好处,反而挨了骂背了锅,这种事情你为什么要做呢?" 高铁答道:"因为热爱本身, ...
- 【Java基础】吃透Java IO：字节流、字符流、缓冲流
文章目录 [Java基础-3]吃透Java IO:字节流.字符流.缓冲流 一.初识java IO 1.1 IO流分类 1.1.1 输入流与输出流 1.1.2 字节流与字符流 1.1.3 节点流和处理流 ...
- java字符流字节流场景_【120期】Java IO：字节流、字符流、缓冲流
IO流是Java中的一个重要构成部分,也是我们经常打交道的.这篇关于Java IO的博文干货满满,堪称全网前三(请轻喷!) 下面几个问题(问题还会继续补充),如果你能对答如流,那么恭喜你,IO知识掌握 ...
最新文章
- oracle11G在linux环境下的卸载操作
- 经典算法——KMP模式匹配
- mysql 创建临时表 时间类型_MySQL问答系列之什么情况下会用到临时表
- dfs——练习demo3(20届周新杰提供)
- AngularJS-模型和控制器
- manacher java_最大回文子串(Manacher算法)
- 东芝宣布时域神经网络技术：要让低功率物联网设备也能深度学习
- jQuery鼠标悬停文字渐隐渐现动画效果
- SQL Server 动态行转列（参数化表名、分组列、行转列字段、字段值）
- java 父子级json组装不用递归_揭秘java中无数人伤透脑筋最为神秘的技术之一——ClassLoader...
- 几种基本汇编指令详解
- 数据挖掘实例1：亲和性分析示例（代码、注释、运行结果）
- Dev-C++ 一直提示源文件未编译，原因及解决办法
- vmsd文件+服务器,VMWARE ESX中利用SnapShot（快照）文件恢复虚拟机数据
- 运用c++编写一个计算三角形周长和面积的程序
- 幅度调制(线性调制)原理
- 51nod1463 找朋友
- 低代码平台和专业开发人员——完美搭档？
- 涨知识--地球自转会影响飞机飞行时间吗？
- Linux命令速查---kalrry