学习Java二十天

一、字符流

1.1简介

1、概念：用于来操作（读写）字符

2、分类：

A、字符输出流

B、字符输入流

3、使用字符流的原因

使用字节流来操作字符 需要将字节转换为字符 将字节转换为字符可能会产生乱码 所有操作比较麻烦

字符流=字节流+编码表

4、任何的编码表 中文的第一个字节都是负数

1.2编码表

1、编码表：字节与字符相互转换的规则

2、常见的编码表

ASCII码表

A、主要是包含西方国家的字符

B、范围 0-127

C、所有编码表都遵循ASCII码表规则 0-127 都是ASCII码表的规则

D、'a'==>97 'A'==>65 '0'==>48

GBK码表

A、GBK码表支持中文字符 大陆使用的比较少 一般是港澳地区

B、GBK码表中 一个中文占两个字节

C、记事本（gb2312）eclipse(GBK)

D、gb2312 是GBK延伸的一种码表

UTF-8码表（重点）

A、在国内大部分公司都是使用UTF-8编码

B、在UTF-8码表中一个中文占三个字节

C、idea中默认的码表就是UTF-8

UNICODE码表

A、万国码表 这个码表是全世界通用的码表

B、范围：0-65535

C、这个码表用于国际交流

1.3字符串的编解码

方法的名称	方法的描述
public byte[] getBytes(StringcharsetName)	将字符串转换为字节数组 按照指定的编码表来进行转换
public String(byte[] bytes, StringcharsetName)	将字节数组转换为字符串 按照指定的编码表来进行转换

package com.gkd.test01; import com.sun.xml.internal.ws.addressing.WsaActionUtil; import java.io.UnsupportedEncodingException; import java.util.Arrays; public class Test01 { public static void main(String[] args) throws UnsupportedEncodingException { //定义一个字符串 String s1="中"; System.out.println(Arrays.toString(s1.getBytes())); //定义一个字符串 String s2="国"; //将字符串转换为字节数组,按照UTF-8编码 byte[] bytes = s2.getBytes("UTF-8"); System.out.println(Arrays.toString(bytes)); //将字节数组转换为字符串,按照UTF-8编码 String s3=new String(bytes,"UTF-8"); System.out.println(s3); //定义一个字符串 String s4="万"; //将字符串转换为字节数组，按照GBK编码 byte[] gbks = s4.getBytes("GBK"); System.out.println(Arrays.toString(gbks)); //将字节数组转换为字符串,按照GBK编码 String s5=new String(gbks,"GBK"); System.out.println(s5); } }

二、字符输出流

2.1简介

A、字符字符的抽象类

B、子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。

但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能

2.2常用的方法

2.3子类

A、FileWrite

三、FileWrite

3.1简介

A、用来写入字符文件的便捷类

B、如果需要指定操作字符编码表 可以使用 OutputStreamWriter

C、FileWriter 用于写入字符流。要写入原始字节流，请考虑使用 FileOutputStream

3.2构造方法

方法的名称	方法的描述
public FileWriter(File file)	根据给定的 File 对象构造一个 FileWriter 对象
public FileWriter(File file,boolean append)	根据给定的 File 对象构造一个 FileWriter 对象。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处
public FileWriter(StringfileName)	根据给定的文件名构造一个 FileWriter 对象
public FileWriter(StringfileName, booleanappend)	根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

3.3FileWrite-写数据

package com.gkd.test01; import java.io.FileWriter; import java.io.IOException; public class Test02 { public static void main(String[] args) throws IOException { //实例化对象 FileWriter fw=new FileWriter("1.txt"); //写数据 fw.write(97); fw.write("拉稀哥在七夕节瞒着阿蒙看妹子"); fw.write(new char[]{'a','b','c'}); //关闭资源 fw.close(); } }

四、Reader

4.1简介

1、用于读取字符流的抽象类

2、子类必须实现的方法只有 read(char[], int, int) 和 close()。

但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能

4.2常用方法

方法的名称	方法的描述
public abstract void close()	关闭资源
public int read()	读取单个字符
public int read(char[] cbuf)	将字符读入数组
public abstract int read(char[] cbuf, int off, int len)	将字符读入数组的某一部分

4.3子类FileReader

A、FileReader

五、FileReader

5.1简介

1、用于读取字符文件的便捷类

2、如果需要设置编码格式使用InputStreamReader

3、FileReader 用于读取字符流。要读取原始字节流，请考虑使用 FileInputStream

5.2构造方法

方法的名称	方法的描述
public FileReader(StringfileName)	在给定从中读取的数据的文件名的情况下创建一个新的
public FileReader(StringfileName)	在给定从中读取数据的 File 的情况下创建一个新FileReader

5.3读数据

package com.gkd.test01; import java.io.FileReader; import java.io.IOException; public class Test03 { public static void main(String[] args) throws IOException { //实例化对象 FileReader fr=new FileReader("1.txt"); //定义变量 int leng=-1; //定义一个字符数组 char [] ch=new char[1024]; while ((leng=fr.read(ch))!=-1){ System.out.println(new String(ch,0,leng)); } //关闭资源 } }

5.4案例-读写字符

step01需求：使用字符流 将2.txt中的内容复制到3.txt

step02分析：

A、FileRreader 读

B、FileWriter写

step03代码

package com.gkd.test01; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class Test04 { public static void main(String[] args) throws IOException { //实例化对象 FileReader fr=new FileReader("1.txt"); //实例化对象 FileWriter fw=new FileWriter("2.txt"); //定义一个变量 int leng=-1; while ((leng=fr.read())!=-1){ fw.write(leng); } fw.close(); fr.close(); } }

5.5使用字符流读写的过程

六、InputStreamReader

6.1简介

A、InputStreamReader 是字节流通向字符流的桥梁

B、设置编码格式

C、为了达到最高效率，可要考虑在 BufferedReader

6.2构造方法

方法名称	方法描述
public InputStreamReader(InputStream in)	创建一个使用默认字符集的InputStreamReader
public InputStreamReader(InputStream in, StringcharsetName)	创建使用指定字符集的InputStreamReader

6.3使用

package com.gkd.test02; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; public class Test01 { public static void main(String[] args) throws IOException { //实例化对象 InputStream is=new FileInputStream("2.txt"); //实例化转换流 InputStreamReader isr=new InputStreamReader(is); //使用循环读取内容 int leng=-1; while ((leng=isr.read())!=-1){ System.out.println((char) leng); } isr.close(); is.close(); } }

七、OutputStreamWriter

7.1简介

A、OutputStreamWriter 是字符流通向字节流的桥梁

B、可以使用指定的 charset 需要写入流中的字符编码生成字节 可以设置编码格式

C、.为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter中

7.2构造方法

方法名称	方法描述
public OutputStreamWriter(OutputStream out)	创建使用默认字符编码的OutputStreamWriter
public OutputStreamWriter(OutputStream out, StringcharsetName)	创建使用默认字符编码的OutputStreamWriter

7.3使用

package com.gkd.test02; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter; public class Test02 { public static void main(String[] args) throws IOException { OutputStream os=new FileOutputStream("3.txt"); //实例化转换流 OutputStreamWriter osw=new OutputStreamWriter(os); // osw.write("哈哈哈！"); osw.write(new char[]{'a','b','c','d'}); //关闭资源 osw.close(); os.close(); } }

八、BufferedReader

8.1简介

A、从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取 字符高效流

B、可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

C、使用 BufferedReader 一般是一行一行进行读取 readLine()

8.2构造方法

方法的名称	方法的描述
public BufferedReader(Reader in)	创建一个使用默认大小输入缓冲区的缓冲字符输入流

8.3独有的方法

方法的名称	方法的描述
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入	一行一行读取

8.4使用

package com.gkd.test02; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.io.Reader; public class Test03 { public static void main(String[] args) throws IOException { Reader r=new FileReader("3.txt"); //实例化对象 BufferedReader br=new BufferedReader(r); // String sr=null; while ((sr=br.readLine())!=null){ System.out.println(sr); } br.close(); r.close(); } }

九、BufferedWriter

9.1简介

A、将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入

B、可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了

9.2构造方法

方法的名称	方法的描述
public BufferedWriter(Writer out)	创建一个使用默认大小输出缓冲区的缓冲字符输出流

9.3独有的方法

方法的名称	方法的描述
public void newLine()	换行

9.4使用

package com.gkd.test02; import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; import java.io.Writer; public class Test04 { public static void main(String[] args) throws IOException { Writer w=new FileWriter("4.txt"); //实例化对象BufferedWriter BufferedWriter bw=new BufferedWriter(w); bw.write("拉稀哥 波多老师"); bw.newLine(); bw.write("老王 小野老师"); bw.newLine(); bw.write("老六 苍老师"); bw.newLine(); bw.write("威威 小泽老师"); bw.newLine(); bw.write("洵洵 加藤老师"); bw.newLine(); bw.write("阿廖 龙泽老师"); bw.close(); w.close(); } }

十、案例

step01需求-分析：

step02代码：

package com.gkd.test02; import java.io.*; import java.util.ArrayList; import java.util.List; public class Test05 { public static void main(String[] args) throws IOException { //实例化读 InputStream is=new FileInputStream("4.txt"); //实例化对象 InputStreamReader isr=new InputStreamReader(is,"UTF-8"); //实例化对象 BufferedReader br=new BufferedReader(isr); //实例化写 //实例化对象 OutputStream os=new FileOutputStream("5.txt"); //实例化对象 OutputStreamWriter osw=new OutputStreamWriter(os,"UTF-8"); //实例化对象 BufferedWriter bw=new BufferedWriter(osw); //实例化集合接收 List<String> list=new ArrayList<String>(); String line=null; //使用循环读取文件存入集合 while ((line=br.readLine())!=null){ list.add(line); } //使用循环遍历集合写入文件 for (int i=list.size()-1;i>=0;i--){ bw.write(list.get(i)); //换行 bw.newLine(); } bw.close(); br.close(); osw.close(); os.close(); isr.close(); is.close(); } }

简化后的代码：

package com.gkd.test02; import java.io.*; import java.util.ArrayList; import java.util.List; public class Test05 { public static void main(String[] args) throws IOException { BufferedReader br= null; BufferedWriter bw= null; try { br = new BufferedReader(new InputStreamReader(new FileInputStream("4.txt"),"UTF-8")); bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("6.txt"),"UTF-8")); //实例化集合接收 List<String> list=new ArrayList<String>(); String line=null; //使用循环读取文件存入集合 while ((line=br.readLine())!=null){ list.add(line); } //使用循环遍历集合写入文件 for (int i=list.size()-1;i>=0;i--){ bw.write(list.get(i)); //换行 bw.newLine(); } } catch (IOException e) { e.printStackTrace(); } finally { if (bw!=null){ bw.close(); } if (br!=null){ br.close(); } } } }

10.6 close()与flush()

1、close()关闭资源

2、flush()刷新 ==>将缓冲区中数据刷新到磁盘中

3、比较

A、调用close()方法之后 流资源对象不能使用

B、调用flush()方法之后 流资源对象还是可以使用

C、调用close()方法的底层会调用flush()方法

十一、对象流

11.1序列化简介

1、使用场景：使用流来操作对象的时候 或者是网路通信中传输对象的时候 就需要使用序列化

2、序列化的机制：使用一个唯一的一个序列化的字节（人的身份证号） 来表示文件对象（属性 方法……）

3、序列化：使用流将对象写入到文件中的过程 就是序列化 将对象进行流化 可以加快对象写的速度

4、反序列化：使用流将文件中的对象读取的过程 就是反序列化 加快对象读速度

11.2对象流-写-ObjectOutputStream

11.2.1简介

A、通过在流中使用文件可以实现对象的持久存储

B、通过在流中使用文件可以实现对象的持久存储

C、能将支持 java.io.Serializable 接口的对象写入流中

D、writeObject 方法用于将对象写入流中。所有对象（包括 String 和数组）都可以通过writeObject 写

11.2.2构造方法

方法的名称	方法的描述
publicObjectOutputStream(OutputStream out)	创建写入指定 OutputStream 的ObjectOutputStream

11.2.3常用的方法

方法的名称	方法的描述
public final void writeObject(Object obj)	将指定的对象写入文件中

11.2.4使用

package com.gkd.test03; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; import java.io.OutputStream; public class Test02 { public static void main(String[] args) throws IOException { OutputStream os=new FileOutputStream("8.txt"); //实例化对象 ObjectOutputStream oos=new ObjectOutputStream(os); //调用方法写入 oos.writeObject("阿廖"); oos.writeObject(new char[]{'a','b','c'}); oos.writeObject(98); oos.writeObject(3.1415926); //关闭资源 oos.close(); os.close(); } }

11.3对象流-读-ObjectInputStream

11.3.1简介

A、ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化B.

B、只有支持 java.io.Serializable 接口的对象才能从流读取。

11.3.2构造方法

方法的名称	方法的描述
public ObjectInputStream(InputStreamin)	创建从指定 InputStream 读取的ObjectInputStream

11.3.3常用方法

方法名称	方法描述
public final Object readObject()	从文件读取对象

11.3.4使用

package com.gkd.test03; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInputStream; import java.util.Arrays; public class Test03 { public static void main(String[] args) throws IOException, ClassNotFoundException { InputStream is=new FileInputStream("8.txt"); //实例化对象 ObjectInputStream ois=new ObjectInputStream(is); Object o1 = ois.readObject(); System.out.println(o1); char[] o2 = (char[]) ois.readObject(); System.out.println(Arrays.toString(o2)); Object o3 = ois.readObject(); System.out.println(03); Object o4 = ois.readObject(); System.out.println(04); ois.close(); is.close(); } }

11.4使用对象流读取对象

step01-代码-学生类

package com.gkd.test03; import java.io.Serializable; public class Student implements Serializable { private String name; private int age; public Student() { } public Student(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 "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } }

step02-代码-测试类

package com.gkd.test03; import java.io.*; public class Test01 { public static void main(String[] args) throws IOException, ClassNotFoundException { // writerObject(); readObject(); } //写方法 public static void writerObject() throws IOException { //实例化 ObjectOutputStream obs=new ObjectOutputStream(new FileOutputStream("7.txt")); Student stu=new Student("老王",18); obs.writeObject(stu); obs.close(); } //读方法 public static void readObject() throws IOException, ClassNotFoundException { //实例化 ObjectInputStream ois=new ObjectInputStream(new FileInputStream("7.txt")); Student ob = (Student) ois.readObject(); System.out.println(ob); ois.close(); } }

注意：没有实现序列化对象的错误：

11.5使用对象流-读写多个对象

第一种方式：

package com.gkd.test03; import java.io.*; public class Test04 { public static void main(String[] args) throws IOException, ClassNotFoundException { writerObject(); readObject(); } //写方法 public static void writerObject() throws IOException { //实例化 ObjectOutputStream obs=new ObjectOutputStream(new FileOutputStream("9.txt")); Student stu01=new Student("老王",18); Student stu02=new Student("拉稀哥",19); Student stu03=new Student("阿廖",20); Student stu04=new Student("威威",16); Student stu05=new Student("洵洵",24); obs.writeObject(stu01); obs.writeObject(stu02); obs.writeObject(stu03); obs.writeObject(stu04); obs.writeObject(stu05); obs.writeObject(null); obs.close(); } //读方法 public static void readObject() throws IOException, ClassNotFoundException { //实例化 ObjectInputStream ois=new ObjectInputStream(new FileInputStream("9.txt")); Object obj=null; while ((obj=ois.readObject())!=null){ Student stu= (Student) obj; System.out.println(stu); } ois.close(); } }

第二种方式：

package com.gkd.test03; import java.io.*; import java.util.ArrayList; import java.util.List; public class Test05 { public static void main(String[] args) throws IOException, ClassNotFoundException { writerObject(); readObject(); } //写方法 public static void writerObject() throws IOException { //实例化 ObjectOutputStream obs=new ObjectOutputStream(new FileOutputStream("11.txt")); Student stu01=new Student("老王",22); Student stu02=new Student("拉稀哥",19); Student stu03=new Student("阿廖",20); Student stu04=new Student("威威",16); Student stu05=new Student("洵洵",24); //实例化集合 List<Student> list =new ArrayList<>(); list.add(stu01); list.add(stu02); list.add(stu03); list.add(stu04); list.add(stu05); obs.writeObject(list); obs.close(); } //读方法 public static void readObject() throws IOException, ClassNotFoundException { //实例化 ObjectInputStream ois=new ObjectInputStream(new FileInputStream("11.txt")); List<Student> list= (List<Student>) ois.readObject(); System.out.println(list); ois.close(); } }

十二、总结