javaSE高级篇2 — 流技术

1、先认识一个类————File类

前言：IO相关的一些常识

I / O————输入输出

I 输入 input
0 输出 output

I / o 按数据的流动方向来分————流动方向：指的是计算机的数据流动————其实这个是有参考系的，如：如果说想要把一个数据弄到主存中来，那我所处的角度（位置）就是主存，数据就只是我的目标，因此：这时读数据就是input（从另外的地方把数据读进来嘛），而从本身中（主存中）把数据弄到另一个地方去，那就是output——写数据（把数据向指定地方写进去嘛）————这样就可以理解了涩
- 读数据————输入 input
- 写数据————输出 output
- 这两个东西别搞懵了，很多人在这个地方直接懵了，什么input叫读数据，什么output叫写数据的，这不是反着的吗，所以有些人学完流技术之后，搞来搞去，最后懵逼了（注意：前面我写的 “ 如： ” 中的这个例子）

I / o按操作目标来分
- 文件流
- 字符流
- 对象流
- 网络流
- ................

什么是文件？

指的就是电脑中的一种存储形式嘛

如：.txt，.doc，.docx，.ppt.........这些都是文件嘛

什么是文件夹？
- 指的就是目录的路径涩
  - 如：D:\IntallationList\MaveIntallationList，这不就指的是前面这一串儿文件夹下的MavenIntallationList这个文件夹吗，所以它就是一个目录的路径涩

File类是什么？

首先它是一个类，在java.io包下
其次它和电脑上的文件产生一一对应的“映射关系”
最后：这个类只是对文件本身进行操作，文件里面的数据搞不了（但是套一层金刚伏魔圈儿就可以搞了）——后续学了流就懂了

- 它是个类，则就有对象，这个对象就是指的文件 / 文件夹，但是：这个文件 / 文件夹并不是电脑中真实硬盘的文件 / 文件夹
  - 而是指的是：“堆内存”中的一个对象，这个对象<————>映射<————>电脑中真实的文件 / 文件夹

File类如何创建对象？

通过new关键字进行创建————有方法重载，但是最常用的是下面这个

File f = new File( String filePathName )————参数中必须跟一个电脑中真实存在的文件 / 文件夹路径（是全路径）————虽然不是真实的也没错，但是就当必须是真实的路径就行（养成习惯），如：
- ```
// 1、创建File对象

File file = new File( "D:\\InatallationPackage\\Mybatis\\Resources" ); // 当然这里的 \\，也可以写成 /       
```

File类中的一些常用方法（完整的方法集可以直接看API）
- length()————获取文件的字节大小
  - ```
  File file = new File("D:\\InatallationPackage\\Mybatis\\Resources");
  
  System.out.println( file.length() );
```

boolean = CanRead()———查看文件是否可读

// 2、查看文件是否可读

System.out.println( file.canRead() );

boolean = CanWrite()————查看文件是否可写

// 3、查看文件是否可写

System.out.println( file.canWrite() );

boolean = CreatNewFile()————创建一个新文件————相比其他这个方法更常用

// 4、创建一个新文件

 try {

   System.out.println( new File("D:/IntallationList/creatNewFile.txt").createNewFile() );

   System.out.println( new File("d:/creatNewFile.txt").createNewFile() ); // 这两种创建都行

   /*

     注：

        1、这个方法需要处理异常————抛出或捕获都行

        2、创建的文件前面的路径必须是真实有效的，否则：无法创建

   */

  } catch (IOException e) {

            e.printStackTrace();

 }

- boolean = delete()————删除一个文件 / 文件夹————如果删除的文件夹中还有文件 / 文件夹，则：无法删除　　
  - ```
  // 5、删除一个文件
  
  System.out.println( new File("D:\\test\\hit-me.txt").delete() );
```

boolean = exists()————查看一个文件是否存在——这个在开发中还有点用

// 6、查看一个文件是否存在

System.out.println( new File("d:/test/aaa.txt").exists() );

String = getAbsolutePath()————获取文件的绝对路径——还有点用

// 7、获取文件夹的绝对路径————即：文件夹的全路径

System.out.println( new File("D:\\IntallationList\\MaveIntallationList").getAbsolutePath() );

String = getName()————获取文件的名字————也有点用

// 8、获取文件的名字————本例子中结果为：MaveIntallationList

 System.out.println( new File("D:\\IntallationList\\MaveIntallationList").getName() );

String = getParent()————获取当前文件的上一层的整个文件路径————结果是个字符串，也没多大用

// 9、获取文件的上层全路径————本例中结果为：D:\IntallationList，这个值是一个字符串

System.out.println( new File("D:\\IntallationList\\MaveIntallationList").getParent() );

File = getParentFile()————获取当前文件的上一届的整个文件路径对象————这个就有点用了，因为：返回的是一个File对象

// 10、返回当前文件的上一层的整个文件路径的对象————本例中结果为：D:\IntallationList，但是这个值是一个File对象

System.out.println( new File("D:\\IntallationList\\MaveIntallationList").getParentFile() );

String[ ] = list()————返回指定文件夹中的所有文件 / 文件夹名的 String类型数组————还是没多大用

// 11、返回一个文件夹中的所有文件 / 文件夹 名的 String数组

String[] fileList = new File("D:\\IntallationList").list();

for (String list : fileList) {

  System.out.println( list );

}

File[] = listFiles()————返回指定文件夹中的所有文件 / 文件夹的全路径的 File对象数组————这个才是有用的

// 12、返回指定文件夹中的所有文件 / 文件夹 的 全路径的 File对象数组

File[] files = new File("D:\\IntallationList").listFiles();

for (File f : files) {

   System.out.println( f );

}

- mkdir()————创建文件夹，是文件夹，不是前面说的文件————但是：这个方法创建，必须保证要创的文件夹外面那一层文件夹是真实存在的，否则：创建不了————但是这个方法也没什么卵用
  - ```
  // 13、创建文件夹
  
  System.out.println( new File("d:/test/demo").mkdir() ); // 这种好使，因为demo的上一级test是存在的
  
  ew File("d:/test/aaa/bbb").mkdir();    // 这种就不得吃，因为bbb的上一层aaa并没有
```

- mkdirs()————这个才是有用的一个，上一层没有文件夹也可以帮忙创建上一层

对文件里面的数据进行操作————真正的IO流技术
- IO体系是咋个样的？————就下面这个样，知识好多哦！！！！

流体系学懂一个，其他的都懂了，流程都是如上图底部中说的那样，全部流技术都是一模球儿一样的流程

1、文件流
- 指的是：
  - 从其他地方读取文件的信息（ input ）
  - 将信息写入其他地方的文件中（ output ）

- 文件流分为：
  - 1、字节型文件流————即：读取 / 写出是以字节形式读写文件
    - FileInputStream 字节型文件输入流
    - FileOutputStream 字节型文件输出流

- - 2、字符型文件流————即：读取 / 写出是以字符形式读写文件
    - 1、FileReader————字符型文件输入流
    - 2、FileWriter————字符型文件输出流

文件流的操作原理————堆内存是JVM里面的那个，在前面的知识中画过多次JVM分析图了

从这图中就可以看出：引入流技术的原因、

变量、数组、集合都是java中的类型————这是用对象进行操作内存，都存储在内存中，程序执行完毕之后，虚拟机就停止了，相应的内存中的东西就被回收了，所以这些数据都是临时存储的。而文件也可以存储很多数据，同时是存储在磁盘上的，是永久性保存
因此：引入流技术的原因就是
- 在文件中，虽然数据安全了，但不是在内存中，是在磁盘上的，故：无法直接进行操作，因此：引入流技术通过IO操作文件

文件流（重点）

1、字节型文件流

1、字节型文件输入流————FileInputStream———套个儿子
- 把一个指定地方的文件的数据读取出来

- 在java.io包下
- FileInputStream继承了InputStream类————InputStream类是字节型输入流的老爹（这是一个抽象类）

FileInputStream怎么创建对象？

通过new关键字创建，但是需要传参，参数有三种方式————最常用的是下图中的前两种

        try {

            // 1、直接利用String类型的有参构造————注意：处理异常，可以抛出，也可以捕获

            FileInputStream fis = new FileInputStream( "D:\\IntallationList" );

            // 2、通过套个儿子的方式创建

            FileInputStream fis2 = new FileInputStream( new File("D:\\IntallationList") );

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        }

- FileInputStream类中的常用方法————这里面的方法就是真的常用了
  - int = read()————指的是：每次从流管道中读取一个字节————有重载

- - - 对这个方法返回值类型是 int 类型的解释————这是一个反人类的设计——以前的返回值都是指：我们传递进去的数据类型参数（如：这里的int）参与计算得出的值，即：输入型参数————而这里的int不再是我们传进去的数据类型参数参与计算得到的，而是一种输出型参数
      - 1、如果是无参的这个read()，则：得到的int值表示的是——要读取的数据的下一个字节的字节码，若：读取的数据已经到了最后，则：返回-1
      - 2、read( byte[ ] b , int off , int len )———题外话：off是偏移量，指的是：跳过off之前的字节，从off位置开始读取，len是指：需要读取的字节长度，即：从off开始，往后读取多少个字节
      - 3、如果是使用的read( byte[ ] b )————这个方法其实调用了2中的三参方法。它得到的int值取决于两个方面
        
        如果我们读取的数据长度比我们用来装读取出来的数据的容器要大，则：得到的这个int值就是这个容器的大小
        
        如果我们读取的数据长度比我们用来装读取出来的数据的容器要小，则：得到的这个int值就是我们读取的数据的字节长度————对于这里所说的容器不懂的话，那就等到这个流技术最后写整个流程知识那里，就懂这里说的容器是什么了
        
        同样的，如果是在文件的最后，返回的也是-1

- - int count = available()————查看流管道中还有多少字节

- - long = skip( Long n )————就是跳过n个字节，然后再从n之后读取文件————和read( byte[ ] b , int off , int len )达到的效果一样，看情况——哪个适合用哪个
    - 这个方法可以用在多线程中
      - 利用几个线程同时读取一个文件
        
        如：文件中有10000个字节，就可以通过5个线程去进行读取——这样效率不就很快了吗
        
        1线程读取1——2000
        
        2线程读取2001——4000
        
        3线程读取4001——6000
        
        4线程读取6001——8000
        
        5线程读取8001——10000

- - void = close()————将流管道关闭————这一步在文件操作中是必须要的
    - 故：这个方法就可以放在finally结构中
    - 注：在把close()放在finally结构中时，应注意：代码的健壮性，所以判断要严谨
      - 如：判断文件是否操作完毕了，完成了才关闭流管道，否则：就如：打开了一个文件（没关闭），但是执行删除操作一样———删不了，同理：流管道能够关闭吗？——流管道不关闭很耗内存的

FileInputStream流技术的操作流程的三步骤（死流程）————三板斧^ _ ^
- 创建流
- 读数据
- 关闭流管道

实例

import java.io.FileInputStream;

import java.io.IOException;

public class Test {

    public static void main(String[] args) {

        // 1、创建流

        FileInputStream fis = null;

        try {

            fis = new FileInputStream("D:\\InatallationPackage\\Maven\\pom.xml");

            // 2、读数据

            // 准备一个容器————用来装读取出来的数据

            byte[] data = new byte[1024];  // 大小可以任意取，建议用这个大小

            int len;  // 这len是为了给read()读取的int结果 同时为了判断————注：别把这个len放在while那个判断力，会出问题

            while ( ( len = fis.read( data ) ) != -1 ){ // read()读取文件 
    // 同时把读取出来的结果放到新建的data数组容器里。另外：这里的判断可以不写成 ！= -1，还可以写成 > 0 

                System.out.println( new String( data , 0,len ) ); // 这里可以看需求弄成其他方式，我只是为了看效果，所以打印了而已

            }

        } catch (IOException e) {

            e.printStackTrace();

        }finally {

            // 关闭流管道

            // 保证代码健壮性

            if ( fis != null ){ // 判断一手儿，为什么是 ！= nul才关闭流管道？看起来应该是fis中为null了，才说明没有内容需要读写了涩
                               // 别忘了 真正去进行映射操作文件的是哪个吊毛————File对象，所以这里的fis只是一个对象，它指向的是File
                              // 所以要是fis为null了，那不就说明fis没有引用了吗，这不就没有一个指向者了————最后也就会导致空指针异常
                             // 后续另外的流也是这么一个原因

                try {

                    fis.close();  // 再关闭流管道

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

2、字节型文件输出流——FileOutputStream
- 将一些数据写入到一个指定的文件中
- 也在java.io包下
- FileOutputStream继承了OutputStream

- FileOutputStream怎么创建对象？
  - 和FileInputStream一样

- - 只是有一个地方需要注意：就是这个输出流是可以操控是否可以追加内容的，即：上图中的第2和第4种创建方式，参数中有一个boolean类型的参数，这个参数就是表示：是否需要追加，默认是false
    - 追加是什么意思？
      - 就是下一次添加内容到同一个文件的时候，可以追加的话，就表示：从文件的后面接着添加内容。不可以追加的话，就表示：系统把原文件删了，然后重新创建一个和原文件名字一模一样的文件，最后再添加本次的内容

FileOutputStream中的常用方法
- 和FileInputStream一样，所以：不再玩儿了
- 但有一个额外的方法需要说明：
  - flush()————刷新（指的其实就是：将流管道中的数据推入【刷新】文件中去），这一步必须有，不然数据无法添加进文件中
    - 另外：close()在这里既有关闭流管道，又有刷新的功能

FileOutputStream的使用流程是怎么样的？——还是三板斧
- 创建流
- 写数据
- 关闭流管道

实例：

import java.io.FileOutputStream;

import java.io.IOException;

// 字节型文件输出流

public class TestFileOutputStream {

    public static void main(String[] args) {

        // 1、创建流

        FileOutputStream fos = null;

        try {

            fos = new FileOutputStream("d:/test/demo.txt",true); // true为：可以追加内容

            // 2、写数据————想要向上面的文件中写入什么内容————利用write()方法————但是这个方法的参数是int 或 byte[]

            fos.write( "这是想要写入的String类型的内容".getBytes() );  // 利用String中的getBytes()方法就把String转为 byte[]字节数组了

            // 也可以在这里加上flush()————即：把2中的数据从流管道中推入文件中

            fos.flush(); // 但是：不用加也可以，因为：close()在这里面有关闭流管道、刷新文件中数据的功能

        } catch (IOException e) {

            e.printStackTrace();

        }finally {

            // 3、关闭流管道

            if ( fos != null ){ // 为了代码的健壮性，严谨判断一手儿

                try {

                    fos.close(); // 关闭流管道

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

利用FileInputStream 和 FileOutputStream实操一手儿

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Date;

import java.util.Scanner;

/**

 * 有这么一个需求：

 *      1、从控制台输入

 *          日记标题

 *          输入正文

 *          然后保存到一个文件中————要求每一篇的日记名字都不一样

 *

 *       2、从日记文件中读取指定名字的日记，从而在控制台显示出对应的日记内容

 */

public class Note {

    public static void main(String[] args) {

        writeNote();

        readNote();

    }

    // 录入日记

    public static void writeNote() {

        System.out.println("请输入日记的标题：");

        Scanner input = new Scanner(System.in);

        String title = input.next();

        System.out.println("请输入日记的正文：");

        String text = input.next();

        // 把控制台输入的东西 放到指定文件中去

        // 1、创建输出流

        FileOutputStream fos = null;

        try {

            fos = new FileOutputStream("d:/test/note/" + new Date().getTime() + ".txt");


　　　　　　　 // 2、写数据

            // 把标题写入文件中去

            fos.write( "标题：".getBytes() );

            fos.write(title.getBytes() );

            fos.write( "\n".getBytes() );   // 换行

            // 把输入的正文写入到文件中去

            fos.write( "正文：".getBytes() );

            fos.write( text.getBytes() );

        } catch (IOException e) {

            e.printStackTrace();

        }finally {


　　　　　　　// 3、关闭流管道

            if ( fos != null ){

                try {

                    fos.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

　　　　　　  System.out.println( "录入成功" );


        }

    }

    // 读取指定名字的日记

    public static void readNote() {

        System.out.println("请输入你想要查看的日记名：");

        Scanner input = new Scanner(System.in);

        String noteName = input.next();

        String realName = noteName + ".txt";

        // 创建输入流

        FileInputStream fis = null;

        try {

            fis = new FileInputStream("d:/test/note/" + realName);

            // 读数据

            byte[] text = new byte[1024];

            int len;

            while ( ( len = fis.read(text) ) != -1 ){

                System.out.println( new String( text,0,len ) );

            }

        } catch (IOException e) {

            e.printStackTrace();

        }finally {

            // 关闭流管道

            if ( fis != null ){

                try {

                    fis.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

效果图如下：

2、字符型文件流

1、字符型文件流——以字符的形式读取文件，通常是纯文本文件（如：txt文件）——excel、doc这种不是纯文本，它是一种软件
- 为什么要有字符型文件流？
  - 假设有这么一个文件————里面有中文和英文
  - 如果想要去读取这个文件，而用来装读取内容的容器大小刚好是16呢？————即：大小位置为“你”这个字哪里，“你"之前的，逗号那里为15，空格也是一个字符
    - 这种情况继续用字节型文件流来读取会怎么样？———— 一个中文占2个字节
      - 那这样，想要把“你”字完全读出来，理论上应该是容器大小为17，这样才可以装得下“你”这个字涩
      - 但是：容器大小是16————所以会导致：中文读取失败（即：无法完整读取）
      - 同时：以字符的形式读取比字节的形式更快一点
      - 因此：有了字符型文件流

字符型文件流的分类
- FileReader 字符输入流————核心方法就：read()
- FileWriter 字符输出流————核心方法就：write()

怎么创建对象？

实例使用——三板斧———流的使用都是这样，后续不再说明了

package cn.xieGongZi.testFileReaderAndFileWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class Demo {

    public static void main(String[] args) throws IOException {

        readData();

        writeData();

    }

    // 读数据

    public static void readData() throws IOException {

        // 创建流管道

        FileReader fr = new FileReader("D:\\InatallationPackage\\Maven\\pom.xml");

        // 读数据

        char[] data = new char[1024];

        int len;

        while ( (len = fr.read(data)) != -1 ){

            System.out.println( new String( data,0,len) );

        }

        if ( fr != null ){

            fr.close();

        }

    }

    // 写数据

    public static void writeData() throws IOException {

        // 创建流管道

        FileWriter fw = new FileWriter("d:/test/play.txt", true);

        // 写数据

        fw.write("天王盖地fu，宝塔镇huo妖");

        // 关闭流管道

        if ( fw != null ){

            fw.close();

            System.out.println("数据写入完毕");

        }

    }

}

学了字节型和字符型文件流操作，其实其他的流操作都已经会了，因为一样的，分类也一样，只是有细微的区别而已

缓冲流————也可以叫包装流——照样不断套娃嘛

就是在流管道中增加缓存数据，从而让我们的数据读写更快，更加流畅，就好比：在文件流的基础上把一部分的流管道容量加大了

1、字节型缓冲流

字节型输入缓冲流————BufferedInputStream

字节型输出缓冲流————BufferOutputStream

这两个没啥好说的，对照字节型文件流就可以了

2、字符型缓冲流

字符输入流——BufferedReader————对照FileReader
- 但是：这个有一个需要注意的地方————BufferedReader的一个方法
  - nextLine()————读取纯文本中一行的内容——很重要啊，用这个流读数据就用这个方法，不再用read()

字符输出流——BufferedWriter———对照FileWriter
- 这个流也有一个特殊的地方————BufferedWriter的一个方法
  - newLine()————这个方法就相当于是换行

实操一手儿

package cn.xieGongZi.buffer;

import java.io.*;

public class Demo {

    public static void main(String[] args) throws IOException {

        readData();

        writeData();

    }

    // 读数据

    public static void readData() throws IOException {

        BufferedReader br = new BufferedReader(new FileReader("D:\\IntallationPackage\\Maven\\pom.xml"));

        String data = null;

        while ( ( data = br.readLine()) != null ){  // readline（）一行一行的读取内容

            System.out.println(data);

        }

    }

    // 写数据

    public static void writeData() throws IOException {

        // 创建输出流

        BufferedWriter bw = new BufferedWriter(new FileWriter("d:/test/play.txt",true));

        // 写要录入文件的数据

        bw.newLine(); // 换行————在新的一行中开始添加内容

        bw.write("老衲来自西方极乐世界，到南方来享受金乌施主的温柔阳光");

        // 关闭流管道

        if ( bw != null ){

            bw.close();

            System.out.println("数据写入成功");

        }

    }

}

转换流（重点）

转换流的作用：

有时读写文件的时候，用字节的方式来读写太慢了，利用字符的形式读写要快得多涩，所以这个时候就需要把字节型流转换为字符型流，这样读写的效率就快得多了
- 根据上面的理论，好像也可以套儿子嘛，因为是字节型转为字符型，所以直接在字符型中再套一个字节型就可以了涩（因为字符流就是基于字节流实现的嘛）。如下所示（字节文件输入转字符文件输入）：

FileReader fr = new FileReader( new FileInputStream("d:/test/play.txt") );  // 这样看起来貌似就是想要的效果嘛

麻嘞个巴子咧~~别乱玩儿啊，看一下创建FileReader对象的时候，传递的参数是啥类型？————是字符串 / File类啊————所以上面的那种创建就是乱弹琴

1、字节输入流转字符输入流（ InputStreamReader ——— 看名字记嘛，inputStream是字节输入流涩，Reader是字符流里面的啊，所以就是字节输入流转字符输入流咯）

InputStreamReader流的使用

// 创建流

InputStreamReader isr = new InputStreamReader(new FileInputStream("d:/test/play.txt"));

// 读数据
isr.read(？？？？); // 但是这里传递的参数是一个char[] / charBuffer，而read()读出来之后的返回值又是int类型的，咋个办？
　　               // 强转？char————>int确定没问题？转不转得了是一回事，重要的是：不会造成数据丢失吗？

// 那就给这个字符流再找个爹儿，变一下嘛.........

套个爹儿的玩法

// 创建流

BufferedReader br = new BufferedReader( new InputStreamReader( new FileInputStream("d:/test/play.txt") ) );

// 读数据————读出来了得有个容器接一下嘛

String buffer;

while ( ( buffer = br.readLine() ) != null ){

          System.out.println( buffer );

      }

// 关闭流管道

if ( br != null ){

     br.close();

}

2、字节型输出流转字符型输出流———和1一样，所以直接上实例

// 字节型输出流——————>字符型输出流

// 创建流

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:/test/play.txt",true)));

// 写数据

bw.newLine();   // 换行再录入数据

bw.write("贫道突然不知道录入个啥子数据进去好了");

// 关闭流管道

if ( bw != null ){

     bw.close();

     System.out.println("数据录入成功");

}

对象流（重点）——ObjectStream

为什么要搞对象流这个东西？

在面向对象编程篇的特征修饰符中见过一个修饰符了涩————transient，即：瞬时的（通俗讲就是：不把对象序列化）
- 这个猫玩意儿就需要用到这里来了

另外就是：分布式开发的时候，这个鸟儿东西就很有用了，因为：可以跨服务器调用彼此之间的东西，如：在A服务器上，调用B服务器的属性和方法，就可以利用这个骚东西知识（配合transient修饰符）来整了

1、序列化对象流————ObjectOutputStream

指的是：把一个完整的对象（这个对象保存的就是自己要录入的数据）拆分成字节碎片（这种东西人看都看球不懂，但计算机懂就行），然后存入到指定的文件中去

ObjectOutputStream流如何创建对象？
- ObjectOutputStream = new ObjectOutputStream( OutputStream os )

序列化的实现方式
- 让对象实现Serializable接口（序列化接口），这就是一个标志接口，里面啥子都没有（在面向对象的接口知识中已说明）————另外：让对象实现这个接口之后，对对象本身没有任何影响，就是给这个对象做了一个标志而已

实例走起

创建一个对象————先创建一个类（用其他对象也可以）

package cn.xieGongZi.objectStream.test;

import java.io.Serializable;

public class Person implements Serializable { // 让这个类实现Serializable接口，表明这个类是可序列化的

    private String name;

    private char sex;

    private Integer age;

    @Override

    public String toString() {

        return "Person{" +

                "name='" + name + '\'' +

                ", sex=" + sex +

                ", age=" + age +

                '}';

    }

    public Person() {

    }

    public Person(String name, char sex, Integer age) {

        this.name = name;

        this.sex = sex;

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public char getSex() {

        return sex;

    }

    public void setSex(char sex) {

        this.sex = sex;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

}

进行序列化

// 序列化流

// 创建流

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:/test/ObjectOutputStream.txt"));

// 写数据

oos.writeObject(new Person("邪公子", '女', 18));  // 注意：这里是使用WriteObject()

oos.writeObject(new Person("紫邪情", '女', 30));

oos.writeObject(new Person("小紫", '女', 150));

oos.writeObject(new Person("韩非", '男', 100));

// 关闭流管道

if (oos != null ){

    oos.close();

    System.out.println("对象序列化完毕");

}

效果如下：看不懂就对了，这就是字节碎片，是计算机底层的东西，这个内容是计算机强行显示出来的内容，在底层也就是二进制存储的

把对象序列化到文件中去，这都是计算机语言，看都看球不懂，咋个整？反序列化回来嘛

2、反序列化对象流

指的是：把字节碎片还原回一个完整的对象

直接上实例

        // 反序列化

        // 创建流

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/test/ObjectOutputStream.txt"));

        // 读数据

        try {

            Object person1 = ois.readObject();  // 在这里：反序列化的顺序就是前面序列化的顺序，不能把顺序搞乱了，不然反序列化出来的数据不一样 / 出错

            System.out.println( person1 );  // 看效果

            Object person2 = ois.readObject();

            System.out.println( person2 );

            Object person3 = ois.readObject();

            System.out.println( person3 );

            Object person4 = ois.readObject();

            System.out.println( person4 );

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        }finally {

            // 关闭流管道

            if (ois != null ){

                ois.close();

            }

        }

效果如下：

至此：需要用的流技术知识已经完毕

后续为装墨水儿知识，知不知道都无所谓

编码与字符集————这里也就来解决乱码的问题

编码

指的是：把字符与数字对应的过程

字符集

指的是：一张记录了对应关系的信息表
- 这种有很多，如：
  - GBK ———— 我国的国标码
  - ISO-8859-1 ———— 西欧语言
  - Big5 ———— 香港台湾语言（繁体字）
  - Unicode ———— 联合编码（多个国家的语言字符都包含在这张表里面）————里面还分为：UTF-8（三串数字存一个中文字符）、UTF-16.......

理论整起来贼没意思，来上实例
- 假如：我存了这么一个数据，然后采用了ANSI编码（不懂门道的，可以简单理解为GBK）

然后去读取这个文件

FileInputStream fis = new FileInputStream("d:/test/play.txt");

byte[] data = new byte[1024];

int len;

while ( ( len = fis.read(data) ) > 0 ){

        System.out.println( new String(data, 0, len) );

      }

if ( fis != null ){

      fis.close();

}

读取出来的效果是这样的————即：发生乱码了————怎么解决？
- 　　　　
只需要把编码格式改一下————因为：保存的时候是使用的ANSI编码，那解码用GBK就可以了（即：charSet ）

再来了解一下：前面说的UTF-8是三串数字存一个中文字符是不是真的

测试一下

// UTF-8是不是采用三串数字保存的一个中文字符？

String data = "中国太好玩儿了";

// 把这个内容采用UTF-8的解码格式读出来看一下

byte[] newData = data.getBytes();  // 这个采用的是系统的默认字符集，而我的字符集就是UTF-8

// 打印出来看一下

System.out.println( Arrays.toString(newData) );

我的idea编码解码格式如下：

最后看一下效果

-28, -72, -83 ———— 中
-27, -101, -67 ———— 国
-27, -92, -86 —————— 太
-27, -91, -67 —————— 好
-25, -114, -87 —————— 玩
-27, -124, -65 —————— 儿
-28, -70, -122 —————— 了

再验证一下嘛：拿这串数字反编译一下，看是不是这几个字

// 整体反编译测试
byte[] data = {-28, -72, -83, -27, -101, -67, -27, -92, -86, -27, -91, -67, -25, -114, -87, -27, -124, -65, -28, -70, -122};
String chineseData = new String(data, "UTF-8");
System.out.println( chineseData );
System.out.println();

// 单个反编译测试
byte[] byteText = {-28, -72, -83};
System.out.println( new String(byteText, "UTF-8") );

效果如下：
-

其他的那些编码也可以这么玩儿

同时：由以上的测试就得出一个结论：

只要产生了乱码，那么必定是编码格式和解码格式不一致导致的

打印流———printStream(没啥好玩儿的）

这个东西最常见了，一直都在用，只是不知道它具体的名字而已

System.out.println()———龟儿嘞舅舅滴，这就是属于打印流^ _ ^，只不过这是属于System下的而已

1、字节打印流

直接看实例

// 字节打印流

PrintStream ps = new PrintStream("d:/test/play.txt");

ps.println("what are you 弄啥嘞？");   // 这是向指定文件打印数据

ps.close();

// 字符型打印流

PrintWriter pw = new PrintWriter("d:/test/play.txt");

pw.print("这玩意儿也不好玩儿啊");

pw.close();

任意文件访问类——RandomAcessFile(更没什么好玩儿的）

通过seek(int pos) 方法移动指针——用来规定从什么位置开始写数据，读数据

支持三种模式

r 只读

w 只写

rw 读写————这个比前面两个用有一点儿

直接看实例咯，懒球整这个类其他的屁东西

// 随机访问文件类

RandomAccessFile raf = new RandomAccessFile("d:/test/play.txt","rw");

// 移动光标到 末尾位置 写数据

raf.seek( raf.length() );

raf.writeBytes( "mysql" );

// 移动光标到 开始位置 读操作

raf.seek(0);

String line = raf.readLine();

System.out.println( line );

raf.close();

流技术的东西就搞完了，在这个阶段没什么写的了

javaSE高级篇2 — 流技术 — 更新完毕的更多相关文章

javaSE高级篇3 — 网络编程 — 更新完毕
网络编程基础知识先来思考两个问题( 在这里先不解决 ) 如何准确的找到一台或多台主机? 找到之后如何进行通讯? 网络编程中的几个要素 IP 和端口号网络通讯协议:TCP / UDP 最后一句 ...
4 - 基于ELK的ElasticSearch 7.8.x技术整理 - 高级篇（续） - 更新完毕
0.前言这里面一些理论和前面的知识点挂钩的,所以:建议看一下另外3篇知识内容基础篇:https://www.cnblogs.com/xiegongzi/p/15684307.html java操作 ...
javaSE高级篇4 — 反射机制( 含类加载器 ) — 更新完毕
反射机制 1.反射机制是什么?----英文单词是:reflect.在java.lang包下---这才是java最牛逼的技术首先提前知道一句话----在java中,有了对象,于是有了类,那么有了类之后 ...
javaSE高级篇6 — 注解（附：注解底层解析） —— 更新完毕
注解 ---- 英文:annotation 1.注解长什么样子? @xxxxxxx( 一些信息 ) ----- 这个信息可有可无 2.注解可以放在什么地方? 类本身的上面.属性的上面.方法的上面.参数 ...
javaSE高级篇5 — java8新特性详解———更新完毕
java8新特性在前面已经见过一些东西了,但是:挖得有坑儿 1.lambda表达式 lambda表达式是jdk1.8引入的全新语法特性它支持的是:只有单个抽象方法的函数式接口.什么意思? 就是说: ...
javaSE高级篇7 — 设计原则和设计模式 — 设计模式慢慢更（这是思想层次篇）
1.什么是设计原则? 设计原则就是面向对象的原则嘛,即:OOP原则换句话说:就是为了处理类与类之间的关系( 包括接口.类中的方法 ) 2.OOP设计原则有哪些? 1).开闭原则:就是指对拓展开放.对 ...
javaSE高级篇1 — 异常与多线程基础
1.异常的体系结构注:Throwable是一个类,不是一个接口,这个类里面是描述的一些Error和Exception的共性,如图所示: 异常 / 错误是什么意思? 定义:指的是程序运行过程中,可能 ...
javaWeb - 1 — servlet — 更新完毕
1.先来聊一些javaWeb相关的知识简单了解一下:web的发展史 1).web就是网页的意思嘛 2).web的分类 (1).静态web 使用HTML.CSS技术,主要包括图片和文本优点:简单,只 ...
Vue2技术整理3 - 高级篇 - 更新完毕
3.高级篇前言基础篇链接:https://www.cnblogs.com/xiegongzi/p/15782921.html 组件化开发篇链接:https://www.cnblogs.com/xi ...

随机推荐

STM32 学习笔记之中断应用概览--以f103为例
异常类型 F103 在内核水平上搭载了一个异常响应系统, 支持为数众多的系统异常和外部中断.其中系统异常有8 个(如果把Reset 和HardFault 也算上的话就是10 个),外部中断有60个.除 ...
用Python去除PDF水印
今天介绍下用 Python 去除 PDF (图片)的水印.思路很简单,代码也很简洁. 首先来考虑 Python 如何去除图片的水印,然后再将思路复用到 PDF 上面. 这张图片是前几天整理<数据 ...
SPOJ GSS8 - Can you answer these queries VIII | 平衡树
题目链接这一道题的修改操作用平衡树都很容易实现,难处理的是询问操作. 要想解决询问操作,只要知道如何在平衡树上快速合并左右两个区间的答案即可. 设$Ans_{[l,r]}^k=\sum\limits ...
hdu 5172 GTY's gay friends（线段树最值）
题意: GTY有n个朋友,站成一排,每个人有一个特征值ai. 有m个询问.每次询问给两个数L,R.问你[L,R](即aL...aR)是否是1..(R-L+1)的一个全排列. 是输出YES,否则输出NO ...
JAVA笔记12__字节、字符缓冲流/打印流/对象流/
/** * !!:以后写流的时候一定要加入缓冲!! * 对文件或其它目标频繁的读写操作,效率低,性能差. * 缓冲流:好处是能更高效地读写信息,原理是将数据先缓冲起来,然后一起写入或读取出来. * * ...
IDEA免费激活至2099年教程，亲测可用
申明,本教程 Intellij IDEA 最新版激活教程,激活码均收集与网络,请勿商用,仅供个人学习使用,如有侵权,请联系作者删除.如条件允许,建议大家购买正版. 以下是本人免费激活到 2099 年的 ...
native连接远程mysql数据库
1.环境 CentOS7.mysqld 8.0.19 2.登录数据库 #mysql -u root -p 2.修改root登录地址为%(任何IP) mysql> update user set ...
【Jenkins】jenkins构建python项目提示：'python' 不是内部或外部命令，也不是可运行的程序或批处理文件
一.问题:jenkins构建python项目提示:'python' 不是内部或外部命令,也不是可运行的程序或批处理文件二.原因:要在jenkins配置本地环境变量三.解决方案:添加python.e ...
js 实现匀速移动
js 实现匀速移动 <!DOCTYPE html> <html lang="en"> <head> <meta charset=" ...
mysql批量修改某一列的值为另外的值
sql语句 UPDATE tb_info SET org_id = 2170 WHERE org_id = 815

javaSE高级篇2 — 流技术 — 更新完毕

javaSE高级篇2 — 流技术 — 更新完毕的更多相关文章

随机推荐

热门专题