Java高级编程–泛型、输入输出流–day06

最新推荐文章于 2023-05-21 02:43:09 发布

小疯子青

最新推荐文章于 2023-05-21 02:43:09 发布

阅读量1k

点赞数 2

本文链接：https://blog.csdn.net/a1773570500/article/details/106473289

版权

知识点和问题整理

1.泛型的作用是什么？

1.解决元素存储的安全性问题，好比商品、药品标签，保证不会弄错。
2.解决获取数据元素时，需要类型强制转换的问题。

 public void test(){
    ArrayList<Integer> list=new ArrayList<>();
    list.add(78);
    list.add(87);
    list.add(99);
    list.add(65);
    for(Integer score:list){
        int stuSocre=score;
        System.out.println(stuSocre);
    }
    Iterator<Integer> iterator=list.iterator();
    while(iterator.hasNext()){
        int stuScore=iterator.next();
        System.out.println(stuScore);
    }
}
public void test2(){
    Map<String,Integer> map=new HashMap<String,Integer>();
    map.put("Tom",87);
    map.put("Jerry",87);
    map.put("Jack",67);
   Set<Map.Entry<String,Integer>> entry=map.entrySet();
   Iterator<Map.Entry<String,Integer>> iterator=entry.iterator();
   while(iterator.hasNext()){
       Map.Entry<String,Integer> e=iterator.next();
       String key=e.getKey();
       Integer value=e.getValue();
       System.out.println(key+"----"+value);
   }
}

2.泛型的使用

在集合中使用泛型
1.泛型的类型必须是类，不能是基本数据类型。
2.如果实例化集合时，没有指明泛型的类型，默认类型是java.lang.Object类型

3.如何自定义泛型结构:泛型类、泛型接口、泛型方法

样例1:

public class Order<T> {
    String orderName;
    int orderId;
    T orderT;
    public Order(){};
    public Order(String orderName,int orderId,T orderT){
        this.orderName=orderName;
        this.orderId=orderId;
        this.orderT=orderT;
    }
    public T getOrderT(){
        return orderT;
    }
    public void setOrderT(T orderT){
        this.orderT=orderT;
    }
    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}
    @Test
    public void test3(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果大家定义了类是带泛型的，建议在实例化时指明类的泛型
        Order order=new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");
        Order<String> order1=new Order<String>("orderAA",1001,"order:AA");
        order1.setOrderT("AA:hello");
    }

样例2：继承泛型类

public class SubOrder extends Order<Integer> {//不再是泛型类
}
    @Test
    public void test4(){
        SubOrder sub1=new SubOrder();
        sub1.setOrderT(1122);
    }

样例3:

public class SubOrder1<T> extends Order<T> {//仍然是泛型类
}
    @Test
    public void test4(){
        SubOrder sub1=new SubOrder();
        sub1.setOrderT(1122);
        SubOrder1<String> sub2=new SubOrder1<>();
        sub2.setOrderT("order2...");
    }

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系

  public <E> List<E> copyFromArrayToList(E[] arr){//public static <E> List<E> copyFromArrayToList(E[] arr){
       ArrayList<E> list=new ArrayList<>();
       for(E e:arr){
           list.add(e);
       }
       return list;
   }
   public void test5(){
       Order<String> order=new Order<>();
       Integer[] arr=new Integer[]{1,2,3,4};
       List<Integer> list=order.copyFromArrayToList(arr);
       System.out.println(list);
   }

4.泛型类泛型方法使用注意事项

泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如:<E1,E2,E3>
泛型类的构造器如下：public GenericClass(){}。
而下面是错误的：public GenericClass<E>(){}
实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
泛型不同的引用不能相互赋值。
尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。
经验：泛型要使用一路都用。要不用，一路都不要用。
如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
jdk1.7，泛型的简化操作：ArrayList<Fruit> flist = new ArrayList<>();
泛型的指定中不能使用基本数据类型，可以使用包装类替换。
在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
异常类不能是泛型的
11.不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
12.父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
 子类不保留父类的泛型：按需实现没有类型擦除具体类型
 子类保留父类的泛型：泛型子类
全部保留
 部分保留
结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型
样例代码1：

class Father<T1, T2> {
}

// 子类不保留父类的泛型
// 1)没有类型擦除

class Son1 extends Father {
// 等价于class Son extends Father<Object,Object>{
}

// 2)具体类型

class Son2 extends Father<Integer, String> {
}

// 子类保留父类的泛型
// 1)全部保留

class Son3<T1, T2> extends Father<T1, T2> {
}

// 2)部分保留

class Son4<T2> extends Father<Integer, T2> {
}

样例代码2：

class Father<T1, T2> {
}

// 子类不保留父类的泛型
// 1)没有类型擦除

class Son<A, B> extends Father{
//等价于class Son extends Father<Object,Object>{
}

// 2)具体类型

class Son2<A, B> extends Father<Integer, String> {
}

// 子类保留父类的泛型
// 1)全部保留

class Son3<T1, T2, A, B> extends Father<T1, T2> {
}

// 2)部分保留

class Son4<T2, A, B> extends Father<Integer, T2> {
}

5.泛型在继承方面的体现

类A是类B的父类，G<A>和G<B>二者不具备子父类关系，二者是并列关系
补充：类A是类B的父类，A<G>是B<G>的父类

6.通配符的使用

通配符:?
类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是G<?>
对于List<?>就不能向其内部添加数据，除了添加null之外，允许读取数据。

public void test6(){
    List<Object> list1=null;
    List<String> list2=null;
    List<?> list=null;
    list =list1;
    list=list2;
}
public void print(List<?> list){
    Iterator<?> iterator=list.iterator();
    while(iterator.hasNext()){
        Object obj=iterator.next();
        System.out.println(obj);
    }
}
public void test6(){
    List<Object> list1=null;
    List<String> list2=null;
    List<?> list=null;
    list1.add("test");
    list =list1;
    list=list2;
    System.out.println(list.get(0));
}

7.有限制的通配符

<? extends Number> (无穷小 , Number]
只允许泛型为Number及Number子类的引用调用
<? super Number> [Number , 无穷大)
只允许泛型为Number及Number父类的引用调用

<? extends Comparable>

只允许泛型为实现Comparable接口的实现类的引用调用

public void test7(){
    List<? extends Person> list1=null;
    List<? super Person> list2=null;
    List<Student> list3=null;
    List<Person> list4=null;
    List<Object> list5=null;
    list1=list3;
    list1=list4;
    list2=list4;
    list2=list5;
    list1=list3;
    Person p=list1.get(0);
    list2=list4;
    Object obj=list2.get(0);
    list2.add(new Person());
    list2.add(new  Student());
}

8.样例代码，返回map中存放的所有T对象

  public List<T> list(){
       ArrayList<T> list=new ArrayList<T>();
       Collection<T> values=map.values();
       for(T t:values){
           list.add(t);
       }
       return list;
   }

9.File 类的使用

1.java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关
2.File 能新建、删除、重命名文件和目录，但File不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
3.想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
4.File对象可以作为参数传递给流的构造器

10.File 类的使用：常用构造器

1.public File(String pathname)
2.public File(String parent,String child)
3.public File(File parent,String child)
程序：

public void test1(){
    //构造器1
    File file1=new File("hello.txt");
    File file2=new File("D:\\test");
    System.out.println(file1);
    System.out.println(file2);
    //构造器2
    File file3=new File("D:\\test","test");
    System.out.println(file3);
    //构造器3
    File file4=new File(file3,"hi.txt");
    System.out.println(file4);
}

运行结果：
hello.txt
D:\test
D:\test\test
D:\test\test\hi.txt

11.File 类的使用：路径分隔符

1.路径中的每级目录之间用一个路径分隔符隔开。
2.路径分隔符和系统有关：
1)windows和DOS系统默认使用“\”来表示
2)UNIX和URL使用“/”来表示
3.Java程序支持跨平台运行，因此路径分隔符要慎用。
为了解决这个隐患，File类提供了一个常量：

public static final String separator。根据操作系统，动态的提供分隔符。
样例代码：
File file1 = new File("d:\\atguigu\\info.txt");
File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt");
File file3 = new File("d:/atguigu");

12.File类的基本方法

1.File类的获取功能
public String getAbsolutePath()：获取绝对路径
 public String getPath() ：获取路径
 public String getName() ：获取名称
 public String getParent()：获取上层文件目录路径。若无，返回null
 public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
 public long lastModified() ：获取最后一次的修改时间，毫秒值
public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
 public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组
样例代码如下：

public void  test2(){
    File file1=new File("hello.txt");
    File file2=new File("d:\\io\\hi.txt");
    System.out.println(file1.getAbsolutePath());
    System.out.println(file1.getPath());
    System.out.println(file1.getName());
    System.out.println(file1.getParent());
    System.out.println(file1.length());
    System.out.println(file1.lastModified());
    System.out.println();
    System.out.println(file2.getAbsolutePath());
    System.out.println(file2.getPath());
    System.out.println(file2.getName());
    System.out.println(file2.getParent());
    System.out.println(file2.length());
    System.out.println(file2.lastModified());
}

运行结果如下hello文件存在：
D:\workspace\JavaSenior\day01\hello.txt
hello.txt
hello.txt
null
10
1590389901278

d:\io\hi.txt
d:\io\hi.txt
hi.txt
d:\io
0
0
样例代码：

    public void test3(){
        File file=new File("D:\\个人文档");//要求文件必须存在
        String[] list=file.list();
        for(String s:list){
            System.out.println(s);//例子:01Hamster Wheel and Insect Hotel.mp4
        }
    }
  File[] files=file.listFiles();
        for(File f:files){
            System.out.println(f);//D:\个人文档\网易云虚拟主机优惠地址.txt
        }

public boolean renameTo(File dest):把文件重命名为指定的文件路径
样例代码：

public void test4(){
    File file1=new File("hello.txt");
    File file2=new File("D:\\个人文档\\hi.txt");//将hello.txt转移到D:\个人文档\hi.txt,D:\个人文档\hi.txt在转移之前不能存在，否则失败
    boolean renameTo=file1.renameTo(file2);
    System.out.println(renameTo);
}

2.File类的判断功能
 public boolean isDirectory()：判断是否是文件目录
 public boolean isFile() ：判断是否是文件
 public boolean exists() ：判断是否存在
 public boolean canRead() ：判断是否可读
 public boolean canWrite() ：判断是否可写
 public boolean isHidden() ：判断是否隐藏
样例代码：

public void test5(){
    File file1=new File("hello.txt");//测试时文件存在，如果文件不存在，则返回均为fale
    System.out.println(file1.isDirectory());
    System.out.println(file1.isFile());
    System.out.println(file1.exists());
    System.out.println(file1.canRead());
    System.out.println(file1.canWrite());
    System.out.println(file1.isHidden());
}

运行结果：
false
true
true
true
true
false
3.File类的创建功能
public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建
样例代码：

public void test6() throws IOException {
    File file1=new File("hi.txt");
    if(!file1.exists()){
        file1.createNewFile();
        System.out.println("创建成功");
    }else{
        file1.delete();
        System.out.println("删除成功");
    }
}
public void test7(){
    File file1=new File("d:\\io\\io1\\io3");//如果io或io1不存在，则创建失败
    System.out.println(file1.mkdir());
    File file2=new File("d:\\io\\io1\\io4");
    System.out.println(file2.mkdirs());
}

13.JavaIO原理

1.I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
2.Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。
3.java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
4.输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
5.输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

14.流的分类

1.按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)
2.按数据流的流向不同分为：输入流，输出流
3.按流的角色的不同分为：节点流，处理流
在这里插入图片描述
补充知识点：
流的使用场景：
1.SpringMVC和ajax页面之间的信息交互

public interface HttpInputMessage extends HttpMessage {
	InputStream getBody() throws IOException;
}

public interface HttpOutputMessage extends HttpMessage {
	OutputStream getBody() throws IOException;
}

2.在springMVC框架中，文件上传处用到该知识点
知识点链接

15.IO体系

在这里插入图片描述

16.将day09下的hello.txt文件内容读入程序中，并输出到控制台

@Test
public void testFileReader()  {
    File file=null;
    FileReader fr=null;
    try{file=new File("hello.txt");
        fr=new FileReader(file);//读入的文件一定要存在，否则会报FileNotFoundException
        int data=fr.read();
        while(data!=-1){
            System.out.print((char)data);
            data=fr.read();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(fr!=null){
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

改进后的读取输出示例

@Test
public void test2() throws IOException {
    File file=new File("hello.txt");
    FileReader fr=new FileReader(file);
    char[] cbuf=new char[5];
    int len;
    while((len=fr.read(cbuf))!=-1){
        for(int i=0;i<len;i++){
            System.out.print(cbuf[i]);
        }
    }
    while((len=fr.read(cbuf))!=-1){
            System.out.print(new String(cbuf,0,len));
    }
}

17.从内存中写出数据到硬盘的文件里

@Test
public void test3() throws IOException {
    File file=new File("hello1.txt");
    FileWriter fw=new FileWriter(file,false);
    fw.write("I have a dream!");
    fw.write("you need to have a dream!");
    fw.close();
}

说明：如果file不存在，则会自动创建
如果file已经存在，根据构造器中的传值判断是追加还是覆盖，false覆盖，true追加。

18.把字符从文件中把文件写到另一个文件中

public void test4() throws IOException {
    File srcFile=new File("hello.txt");
    File destFile=new File("hello2.txt");
    FileReader fr=new FileReader(srcFile);
    FileWriter fw=new FileWriter(destFile);
    char[] buf=new char[5];
    int len=0;
    while((len=fr.read(buf))!=-1){
        fw.write(new String(buf,0,len));
    }
}

19.以字节的形式把文件从一个文件读到另一个文件。

public void test5() throws IOException {
    File file=new File("hello.txt");
    FileInputStream fis=new FileInputStream(file);
    byte[] buffer=new byte[5];
    int len=0;
    while((len=fis.read(buffer))!=-1){
        System.out.println(new String(buffer,0,len));
    }
    fis.close();
}

20.字节流和字符流使用注意事项？

对于文本(.txt,.java,.c,.cpp)文件使用字符流处理
对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)，使用字节流处理

21.字节流实现复制

public void test6() throws IOException {
    File srcFile=new File("D:\\个人文档\\学习文档\\java\\day26_IO流\\01-尚硅谷-Java语言高级-每天一考.avi");
    File descFile=new File("D:\\个人文档\\test.avi");
    FileInputStream fin=new FileInputStream(srcFile);
    FileOutputStream fou=new FileOutputStream(descFile);
    byte[] buffer=new byte[5];
    int len=0;
    while((len=fin.read(buffer))!=-1){
        fou.write(buffer,0,len);
    }
    fin.close();
    fou.close();
}

22.用缓冲流复制字节文件

@Test
public void test7() throws IOException {
    File srcFile=new File("D:\\个人文档\\学习文档\\java\\day26_IO流\\01-尚硅谷-Java语言高级-每天一考.avi");
    File descFile=new File("D:\\个人文档\\test.avi");
    FileInputStream fin=new FileInputStream(srcFile);
    FileOutputStream fou=new FileOutputStream(descFile);
    BufferedInputStream bis=new BufferedInputStream(fin);
    BufferedOutputStream bos=new BufferedOutputStream(fou);
    byte[] buffer=new byte[1024];
    int len;
    while((len=bis.read(buffer))!=-1){
        bos.write(buffer,0,len);
    }
    fin.close();
    bos.close();
}

23.处理流程之一：缓冲流的使用

BuffererInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
2.作用:提高流的读取、写入的速度,因为内部提供了一个缓冲区

@Test
public void test8() throws IOException {
    BufferedReader bufr= null;
    BufferedWriter fbwr= null;
    try {
        bufr = new BufferedReader(new FileReader(new File("hello.txt")));
        fbwr = new BufferedWriter(new FileWriter(new File("D:\\个人文档\\hello3.txt")));
        char[] buffer=new char[1024];
        int len=0;
        while((len=bufr.read(buffer))!=-1){
            fbwr.write(buffer,0,len);
            //fbwr.flush();
        }
        String data;
        while((data=bufr.readLine())!=null){
            fbwr.write(data+"/n");
            //fbwr.write(data);
            //fbwr.newLine();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        bufr.close();
        fbwr.close();
    }
}

24.什么是转换流

1.转换流：属于字符流，提供字节流与字符流之间的转换
InputStreamReader:将一个字节的输入流转换成字符的输入流
OutputStreamWriter:将一个字符的输出流转换为字节的输出流
解码：字节、字节数组—>字符数组、字符串
编码：字符数组、字符串—>字节、字节数组
样例代码：

    @Test
    public void test9() throws IOException {
        FileInputStream fis=new FileInputStream("hello.txt");
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        char[] cbuf=new char[20];
        int len;
        while((len=isr.read(cbuf))!=-1){
            String str=new String(cbuf,0,len);
            System.out.println(str);
        }
        isr.close();
        fis.close();
    }
 @Test
    public void test10() throws IOException {
        File file1=new File("hello.txt");
        File file2=new File("hello_gbk.txt");
        FileInputStream fis=new FileInputStream(file1);
        FileOutputStream fos=new FileOutputStream(file2);
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
        char[] buffer=new char[20];
        int len;
        while((len=isr.read(buffer))!=-1){
            osw.write(buffer,0,len);
        }
        isr.close();
        osw.close();
    }

25.常见的编码表

1.ASCII：美国标准信息交换码。
 用一个字节的7位可以表示。
2.ISO8859-1：拉丁码表。欧洲码表用一个字节的8位表示。
3.GB2312：中国的中文编码表。最多两个字节编码所有字符
4.GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
5.Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
6.UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
在这里插入图片描述

26.标准输入输出流

1.System.in和System.out分别代表了系统标准的输入和输出设备
2.默认输入设备是：键盘，输出设备是：显示器
3.System.in的类型是InputStream
4.System.out的类型是PrintStream，其是OutputStream的子类FilterOutputStream 的子类
5.重定向：通过System类的setIn，setOut方法对默认设备进行改变。

 public static void setIn(InputStream in)
 public static void setOut(PrintStream out)

27.例题：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

两种方法，一个使用Scanner来实现，另一个使用System.in实现

public class OtherStream {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br=new BufferedReader(isr);
        while(true){
            System.out.println("请输入：");
            String data=br.readLine();
            if("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
                break;
            }
            System.out.println(data.toUpperCase());
        }
    }
}

28.打印流

样例代码：

@Test
public void test1(){
    PrintStream ps = null;
    try {
        FileOutputStream fos = new FileOutputStream(new File("D:\\IO1\\text.txt"));
        // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
        ps = new PrintStream(fos, true);
        if (ps != null) {// 把标准输出流(控制台输出)改成文件
            System.setOut(ps);
        }
        for (int i = 0; i <= 255; i++) { // 输出ASCII字符
            System.out.print((char) i);
            if (i % 50 == 0) { // 每50个数据一行
                System.out.println(); // 换行
            }
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        if (ps != null) {
            ps.close();
        }
    }
}

29.数据流

1.为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。
2.数据流有两个类：(用于读取和写出基本数据类型、String类的数据）
DataInputStream 和 DataOutputStream
3.DataInputStream中的方法
boolean readBoolean()
byte readByte()
char readChar()
float readFloat()
double readDouble()
short readShort()
long readLong()
int readInt()
String readUTF()
void readFully(byte[] b)
4.DataOutputStream中的方法将上述的方法的read改为相应的write即可。

@Test
public void test2() throws IOException {
    DataOutputStream dos=new DataOutputStream(new FileOutputStream("data.txt"));
    dos.writeUTF("数据");
    dos.writeByte(1);
    dos.writeFloat((float) 1.0);
    dos.flush();
    dos.close();
}
@Test
public void test3() throws IOException {
    DataInputStream ins=new DataInputStream(new FileInputStream("data.txt"));
    System.out.println(ins.readUTF());
    System.out.println(ins.readBoolean());
    ins.close();
}

30.对象流

ObjectInputStream和OjbectOutputSteam
1.用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
2.序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
3.反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
4.ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量，会存储为null
测试样例代码：

@Test
public void testObjectOutputStream() throws IOException {
    ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("test.vvv"));
    oos.writeObject(new StringBuilder("测试"));
    oos.close();
}
@Test
public void testObjectOutputInput() throws IOException, ClassNotFoundException {
    ObjectInputStream ois=new ObjectInputStream(new FileInputStream("test.vvv"));
    Object obj=ois.readObject();
    System.out.println((StringBuilder)obj);
}

31.对象序列化机制指的是什么？

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

32.如果想让某个对象可序列化，必须做哪些处理？

如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常
1.实现接口：Serializable
1)当前类提供一个全局变量：serialVersionUID
2)除了当前Person类需要实现Serializable接口之外，还需要保证其内部所有属性，也必须是可序列化的。(默认情况下，基本数据类型可序列化)
测试样例部分代码：

public class Person implements Serializable {
    private static final long serialVersionUID = 1923452389574982374L;
    private String name;
    private int age;
    public Person() {}
}
    @Test
    public void testObjectOutputStream() throws IOException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("test.vvv"));
        oos.writeObject(new StringBuilder("测试"));
        oos.writeObject(new Person("test",12));
        oos.close();
    }
    @Test
    public void testObjectOutputInput() throws IOException, ClassNotFoundException {
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("test.vvv"));
        Object obj=ois.readObject();
        System.out.println((StringBuilder)obj);
        System.out.println((Person)ois.readObject());
    }

2.实现接口Externalizable

33.随机存取文件流

RandomAccessFile的使用
1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
如果写出到的文件存在，则会对原有文件内容进行覆盖(默认情况下，从头覆盖)。
4.RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。RandomAccessFile 类对象可以自由移动记录指针：
long getFilePointer()：获取文件记录指针的当前位置
void seek(long pos)：将文件记录指针定位到 pos 位置
5.构造器
public RandomAccessFile(File file, String mode)
public RandomAccessFile(String name, String mode)
6.创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：
r: 以只读方式打开
rw：打开以便读取和写入
rwd:打开以便读取和写入；同步文件内容的更新
rws:打开以便读取和写入；同步文件内容和元数据的更新
7.如果模式为只读r。则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建。
样例代码

  @Test
   public void test1() throws IOException {
       RandomAccessFile raf1=new RandomAccessFile(new File("C:\\Users\\华为\\Desktop\\3.PNG"),"r");
       RandomAccessFile raf2=new RandomAccessFile(new File("1.PNG"),"rw");
       byte[] buffer=new byte[1024];
       int len;
       while((len=raf1.read(buffer))!=-1){
           raf2.write(buffer,0,len);
       }
       raf1.close();
       raf2.close();
   }

34.使用RandomAccessFile实现数据的插入效果

@Test
public void test2() throws IOException {
    RandomAccessFile raf1=new RandomAccessFile("hello.txt","rw");
    raf1.seek(3);
    StringBuilder builder=new StringBuilder((int)new File("hello.txt").length());
    byte[] buffer=new byte[20];
    int len;
    while((len=raf1.read(buffer))!=-1){
        builder.append(new String(buffer,0,len));
    }
    raf1.seek(3);
    raf1.write("xyz".getBytes());
    raf1.write(builder.toString().getBytes());
    raf1.close();
}

35.NIO.2中Path、Paths(工具类)、Files(工具类)类的使用

NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网
络编程NIO。
|-----java.nio.channels.Channel
 |-----FileChannel:处理本地文件
 |-----SocketChannel：TCP网络编程的客户端的Channel
 |-----ServerSocketChannel:TCP网络编程的服务器端的Channel
 |-----DatagramChannel：UDP网络编程中发送端和接收端的Channel

36.使用第三方jar包实现文件传输

@Test
public void test3() throws IOException {
    File srcFile=new File("C:\\Users\\华为\\Desktop\\3.PNG");
    File destFile=new File("text.PNG");
    FileUtils.copyFile(srcFile,destFile);
}