IO流

文件

概述

File：

文件和目录路径名的抽象表示形式。

既可以表示文件也可以表示文件夹。

抽象路径：创建文件对象时，硬盘上不一定存在。

构造方法

1.构造方法：

① File(String pathname)

② File(File parent, String child)

③ File(String parent, String child)

常用方法

1.常用方法：

① exists() 判断文件或目录是否存在在硬盘上。

② getAbsoluteFile() /getAbsolutePath() 绝对路径

2.绝对路径和相对路径：

① 绝对路径：从盘符开始的路径。

② 相对路径：相对于某个路径的路径。

对javase的项目：针对idea工具，前面啥也不带表示当前项目底下。

代码

package com.demo;

import java.io.File;

/**
  1.构造方法：
    ① File(String pathname)
    ② File(File parent, String child)
    ③ File(String parent, String child)
  2.常用方法：
     ① exists() 判断文件或目录是否存在在硬盘上。
     ② getAbsoluteFile() /getAbsolutePath() 绝对路径
  3.绝对路径和相对路径：
     ① 绝对路径：从盘符开始的路径。
     ② 相对路径： 相对于某个路径的路径。
         对javase的项目：针对idea工具，前面啥也不带 表示当前项目底下。

 */
public class File类 {
    public static void main(String[] args) {
        File f = new File("D:\\1\\2.txt");
//        System.out.println(f.exists());
//         ② File(File parent, String child)
          File f1 = new File("d:\\1");
          File f2 = new File(f1,"2.txt");
          File f3 = new File("D:\\1","2.txt");
       /* System.out.println(f2.getAbsolutePath());
        System.out.println(f3.getAbsolutePath());*/
       File f4 = new File("1.txt");
        System.out.println(f4.getAbsoluteFile());
        File f5 = new File("day21a\\1.txt");
        System.out.println(f5.getAbsoluteFile());
    }

}

常用方法一

1.常用方法：

① createNewFile() 创建文件没有才创建。

② delete() /deleteOnExit() 删除 /退出jvm时删除

注意：

delete删除方法不走回收站。

delete删除文件或空目录。

(**)③ isDirectory() 判断是否为目录

(**)④ isFile() 判断是否为文件

注意：

目录或文本必须存在才能返回true，否则不存在或者不是都返回false。

⑤ length() 文件的长度容量只对文件有效，对于目录来说，值不确定的。

代码

package com.demo;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;

/**
   1.常用方法：
     ① createNewFile() 创建文件没有才创建。
     ② delete() /deleteOnExit() 删除 /退出jvm时删除
        注意：
            delete删除方法不走回收站。
            delete删除文件或空目录。
     (**)③ isDirectory()  判断是否为目录
     (**)④ isFile()      判断是否为文件
       注意：
           目录或文本必须存在才能返回true，否则不存在或者不是都返回false。
     ⑤ length() 文件的长度 容量 只对文件有效，对于目录来说，值不确定的。

 */
public class File类常用方法 {
    public static void main(String[] args) throws IOException {
        File file = new File("d:\\1\\3.txt");
//           ① createNewFile() 创建文件没有才创建。
        /*boolean flag = file.createNewFile();
        System.out.println(flag);*/
//         ② delete() /deleteOnExit() 删除 /退出jvm时删除ut
//        boolean flag1 = file.delete();
//        System.out.println(flag1);
//        File file2 = new File("d:\\1");
//        boolean flag2 = file2.delete();
//        System.out.println(flag2);

//        getParent()/getParentFile() 获取父目录
//        System.out.println(file.getParent());

        /*(**)③ isDirectory()  判断是否为目录
                (**)④ isFile()      判断是否为文件*/
        File  file2 = new File("d:\\1\\5.txt");
//        System.out.println(file2.isFile());

//        lastModified()最后一次修改时间
//        System.out.println(file2.lastModified());
//        Date  date = new Date(file2.lastModified());
//        System.out.println(new SimpleDateFormat("yyyy/MM/dd E HH:mm:ss").format(date));

//             ⑤ length() 文件的长度
        System.out.println(file2.length());
    }
}

文件遍历的方法

1.list()/listFiles()/listFiles(FileFilter filter) 遍历目录

注意：

② 不包括目录本身。

③ 如果对象本身是文件，此时，该方法返回值为null需要进行判断是否为null再进行遍历

代码

package com.demo;
import java.io.File;
/**
   1.list()/listFiles()/listFiles(FileFilter filter)  遍历目录
    注意：
       ① 当前目录下的所有直接子目录或子文件。
       ② 不包括目录本身。
       ③ 如果对象本身是文件，此时，该方法返回值为null需要进行判断是否为null再进行遍历


 */
public class 文件遍历的方法 {
    public static void main(String[] args) {
        File file = new File("d:\\1\\3.txt");
        File[] fs = file.listFiles();
        //需要进行判断 否则可能报空指针异常。
        if(fs!= null){
            for (File f : fs) {
                System.out.println(f);
            }
        }
    }
}

文件过滤器

1.FileFilter文件过滤器

boolean accept(File pathname) 如果返回值为true，可以通过，否则不能通过

代码

package com.demo;

import java.io.File;
import java.io.FileFilter;
import java.util.Arrays;

/**
   1.FileFilter文件过滤器
    boolean accept(File pathname) 如果返回值为true，可以通过，否则不能通过
 */
public class 文件过滤器 {
    public static void main(String[] args) {
        File file = new File("d:\\1");
        File[] cs = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".txt");
            }
        });
        System.out.println(Arrays.toString(cs));
    }
}

文件常用方法二

1.mkdir()/mkdirs() 创建目录 ,mkdir只支持父目录存在的情况下创建，而加s表示父目录可以不在。

2.renameTo(File dest) 重命名

在同一个目录下，相当于重命名，但是在不同的目录下，相当于剪切和重命名。

代码

package com.demo;

import java.io.File;

/**
  1.mkdir()/mkdirs() 创建目录 ,mkdir只支持父目录存在的情况下创建，而加s表示父目录可以不在。
  2.renameTo(File dest) 重命名
     在同一个目录下，相当于重命名，但是在不同的目录下，相当于剪切和重命名。
 */
public class File类常用方法一 {
    public static void main(String[] args) {
       /* File file = new File("d:\\1\\2\\3");
        file.mkdirs();*/
       File file1 = new File("d:\\1\\2\\5.txt");
       File file2 = new File("d:\\1\\2\\7.txt");
       File file3 = new File("d:\\1\\2\\3\\9.txt");
//       file1.renameTo(file2);
        file2.renameTo(file3);
    }
}

递归

概述

1.递归：

自己调用自己。

2.分类：

① 直接递归：在该方法中直接调用方法自身 . A->A

② 间接递归: 该方法调用了其它方法，在其它方法中，又调用该方法。

A–>B–>C–>A

3.递归注意事项：

递归必须有出口，否则会报StackOverflowError栈溢出异常。

例如：求和 1-10

f(n)

f(1) 1

f(2) ==>f(1)+2

f(3)===> f(2)+3

==> f(n) ==> f(n-1)+n

代码

package com.demo;
/**
   1.递归：
       自己调用自己。
   2.分类：
       ① 直接递归： 在该方法中直接调用方法自身 . A->A
       ② 间接递归:  该方法调用了其它方法，在其它方法中，又调用该方法。
                    A-->B-->C-->A
    3.递归注意事项：
          递归必须有出口，否则会报StackOverflowError栈溢出异常。
   例如：求和 1-10
    f(n)
    f(1) 1
   f(2) ==>f(1)+2
   f(3)===> f(2)+3
  ==> f(n) ==> f(n-1)+n
 */
public class 递归 {
    public static void main(String[] args) {
        System.out.println(getSum(5));
    }
    public static int getSum(int n){
        if(n==1){
            return 1;
        }
       return  getSum(n-1)+n;
    }
}

IO流

概述

IO流：计算机中数据的传输。

IO 输入input 输出output

IO流的分类：

1》方向：

输入流

输出流

2》数据类型：

字节流

字符流

四大基本流

字节输入流

字节输出流

字符输入流

字符输出流

字节输入流

概述

byte input

抽象父类：InputStream

子类： FileInputStream 文件字节输入流

构造方法：

FileInputStream(File file)

FileInputStream(String name)

常用方法

1》 read()从流中读取一个字节数据，返回值表示读取的字节，到达文件的末尾返回值为-1

2》 close() 关闭资源。

代码

package com.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
   1.字节输入流：
    ① 构造方法：
         FileInputStream(File file)
         FileInputStream(String name)
    ② 常用方法：
       1》 read()从流中读取一个字节数据，返回值表示读取的字节，到达文件的末尾 返回值为-1
       2》 close() 关闭资源。
 */
public class 字节输入流 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(new File("day22a\\1.txt"));
       /* int value = fis.read();
        System.out.println(value);
        value = fis.read();
        System.out.println(value);
        value = fis.read();
        System.out.println(value);
        value = fis.read();
        System.out.println(value);*/
        int value = 0;//表示要读取的字节的数值
        while ((value = fis.read())!= -1){
            System.out.print((char) value);
        }
        //关闭资源
        fis.close();
    }
}

read方法的使用

（***） 1.read() 读取一个字节，返回值为该字节数值，并且到达文件的末尾返回值为-1.

（***）2. read(byte[] b) 一次性读取最多b.length个数据，到达文件的末尾，返回值为-1

注意：

一般b的大小，是以1024整数倍的形式存在，也可以是别的值。

对于b中存储的元素值，如果b的空间不够，会覆盖原有数据。

b称为缓冲区小数组，用来一次性从输入流中进行读取。

3.read(byte[] b, int off, int len) 将最多len个数据读取到b中，到达文件的末尾，返回值为-1

4.字节数组转字符串的方法：

String(byte[] bytes, int offset, int length)

从offset位置开始，将length个字节进行转换

代码

package com.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

/**
 （***） 1.read() 读取一个字节，返回值为该字节数值，并且到达文件的末尾 返回值为-1.
 （***）2. read(byte[] b) 一次性读取最多b.length个数据，到达文件的末尾，返回值为-1
     注意：
       一般b的大小，是以1024整数倍的形式存在，也可以是别的值。
       对于b中存储的元素值，如果b的空间不够，会覆盖原有数据。
       b称为缓冲区小数组，用来一次性从输入流中进行读取。
 3.read(byte[] b, int off, int len)  将 最多len个数据读取到b中，到达文件的末尾，返回值为-1
 4.字节数组转字符串的方法：
 String(byte[] bytes, int offset, int length)
   从offset位置开始，将length个字节进行转换。
 */
public class Read方法 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(new File("day22a\\2.txt"));
        byte[] bt = new byte[1024];// 1个字节 8位  1024B = 1KB  M G T P
        /*int value = fis.read(bt);
        System.out.println(value);
        System.out.println(Arrays.toString(bt));
        //字节数组转字符串
        System.out.println(new String(bt,0,value));
        value = fis.read(bt);
        System.out.println(value);
        System.out.println(Arrays.toString(bt));
        System.out.println(new String(bt,0,value));*/
        /*int value = 0;
        while ((value = fis.read(bt))!=-1){
            System.out.println(new String(bt,0,value));
        }*/

//        3.read(byte[] b, int off, int len)  将 最多len个数据读取到b中，到达文件的末尾，返回值为-1
        int value1 = fis.read(bt, 1, 3);
        System.out.println(value1);
        System.out.println(Arrays.toString(bt));
        fis.close();
    }
}

Available方法

available() 剩余字节数,如果一次都没读取，就是该文件的长度，如果读取了，就是剩余没有读取的字节数。

代码

package com.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
   1.available() 剩余字节数,如果一次都没读取，就是该文件的长度，如果读取了，就是剩余没有读取的字节数。
 */
public class Available方法 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(new File("day22a\\2.txt"));
        System.out.println(fis.available());
        fis.read();
        System.out.println(fis.available());
        fis.read();
        System.out.println(fis.available());
    }
}

字节输出流

概述

OutputStream ：表示输出字节流的所有类的超类

子类：

FileOutputStream

细节

1.构造方法：

1》 FileOutputStream(File file)/FileOutputStream(File file, booleanappend)

注意：

字节输出流的文件找不到异常，指无法创建时，才会报该异常，否则，会自动创建或覆盖原文件。

其中第二个参数表示是否在末尾插入，如果为true表示从末尾开始插入，如果不写false表示从文件开头插入。

2》FileOutputStream(String name) /FileOutputStream(String name, booleanappend)

2.常用方法：

① write(int b) 将一个字节的内容写到文件中

② write(byte[] b) 将一个数组中的内容写到文件输出流中。

③ write(byte[] b, int off, int len) 将数组中的内容从off位置开始，写len个。

代码

package com.demo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
  1.构造方法：
       1》 FileOutputStream(File file)/FileOutputStream(File file, boolean append)
         注意：
              字节输出流的文件找不到异常，指无法创建时，才会报该异常，否则，会自动创建或覆盖原文件。
              其中第二个参数表示是否在末尾插入，如果为true表示从末尾开始插入，如果不写或false表示从文件开头插入。
       2》FileOutputStream(String name) /FileOutputStream(String name, boolean append)
  2.常用方法：
      ① write(int b) 将一个字节的内容写到文件中
      ② write(byte[] b) 将一个数组中的内容写到文件输出流中。
      ③ write(byte[] b, int off, int len) 将数组中的内容 从off位置开始，写len个。

 */
public class 字节输出流 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(new File("day22a\\6.txt")/*,true*/);
        fos.write(97);
        byte[] bt = {97,98,99,100};
        fos.write(bt);
        //输入字符串-->byte[]
        fos.write("今天天气很好".getBytes());
        byte[] bt1 = {101,102,103,104,105};
        fos.write(bt1,1,2);
        fos.close();
    }
}

文件复制

概念

一边进行输入一边进行输出的过程

输入：文件字节输入流

输出: 文件字节输出流

字节流可以进行操作的文件：

所有的文件，包括文本文件视频声音图片，但是对于文本文件这种，由于编码问题，建议字符流，减少乱码问题的产生。

代码

package com.demo;

import java.io.*;

/**
 一边进行输入一边进行输出的过程
 输入：文件字节输入流
 输出: 文件字节输出流
 字节流可以进行操作的文件：
       所有的文件，包括 文本文件 视频  声音 图片  ，但是对于文本文件这种，由于编码问题，建议字符流，减少乱码问题的产生。
 */
public class 文件复制操作 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(new File("day22b\\img\\1.jpg"));
        FileOutputStream fos= new FileOutputStream(new File("C:\\Users\\Administrator\\Desktop\\5.jpg"));
        int value = 0;
        byte[] bt = new byte[1024];
        while ((value = fis.read(bt))!=-1){
            fos.write(bt,0,value);
        }
        //关闭资源
        fis.close();
        fos.close();
    }
}

流的异常处理形式

1.6jdk的处理形式

try{

}catch(异常的数据类型异常的名称){

}finally{

}

代码

package com.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
     try{

     }catch(异常的数据类型 异常的名称){

     }finally{

     }
 */
public class Jdk1_6异常处理形式 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
           int  i = 5/0;
           fis = new FileInputStream(new File("day22b\\img\\1.jpg"));
           fos= new FileOutputStream(new File("C:\\Users\\Administrator\\Desktop\\5.jpg"));
           int value = 0;
           byte[] bt = new byte[1024];
           while ((value = fis.read(bt))!=-1){
               fos.write(bt,0,value);
           }
       }catch (IOException e){
            e.printStackTrace();
       }finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try {
                if (fos!= null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.7jdk流的异常处理

格式：

try(需要关闭的流){

}catch(异常的数据类型异常的名称){

}

注意：

① finally 如果有其它操作，仍然可以使用finally但是如果只是关流，可以直接写在try()里面。会自动关流。

② try后面的()必须放置实现了AutoCloseable接口的对象，才能够进行自动关流。

代码

package com.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
     try{

     }catch(异常的数据类型 异常的名称){

     }finally{

     }
 */
public class Jdk1_6异常处理形式 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
           int  i = 5/0;
           fis = new FileInputStream(new File("day22b\\img\\1.jpg"));
           fos= new FileOutputStream(new File("C:\\Users\\Administrator\\Desktop\\5.jpg"));
           int value = 0;
           byte[] bt = new byte[1024];
           while ((value = fis.read(bt))!=-1){
               fos.write(bt,0,value);
           }
       }catch (IOException e){
            e.printStackTrace();
       }finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try {
                if (fos!= null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

处理/功能流

概述

对基本流的一个功能的增强，称为处理流。

带有缓冲区的字节流，高效读写的流

BufferedInputStream 带有缓冲区的字节输入流

BufferedOutputStream 带有缓冲区的字节输出流

默认缓冲区的大小 8192个字节

构造方法

① BufferedInputStream(InputStream in)

② BufferedOutputStream(OutputStream out)

带有缓冲区的高效读写字节输出流

常用方法：

① flush() 刷新缓冲区

(***) 3.close方法与flush方法的区别：

① flush 刷新缓冲区，不会关闭流，后续还可以使用输出流。

② close方法表示关闭资源，会关闭输出流。但是在关闭输出流之前，调用flush方法刷新缓冲区。

代码

package com.demo;import java.io.*;public class 带有缓冲区的高效读写的字节流 {    public static void main(String[] args) throws IOException {        BufferedInputStream bis = new BufferedInputStream(new FileInputStream                (new File("day22b\\src\\com\\demo\\文件复制操作.java")));        int value = 0;        byte[] bt = new byte[1024];        while ((value = bis.read(bt))!= -1){            System.out.println(new String(bt,0,value));        }        bis.close();    }}

package com.demo;import java.io.*;/**  1.构造方法：   BufferedOutputStream(OutputStream out)  2.常用方法：      ① flush()  刷新缓冲区  (***) 3.close方法与flush方法的区别：       ① flush 刷新缓冲区，不会关闭流，后续还可以使用输出流。       ② close方法 表示关闭资源，会关闭输出流。但是在关闭输出流之前，调用flush方法 刷新缓冲区。 */public class 带有缓冲区的高效读写的字节输出流 {    public static void main(String[] args) throws IOException {        BufferedOutputStream br = new BufferedOutputStream(new FileOutputStream(new File("day22b\\1.txt")));        br.write(98);        br.write(97);        br.write(99);        br.flush();    }}

带有高效读写的文件复制

package com.demo;

import java.io.*;

public class 带有高效读写的文件复制 {
    public static void main(String[] args) {
        try(
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("day22b\\img\\1.jpg")));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("C:\\Users\\Administrator\\Desktop\\5.jpg")));

            ){
                int value = 0;
                byte[] bt = new byte[1024];
                while ((value = bis.read(bt))!=-1){
                    bos.write(bt,0,value);
                }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

字符流

概念

字符输入流： Reader

字符输出流： Writer

底层/实质：

字节流 + 编码

Reader 字符输入流

1.FileReader 文件字符输入流

2.构造方法：

FileReader(File file) /FileReader(String fileName)

3.常用方法：

read()

read(char[] c)

close()

代码

package com.demo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class 文件字符输入流 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader(new File("day22b\\src\\com\\demo\\文件复制操作.java"));
//        int value = fr.read();
//        System.out.println((char) value);
         int  value = 0;
         char[] c = new char[1024];
         while ((value = fr.read(c)) != -1){
//             System.out.print((char)value);
             System.out.println(new String(c,0,value));
         }
         fr.close();
    }
}

Writer字符输出流

1.FileWriter 文件字符输出流

2.构造方法：

FileWriter(File file) /FileWriter(File file, boolean append)

FileWriter(String fileName) /FileWriter(String fileName, boolean append)

3.常用方法：

write(String str)

write(char[] c,offset,len)

close()

flush()

代码

package com.demo;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class 文件字符输出流 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter(new File("day22b\\3.txt"));
        fw.append('a');
        fw.write("今天天气真好");
        fw.write(new char[]{'b','c','d'}, 0, 3);
        fw.close();
    }
}

高效读写的字符流

概述

BufferedReader 带有缓冲区的字符输入流：字符、数组和行的高效读取

BufferedWriter 带有缓冲区的字符输出流：提供单个字符、数组和字符串的高效写入

构造方法

BufferedReader(Reader in)

BufferedWriter(Writer out)

常用方法：

1.String readLine() 读取一行

2.newLine() 可以根据不同的平台实现换行

代码

package com.demo;

import java.io.*;

/**
    文件复制
 */
public class 高效读写的字符流 {
    public static void main(String[] args) {
        try(
                BufferedReader  br = new BufferedReader(new FileReader(new File("day23a\\src\\com\\homework\\Topic1.java")));
                BufferedWriter bw = new BufferedWriter(new FileWriter(new File("day23a\\T.java")));
        ){
                String msg = null;
                while ((msg = br.readLine())!=null){
                    bw.write(msg);
                    //换行
                    bw.newLine();
                }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

转换流

概述

1.编码与解码：

① 编码：根据编码表将字符存储在计算机中。将认识的转换成计算机中存储的。

② 编码表：规定。编码与解码的依据。

单字节： ASCII ISO-8859-1 不支持中文

两个字节： GBK ：中国国内。

多个字节：

Unicode ：utf-8 全世界统一编码。

③ 解码：根据编码表将存储在计算机中的数据值，转换成相应的字符。

④ 编码与解码时，要保证编码与解码使用相同的编码表，如果使用的不是同一个，会造成乱码

问题。

⑤ 解决乱码问题：

编码与解码使用的编码表一致。

2.转换流：

① InputStreamReader：实质：根据编码，将字节流转换成字符流。

1》构造方法：

InputStreamReader(InputStream in, Charset cs)

注意：

如果只有一个参数，采用平台默认编码，如果有两个参数，第二个参数表示编码。

② OutputStreamWriter：

1》构造方法：

OutputStreamWriter(OutputStream out, Charset cs)

3.转换流的作用：

① 可以将字节流转成字符流。

② 可以对字符流进行编码的指定。

代码

package com.demo;

import java.io.*;
import java.net.URLDecoder;
import java.net.URLEncoder;

/**
   1.编码与解码：
      ① 编码： 根据编码表将字符存储在计算机中。将认识的转换成计算机中存储的。
      ② 编码表： 规定。编码与解码的依据。
          单字节： ASCII  ISO-8859-1 不支持中文
           两个字节： GBK ：中国国内。
           多个字节：
                   Unicode ：utf-8 全世界统一编码。
      ③ 解码：根据编码表将存储在计算机中的数据值，转换成相应的字符。
      ④ 编码与解码时，要保证编码与解码使用相同的编码表，如果使用的不是同一个，会造成乱码问题。
      ⑤ 解决乱码问题：
            编码与解码使用的编码表一致。
   2.转换流：
     ① InputStreamReader： 实质：根据编码，将字节流转换成字符流。
       1》构造方法：
        InputStreamReader(InputStream in, Charset cs)
       注意：
          如果只有一个参数，采用平台默认编码，如果有两个参数，第二个参数表示编码。
 */
public class 转换流 {
    public static void main(String[] args) throws IOException {
//        FileReader fr = new FileReader(new File("day23a\\1.txt"));
        /*InputStreamReader fr = new InputStreamReader(new FileInputStream(new File("day23a\\1.txt")),"gbk");
        char[] c = new char[1024];
        int value = fr.read(c);
        System.out.println(new String(c,0,value));
        fr.close();*/
//         FileWriter  fw = new FileWriter(new File("day23a\\1.txt"));
        OutputStreamWriter fw = new OutputStreamWriter(new FileOutputStream(new File("day23a\\1.txt")),"gbk");
         fw.write("今天天气很好");
         fw.close();
       //URLEncoder HTML编码实用工具类
        /*String valueU = URLEncoder.encode("今天天气真好", "utf-8");
        String valueG = URLEncoder.encode("今天天气真好", "GBK");
        System.out.println(valueU);
        System.out.println(valueG);
        //URLDecoder HTML解码实用工具类
        String vU = URLDecoder.decode(valueU, "utf-8");
        String vU1 = URLDecoder.decode(valueU, "gbk");
        System.out.println(vU);
        System.out.println(vU1);*/

    }
}

其他流

概念

System.in –> InputStream 字节输入流

PrintStream/PrintWriter 打印字节/符流永远不会抛出 IOException

Scanner 扫描器

常用方法：返回字符串

next()

nextLine()

对象流

概念

1.程序运算的结果–》内存？–》存储在硬盘持久化 –》存储在文件上 IO流/ 数据库

2.通过IO流写入的内容都是字符串的形式。获取其中某些数据，比较麻烦。引入了对象流。

3.ObjectOutputStream:对象输出流/序列化流

4.构造方法：

① ObjectOutputStream(OutputStream out)

5.常用方法：

① writeObject(Object obj) 写入一个对象

6.注意：

① NotSerializableException 如果写入的类上没有实现 Serializable接口会报该异常。

② Serializable：序列化接口，类通过实现 java.io.Serializable 接口以启用其序列化功能

注意：

该接口没有任何方法，该接口主要是用来标识对象可以存储在计算机中。

7.ObjectInputStream：对象输入流/反序列化流

8.构造方法：

① ObjectInputStream(InputStream in)

9.常用方法：

① Object readObject() 读取一个对象，注意，返回值类型为Object.

代码

package com.demo;

import java.io.*;

/**
  1.ObjectOutputStream:对象输出流/序列化流
  2.构造方法：
    ① ObjectOutputStream(OutputStream out)
  3.常用方法：
    ① writeObject(Object obj)  写入一个对象
  4.注意：
    ① NotSerializableException 如果写入的类上没有实现 Serializable接口会报该异常。
    ②  Serializable：序列化接口，类通过实现 java.io.Serializable 接口以启用其序列化功能
       注意：
          该接口没有任何方法，该接口主要是用来标识对象可以存储在计算机中。
  5.ObjectInputStream：对象输入流/反序列化流
  6.构造方法：
    ① ObjectInputStream(InputStream in)
 7.常用方法：
    ① Object readObject()  读取一个对象，注意，返回值类型为Object.


 */
public class 对象输出流 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //写入
       /* ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("day23b\\1.txt")));
        oos.writeObject(new Person("zs", 19));
        oos.close();*/

       //读取
        ObjectInputStream  ois = new ObjectInputStream(new FileInputStream(new File("day23b\\1.txt")));
        Person value = (Person) ois.readObject();
        System.out.println(value);
        ois.close();
    }
}
//Serializable 标识对象可以存储在计算机中
class Person implements  Serializable{
    String name;
    int age;
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

对象流读写多个对象

package com.demo;

import java.io.*;

/**
   1.读写多个对象
   2.EOFException :当输入意外到达文件或流的末尾时，会报该异常
 */
public class 对象流读写多个对象 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
       /* ObjectOutputStream  oos = new ObjectOutputStream(new FileOutputStream(new File("day23b\\3.txt")));
        oos.writeObject(new Person("张三", 19));
        oos.writeObject(new Person("李四", 21));
        oos.writeObject(new Person("王五", 20));
        oos.close();*/
       ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("day23b\\3.txt")));
        Person value = (Person) ois.readObject();
        System.out.println(value);
        Person value1 = (Person) ois.readObject();
        System.out.println(value1);
        Person value2 = (Person) ois.readObject();
        System.out.println(value2);
        Person value3 = (Person) ois.readObject();
        System.out.println(value3);
    }
}

对象流存储集合

package com.demo;

import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;

/**
    1.存储集合
 */
public class 对象流存储集合 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*ObjectOutputStream  oos = new ObjectOutputStream(new FileOutputStream(new File("day23b\\5.txt")));
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三", 19));
        list.add(new Person("李四", 19));
        list.add(new Person("王五", 19));
        oos.writeObject(list);
        oos.close();*/
        //读
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("day23b\\5.txt")));
        ArrayList<Person> list = (ArrayList<Person>) ois.readObject();
        //遍历
        /*Iterator<Person> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }*/
        for (Person person : list) {
            System.out.println(person);
        }
        ois.close();
    }
}

Scanner细节问题

package com.demo;

import java.util.Scanner;

/**
  1.Scanner :
    ① next() 返回与分隔模式匹配的数据
    ② nextLine() 返回一行
  注意：
     在使用next、nextXXX 与 nextLine连用时，需要重新创建一个Scanner对象，保证数组中不存在数据。
 */
public class Scanner细节问题 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
//        String value = sc.next();
//        System.out.println(value);
        String value1 = sc.next();
         sc = new Scanner(System.in);
        String value2 = sc.nextLine();
        System.out.println(value1);
        System.out.println(value2);
    }
}

对象流的细节问题

概述

1.存的时候，对象流中存储的对象，必须是实现了序列化接口。如果，该对象的属性有没有实现序列化接口的，也必须实现。

否则会报NotSerializableException。

2.瞬时对象：只存在内存中的对象。

关键字：transient 表示该对象是瞬时对象。不会被持久化，不会被存储。

代码

package com.demo;

import java.io.*;

/**
  1.存的时候，对象流中存储的对象，必须是实现了序列化接口。如果，该对象的属性有没有实现序列化接口的，也必须实现。
    否则会报NotSerializableException。
  2.瞬时对象 ：只存在内存中的对象。
    关键字：transient 表示该对象是瞬时对象。不会被持久化，不会被存储。

 */
public class 对象流的细节问题 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("day23b\\7.txt")));
        oos.writeObject(new B(15, new A()));
        oos.close();*/
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("day23b\\7.txt")));
        B value = (B) ois.readObject();
        System.out.println(value);
    }
}
//作为需要持久化的对象的属性，也需要被序列化。
class A implements  Serializable{
    int k;
}
class B implements Serializable {
    int m;
   /* transient*/  A a;//瞬时对象 可以通过关键字 transient来表示，不会被持久化

    @Override
    public String toString() {
        return "B{" +
                "m=" + m +
                ", a=" + a +
                '}';
    }

    public B() {
    }

    public B(int m, A a) {
        this.m = m;
        this.a = a;
    }
}

序列化版本号

概述

1.serialVersionUID:序列化版本号:向下兼容。

private static final long serialVersionUID = 1l; 手动默认一般设置为1l

2.InvalidClassException：失效的类异常，当使用对象流写入或读取的类的模板文件不一致时，会报该异常。

代码

package com.demo;

import java.io.*;

/**
  1.步骤：
     ① 写--》writeObject()
     ② 读--》 readObject()
 2.InvalidClassException :失效的类异常，该异常由对象流报出。
      当写入的对象的类，在写入后被修改，读取时，会报该异常。
 3.serialVersionUID：序列化版本号。作用：向下兼容类。
  ① 默认 private static final long serialVersionUID = 1l

 */
public class 对象流序列化的细节问题1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("day23b\\9.txt")));
        oos.writeObject(new Student("张三", 19));
        oos.close();*/
       ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("day23b\\9.txt")));
        Student stu = (Student) ois.readObject();
        System.out.println(stu);
        ois.close();
    }
}
class Student implements Serializable {
    private static final long serialVersionUID = 4496801413692333247L;
    //    private static final long serialVersionUID = 1l;
    String name;
    int age;
    String stuNo;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name, int age, String stuNo) {
        this.name = name;
        this.age = age;
        this.stuNo = stuNo;
    }
}

属性集

概念

Properties：

表示了一个持久的属性集。可保存在流中或从流中加载，

属性列表中每个键及其对应值都是一个字符串。

实质：

Map集合的一个子类。继承自HashTable。

构造方法

Properties()

常用方法

① setProperty(String key, String value) 添加键值对

② list(PrintStream/PrintWriter out)/store(OutputStream/Writer out, String

comments)

（***）③ load(InputStream/Reader inStream) 加载属性集到流中

（***） ④ getProperty(String key) 通过key获取值

代码

package com.demo;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
  1. 属性集：
  2.常用方法：
     ① setProperty(String key, String value) 添加键值对
     ② list(PrintStream/PrintWriter out)/store(OutputStream/Writer out, String comments)
   （***）③ load(InputStream/Reader inStream) 加载属性集到流中
  （***） ④ getProperty(String key) 通过key获取值

 JDBC:java数据库连接
 */
public class Properties属性集 {
    public static void main(String[] args) throws IOException {
        Properties prp = new Properties();
        /*prp.setProperty("name", "张三");
        prp.setProperty("psw", "123");
        //prp.list(System.out);
        prp.store(new FileWriter(new File("day24a\\JDBC.properties")), "this is java");*/


        prp.load(new FileReader(new File("day24a\\JDBC.properties")));
        System.out.println(prp.getProperty("name"));
        System.out.println(prp.getProperty("psw"));
    }
}