Java进阶（六）_泛型与IO流

一、泛型

1.为什么要有泛型？

  • 泛型：标签

  • 泛型的设计背景

    集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK5.0之前只能把元素类型设计为Object，JDK5.0之后使用泛型来解决。将元素的类型设计成一个参数，这个类型参数叫做泛型。Collection,List,ArrayList,这个就是类型参数，即泛型。

  • 泛型的概念

    • 泛型就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
    • 从JDK1.5之后，java引入了“参数化类型”的概念，允许我们在创建集合时再指定集合元素的类型，比如List，表明该List只能保存字符串类型的对象。
    • JDK1.5后改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

2.在集合中使用泛型

  • 集合接口或集合类在jdk5.0时都修改为带泛型的结构；
  • 在实例化集合类时，可以指明具体的泛型类型
  • 指明完之后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化时的泛型的类型。比如add(E e)---实例化后：add(Integer e)
  • 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换。
  • 如果实例化时，没有指明泛型的类型。默认类型为java.Lang.Object类型。

3.自定义泛型结构：泛型类、泛型接口、泛型方法

3.1泛型类和泛型接口

  • 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型；

  • 要求：如果已经定义了类是带泛型的，建议在实例化时要指明类的泛型。

  • 如果子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。

  • 注意点：

    1. 泛型类可能有多个参数，此时应该将参数用逗号隔开，然后放到尖括号<>内;

    2. 泛型类的构造器如下：public GenericClass( ){}, 而下面是错误的：public GenericClass( ){}

    3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致；

    4. 泛型不同的引用不能相互赋值；

      尽管在编译时ArrayList和ArrayList是两种类型，但是运行时只有一个ArrayList被加载到JVM中；

    5. 泛型如果不指定，泛型对应的类型均按照Object处理，但是不等价于Object；经验:泛型要使用就要一路使用，否则就不用。

    6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类对象；

    7. jdk1.7，泛型的简化操作为：ArrayListfirst=new ArrayList<>();

    8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。

    9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型

    10. 异常类不能声明为泛型类

    11. 不能使用 new E[]

    12. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

      • 子类不保留父类的泛型：按需实现

        • 没有类型 擦除
        • 具体类型

      • 子类保留父类的泛型：泛型子类

        • 全部保留
        • 部分保留

子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。

3.2泛型方法

  • 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系，换句话说，泛型方法所属的类是不是泛型类都没关系；
  • 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的，并非在实例化类时确定。

泛型在继承方面的体现

  1. 虽然类A是类B的父类，但是G和G二者不具备子父类关系，二者是并列关系；
  2. 类A是类B的父类，A是B的父类

3.3 通配符的使用

通配符：？

  1. 类A是类B的父类，但是G和G二者不具备子父类关系，两者的公共父类是G<?>;

  2. 添加：对于List<?>就不能向其内部添加数据。除了添加null之外。读取：可以读取，读出来的对象类型为Object

  3. 有限制条件的通配符的使用

    ？extends A： G<? extends A>可以作为G和G的父类，其中B是A的子类

    ？super A： G<? super A>可以作为G和G的父类，其中B是A的父类

二、IO流

1. File类的使用

  • File类的一个对象，代表一个文件或一个文件目录（俗称：文件夹）
  • File类声明在java.io包下

1.1 如何创建File类的实例

注意：这里创建实例指的是在内存中创建这样一个实例，不会真实在硬盘中创建文件。

  • File(String filePath)
  • File(String parentPath, String childPath )
  • File(File parentPath, String childPath )

(1)

相对路径：相较于某个路径下，指定的路径

绝对路径：包含在盘符在内的文件或文件目录的路径

(2)路径分隔符

Windows：\\

unix:/

1.2 File类的常用方法

  • Flie类的获取功能

    • public String getAbsolutePath( ):获取绝对路径
    • public String getPath( )：获取路径
    • public String getName( ):获取名称
    • public String getParent( ):获取上层文件目录路径，若无，返回null
    • public long length( )：获取文件长度（即字节数）
    • public long lastModified( ):获取最后一次修改的时间
    • public String[] list( )：获取指定目录下的所有文件或文件目录的名称数组
    • public File[] listFlies( ):获取指定目录下的所有文件或者文件目录的Flie数组

  • Flie类的重命名功能

    • public boolean renameTo(File dest)：把文件重命名为指定的文件路径

      比如：file1.renameTo(Flie dest)：为例。要保证返回True，需要file1在硬盘中是存在的，且file2不能再硬盘中存在。

  • Flie类的判断功能

    • public boolean isDrectory( ):判断是否是文件目录
    • public boolean isFile( ):判断是否是文件
    • public boolean exists( ):判断是否存在
    • public boolean canRead( ):判断是否可读
    • public boolean canWrite( ):判断是否可写
    • public boolean isHidden( ):判断是否隐藏

  • File 类的创建功能

    • public boolean createNewFile( ):创建文件。若文件存在，则不创建，返回false

    • public boolean mkdir( )：创建文件目录。如果此文件目录存在，就不创建了，如果此文件目录的上层目录也不存在，也不创建。

    • public boolean mkdirs( ):创建文件目录。如果上层文件目录不存在，一并创建。

      注意：如果创建文件或者文件目录没有写盘符路径，那么会默认在项目路径下。

  • File 类的删除功能

    • public boolean delete( ):删除文件或文件夹

      删除注意事项：Java中的删除不走回收站。要删除一个文件目录，注意该文件目录内不能包含文件或文件目录。

总结

  1. File类的一个对象，代表一个文件或一个文件目录（俗称：文件夹）
  2. Flie类声明在java.io包下
  3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流完成。
  4. 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的“终点”。

2. IO流原理及流的分类

2.1 java IO原理

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

2.2 流的分类

  • 按操作数据单位不同分为：字节流（8 bit），字符流（16 bit）
  • 按数据流的流向不同分为：输入流，输出流
  • 按流的角色的不同分为：节点流，处理流
抽象基类 字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Write
  • Java的IO流共涉及到40多个类，实际上非常规则，都是从上面四个抽象基类派生的；
  • 由这四个类派生出来的子类名称都是以其父类作为子类名后缀。
抽象基类 节点流（或文件流） 缓冲流（处理流的一种）
InputStream FileInputStream(read(byte[] buffer)) BufferedInputStream(read(byte[] buffer))
OutputSteam FileOutputSteam(write(byte[] buffer,0,len)) BufferedOutputSteam(write(byte[] buffer,0,len))
Reader FileReader(read(char[] buffer)) BufferedReader(read(char[] buffer)/ readLine())
Write FileWrite(write(char[] buffer,0,len)) BufferedWrite(write(char[] buffer,0,len))

3. 节点流（或文件流）

3.1 FileReader读入数据的基本操作

/*
* 说明：
* 1.read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
* 2.异常的处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理
* 3.读入文件一定要存在，否则会报FileNotFoundException
* */
public class FileTest1 {
@Test
//将hello.text中的内容输出到控制台上
    public void testFileReader() {
    FileReader fr= null;
    try {
    //1.实例化Flie类的对象，指明要操作的文件
        File file=new File("hello.txt");//相比较于当前Module
    //2.提供具体的流
        fr = new FileReader(file);
        //3.数据的读入
        //read(): 返回读入的一个字符，如果达到文件末尾返回-1
        int data=fr.read();
        while(data!=-1){
            System.out.println((char)data);
            data=fr.read();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        //4.流资源的关闭
        try {
            if(fr!=null)
                fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//对read()操作升级：使用read的重载方法
@Test
public void testFlieReader1()   {
    FileReader fr= null;
    try {
    //1.实例化Flie类的对象，指明要操作的文件
    File file=new File("hello.txt");//相比较于当前Module
    //2.FileRead流的实例化
        fr = new FileReader(file);
    //3.读入的操作
    //read(char[] cuf):返回每次读入cuf数组中的字符的个数。如果达到文件末尾，返回-1
    char[] cuf=new char[5];
    int len;
    while((len=fr.read())!=-1){
        //方式一：错误的写法
/*        for (int i = 0; i < cuf.length; i++) {
            System.out.println(cuf[i]);
        }*/
        //方式一：正确的写法
        for (int i = 0; i < len; i++) {
            System.out.println(cuf[i]);
        }
        //错误的写法方式二：使用String的构造器将char[]型数组转化为String型
        String s = new String(cuf);
        //方式二正确的写法
        String s1 = new String(cuf,0, len);
        System.out.println(s1);

    }} catch (IOException e) {
        e.printStackTrace();
    }finally {
        //4.流资源的关闭
        try {
            if(fr!=null)
                fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
}

3.2 FileWriter写出数据的基本操作

/*
 *从内存中写出数据到硬盘的文件里
 * 1.输出操作，对应的File可以不存在，并不会报异常
 * 2.
 *  File 对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件
 *  File 对应的硬盘中的文件如果存在：
 *     如果流使用的构造器是：FileWriter(file,false)/FileWrite(file):对原有文件的覆盖
 *     如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是在原有文件的基础上追加内容
 * */
public class FlieWriteTest {
    @Test
    public void testFileWriter()  {
        FileWriter fw = null;
        try {
        //1.提供File类的对象，指明写出到的文件
            File fr=new File("hello.txt");
        //2.提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(fr);
        //3.写出的操作
        fw.write("my name is aa\n");
        fw.write("your name is dd\n");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //4.流资源的关闭
            try {
                if(fw!=null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /*二。读操作和写出操作的结合*/
    @Test
    public  void testFileReaderFileWriter() {
        FileReader fr = null;
        FileWriter fw=null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile=new File("hello.txt");
            File destFile=new File("hello1.txt");
            //2.创建输入流和输出流的对象
              fr = new FileReader(srcFile);
              fw = new FileWriter(destFile);
            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数据中的字符个数
            while ((len=fr.read(cbuf))!=-1){
                 //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //4.流的关闭
            try {
                if(fw!=null)
                fw.close() ;
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fr!=null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

3.3 FileInputStream 和FileOutputStream 的使用

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

  • 使用字节流FileInputStream 处理文本文件，可能出现乱码

  • 如果只是单纯将文本文件复制到另一个文本中，那么使用字节流处理也不会乱码，只是说使用字节流要将文本文件输出到控制台上，可能会出现乱码

public class FileInputStreamTest {
    /*
    实现图片的复制操作
    * */
    @Test
    public void testFileInputOutputStream(){
        FileInputStream fis = null;
        FileOutputStream fos=null;
        try {
        File srcFile = new File("图片.jpg");
        File destFile = new File("图片_副本.jpg");
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);
        //复制的过程
        byte[] buffer=new byte[5];
        int len;
        while((len=fis.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //
            try {
                if(fis!=null)
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fos!=null)
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //指定路径下的文件复制,将上述操作封装为一个方法
    public  void copyFile(String srcPath,String destPath){
        FileInputStream fis = null;
        FileOutputStream fos=null;
        try {
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            //复制的过程
            byte[] buffer=new byte[5];
            int len;
            while((len=fis.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //
            try {
                if(fis!=null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fos!=null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    }

4. 缓冲流--处理流之一

/*处理流之一：缓冲流的使用
1.缓冲流（四种）

2.作用：提供流的读取、写入的速度
提高读写速度的原因：内部提供了一个缓冲区
3.处理流，就是“套接”在已有的流的基础上
* */

public class BufferTest {

    @Test
    public  void BufferedStreamTest(){
        /*实现非文本文件的复制
        * */
        FileInputStream fis= null;
        FileOutputStream fos=null;
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try {
        //1.造文件
        File srcFile = new File("图片.jpg");
        File destFile = new File("图片_副本.jpg");
        //2.造流
        //2.1造节点流
         fis = new FileInputStream(srcFile);

         fos=new FileOutputStream(destFile);
        //2.2造缓冲流
         bis=new BufferedInputStream(fis);
         bos=new BufferedOutputStream(fos);
        //3.复制的细节：读取、写入
        byte[] buff=new byte[5];
        int len;
        while((len=bis.read(buff))!=-1){
            bos.write(buff,0,len);
        }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            try {
                if(bos!=null)
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(bis!=null)
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略
            // fos.close();
            // fis.close();
        }
    }
/*
* 使用BufferedReader和BufferedWriter实现文本文件的复制
* */
    @Test
    public void testBufferedReaderBufferedWriter(){

        BufferedReader br= null;
        BufferedWriter wr= null;
        try {
            br = new BufferedReader(new FileReader( new File("db.txt")));
            wr=new BufferedWriter(new FileWriter(new File("db_1.txt")));

            /*        //读写操作  方式一：
        char[] cbuf=new char[1024];
        int len=0;
        while((len=br.read(cbuf))!=-1){
            wr.write(cbuf,0,len);
        }*/
            //方式二：使用String
            String data;
            while((data=br.readLine())!=null){
                wr.write(data+"\n");//data中不包含换行符
                //wr.newLine();就是提供一个换行符
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            try {
                if(wr!=null)
                wr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(br!=null)
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

5.转换流--处理流之二

  • 转换流提供了在字节流和字符流之间的转换

  • Java API提供了两个转换流：（属于字符流）

    • InputStreamReader：将InputStream 转换为Reader，即将一个字节的输入流转换为字符的输入流

    • OutputStreamWriter：将Writer转换为OutputStream，即将一个字符的输出流转换为字节的输出流

      编码：字符变为字节；解码：字节变为字符

  • 字节流中的数据都是字符时，转成字符流操作更有效

  • 很多时候我们使用转换流来处理文件乱码的问题。实现编码和解码的功能。

  • 字符集：（编码表）

    • ASCII：美国标准信息交换码。用一个字节的7位可以表示；
    • ISO8859-1:拉丁码表。欧洲码表，用一个字节的8位表示；
    • GB2312：中国的中文编码表。最多两个字节编码所有字符；
    • GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码；
    • Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节表示。
    • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
public class InputStreamReaderTest {
    @Test
    public  void test1(){
        FileInputStream fis= null;
        InputStreamReader isr=null;
        try {
            fis = new FileInputStream("hello.txt");
            // InputStreamReader isr=new InputStreamReader(fis);//使用系统默认的字符集
            isr=new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集
            //参数2指明了字符集，具体使用哪个字符集，取决于这个文件当初保存时使用的字符集
            char[] cbuf=new char[20];
            int len;
            while((len=isr.read(cbuf))!=-1) {
                String str = new String(cbuf, 0, len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(isr!=null)
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /*综合使用InputStreamReader和OutputStreamWriter*/

@Test
    public void test2(){
    //1.造文件、造流
        File file1=new File("hello1.txt");
        File file2=new File("dbcp_gbk.txt");
    FileInputStream fis1= null;
    FileOutputStream fos=null;
    InputStreamReader isr1=null;
    OutputStreamWriter osw=null;
    try {
        fis1 = new FileInputStream(file1);
        fos=new FileOutputStream(file2);
        isr1=new InputStreamReader(fis1,"utf-8");
        osw=new OutputStreamWriter(fos,"gbk");
        //2.读写过程
        char[] cbuf=new char[20];
        int len;
        while((len=isr1.read(cbuf))!=-1) {
            osw.write(cbuf,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            //3.关闭流
            if(isr1!=null)
            isr1.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if(osw!=null)
            osw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

}

6. 其他处理流的使用

6.1 标准的输入输出流

  • System.in 和System.out是标准的输入输出流，输入流默认是从键盘输入，输出流默认是从控制台输出；
  • System.in 的类型是InputStream,System.out的类型是PrintStream，其是OutputStream的子类，FilterOutputStream的子类
  • System类的setIn(InputStream in)和setOut(PrintStream out)方式重新制定输入和输出的流

6.2 打印流

  • 实现将基本数据类型的数据格式转化为字符串输出；
  • 打印流：PrintStream和PrintWriter
    • 提供了一系列重载的print()和printLn() 方法，用于多种数据类型的输出
    • PrintStream和PrintWriter的输出不会抛出IOException的异常
    • PrintStream和PrintWriter有自动flush的功能
    • PrintStream打印的所有字符都使用平台默认的字符编码转化为字节，在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类
    • System.out返回的是PrintStream的实例

6.3 数据流

  • 为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流

  • 数据流有两个类：（用于读取和写出基本数据类型、String类的数据）

    • DataInputStream和DataOutputStream
    • 分别套接在InputStream和OutputStream子类的流上

  • DataInputStream中的方法

    boolean readBoolean() byte readByte()

    char readChar() float readFloat()

    double readDouble() short readShort()

    long readLong() int readIn()

    String readUTF() void readFully(byte[] b)

  • DataInputStream中的方法

    将上述的方法的read改为相应的write即可

  • 关于异常的处理，也应该使用try-catch-finally

  • 读取不同类型的数据的顺序要与写入时的数据保持一致

7.对象流

  • ObjectInputStream和ObjectOutputStream

    用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把java中的对象写入到数据源中，也可以把对象从数据源中还原回来

  • 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制

  • 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制

  • ObjectInputStream和ObjectOutputStream不能序列化static和transient修饰的成员变量

/*对象流的使用*/
public class ObjectTest {
    /*序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
    使用ObjectOutputStream实现
    * */
    @Test
    public void testObjectOutputStream(){
        ObjectOutputStream oos= null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
            oos.writeObject(new String("我爱睡觉"));
            oos.flush();//刷新操作
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(oos!=null)
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /*反序列化：将磁盘文件中的对象还原为内存中的一个java对象
    * 使用ObjectInputStream实现*/
    @Test
    public  void testObjectInputStream(){
        ObjectInputStream ois= null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object obj=ois.readObject();
            String str=(String)obj;  //String类型本身实现了序列化
            System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
        }catch ( ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                if(ois!=null)
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

7.1 对象的序列化

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

  • 序列化的好处在于可以将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原；

  • 序列化时RMI（Remote Method Invoke，即远程方法调用）过程的参数和返回值都必须实现的机制，而RMI时JavaEE平台的基础；

  • 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须满足以下条件：

      1. 该对象的类需要实现接口：Serializable

      1. 当前类提供一个全局常量：serialVersionUID

      2. 除了当前类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化的）

8.随机存储文件流

RandomAccessFile 类

  • RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。

  • 并且它实现了DataInput、DataOutput这两个接口，意味着这个类即可以读也可以写；

  • RandomAccessFile 类支持“随机访问”的方式，程序可以直接跳到文件的任意地方来读、写文件；

  • RandomAccessFile 包含一个记录指针，用于标示当前读写处的位置

    RandomAccessFile 类对象可以自由移动记录指针：

    long gteFilePointer():获取文件记录指针的当前位置

    void seek(long pos)：将文件记录指针定位到pos位置
posted @   日积月累，水滴石穿  阅读(57)  评论(0)  编辑  收藏  举报
相关博文：
· Java基础（五）-面向对象编程
· Java进阶（三）-常用类
· Java进阶篇-3
· Java基础
· Java基础学习（十五）
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单，K8s 太复杂？w7panel 让容器管理更轻松！
点击右上角即可分享
微信分享提示