Java第十八天~第十九天/11.25~11.26

一、文件字节输入流

* 读数据的两种方式:*
* 1)public int read():一次读取一个字节
* 2)public int read(byte[] b):一次读取一个字节数组
* 返回的是实际读取的字节数,使用文件输入流一次读取一个字节数组

1、public int read():一次读取一个字节

package org.westos_字节文件输入输出流;

import java.io.FileInputStream;
import java.io.IOException;
/**
 * 文件的字节输入流
 *      public FileInputStream(String name)
 * @author 小鑫
 */
public class FileInputStreamDemo {

    public static void main(String[] args) throws IOException {
        //创建文件输入流对象
        FileInputStream fis = new FileInputStream("a.txt");

        //1)public int read():一次读取一个字节
        //模板代码
        int by=0;
        while((by=fis.read())!=-1){
            System.out.print((char)by);
        }

        //释放资源
        fis.close();
    }
}

2、public int read(byte[] b):一次读取一个字节数组

package org.westos_字节文件输入输出流;

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo2 {

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

        //封装数据源
        FileInputStream fis = new FileInputStream("a.txt");

        //2)public int read(byte[] b):一次读取一个字节数组
        //模板代码
        byte[] bys=new byte[1024];
        int len=0;
        while((len=fis.read(bys))!=-1){
            System.out.println(new String(bys, 0, len));
        }
        //释放资源
        fis.close();
    }
}

3、练习

package org.westos_字节文件输入输出流;

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

/**
 * E盘下有照片艾弗森.jpg文件，将他图片内容复制到当前项目下的答案.jpg
 * 分析：
 *    数据源--->E:\\艾弗森.jpg--->FileInputStream
 *    目的地--->答案.jpg--->FileOutputStream
 * @author 小鑫
 *
 */
public class CopyDemo {

    public static void main(String[] args) throws IOException {
        //封装数据源
        FileInputStream fis = new FileInputStream("E:\\艾弗森.jpg");
        //封装目的地
        FileOutputStream fos = new FileOutputStream("答案.jpg");

        /*//读写操作
        int by=0;
        while((by=fis.read())!=-1){
            fos.write(by);
        }*/

        byte[] bys=new byte[1024];
        int len=0;
        while((len=fis.read(bys))!=-1){
            fos.write(bys, 0, len);
        }
        //释放资源
        fis.close();
        fos.close();
    }
}

4、练习

package org.westos_字节文件输入输出流;

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

/**
 * 需求:在当前项目下有一个:a.txt文件
 *      将a.txt文件的内容赋值到b.txt文件中
 * 
 * 分析:
 * 1)数据源:a.txt------->FileInputStream:输入流------->读数据
 * 2)目的地:b.txt------->FileOutputStream:输出流------>写数据
 * @author 小鑫
 *
 */
public class CopyFileDemo {

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

        //封装数据源
        //创建一个文件字节流对象
        FileInputStream fis = new FileInputStream("a.txt");
        //带盘符文件
        //FileInputStream fis = new FileInputStream("C:\\a.txt");
        //封装目的地
        //创建文件输出流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
        //带盘符文件
        //FileOutputStream fos = new FileOutputStream("D:\\b.txt");

        /*//一次读取一个字节
        int by=0;
        while((by=fis.read())!=-1){
            fos.write(by);
        }*/

        byte[] bys=new byte[1024];
        int len=0;
        while((len=fis.read(bys))!=-1){
            fos.write(bys, 0, len);
        }
        //释放资源
        fis.close();
        fos.close();
    }
}

二、字节缓冲流

1、为什么字节缓冲流不能直接针对文件进行操作呢?
* 缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所以缓冲流不能直接对文件操作

2、flush()和close()方法的区别?
* flush():刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.
* close():关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的!
3、字节缓冲输出流
由于字节数组比一次读取一个字节更快,从而引出类更高效的一种流:
字节缓冲输出流:BufferedOutputStream
构造方式: public BufferedOutputStream(OutputStreamout):默认缓冲区大小(默认缓冲大小已经足够大了)

package org.westos_字节缓冲输入输出流;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo {

    public static void main(String[] args) throws IOException {
        // 创建字节缓冲输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("bos.txt"));
        //写数据
        bos.write(97);
        //刷新该缓冲区的流
        bos.flush();//迫使将这写字节强制输出流中
        bos.write(98);
        bos.close();
        //bos.write(99);
        //bos.flush();//java.io.IOException: Stream Closed
    }
}

4、字节缓冲输入流
字节缓冲输入流:BufferedInputStream
* 构造方法:
* BufferedInputStream(InputStream in) :指定默认缓冲区大小创建字节缓冲输入流对象

package org.westos_字节缓冲输入输出流;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo {

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

        //创建字节缓冲输入流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
        /*//一次读取一个字节
        int by=0;
        while((by=bis.read())!=-1){
            System.out.print((char)by);
        }*/

        //一次读取一个字节数组
        byte[] bys=new byte[1024];
        int len=0;
        while((len=bis.read(bys))!=-1){
            System.out.println(new String(bys, 0, len));
        }
        //释放资源
        bis.close();
    }
}

5、字节缓冲流复制视频

package org.westos_字节缓冲输入输出流;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 对于图片文件,音频文件,视频文件,优先采用字节缓冲输入流(高效流)一次读取一个字节数组!
 * 复制e:\\abc.mp4文件---->当前项目下的Copy.mp4文件
 * @author 小鑫
 *
 */
public class CopyFileDemo {

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

        //基本字节流一次读取一个字节
        //method1("E:\\abc.mp4","Copy.mp4");
        //基本字节流一次读取一个字节数组
        //method2("E:\\abc.mp4","Copy.mp4");
        //字节缓冲输入流(高效字节流)一次读取一个字节
        //method3("E:\\abc.mp4","Copy.mp4");
        //字节缓冲输入流一次读取一个字节数组
        method4("E:\\abc.mp4","Copy.mp4");

    }

    //字节缓冲输入流一次读取一个字节数组
    private static void method4(String srcString, String destString) throws IOException {

        //封装数据源
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));
        //封装目的地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString));
        //字节缓冲输入流一次读取一个字节数组
        byte[] bys=new byte[1024];
        int len=0;
        while((len=bis.read(bys))!=-1){
            bos.write(bys, 0, len);
        }
        //释放资源
        bis.close();
        bos.close();

    }

    //字符缓冲输入流一次读取一个字节
    private static void method3(String srcString, String destString) throws IOException {

        //封装数据源
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));
        //封装目的地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString));
        //字符缓冲输入流一次读取一个字节
        int by=0;
        while((by=bis.read())!=-1){
            bos.write(by);
        }
        //释放资源
        bis.close();
        bos.close();
    }

    // 基本字节流一次读一个字节数组
    private static void method2(String srcString, String destString) throws IOException {

        // 封装数据源
        FileInputStream fis = new FileInputStream(srcString);
        // 封装目的地
        FileOutputStream fos = new FileOutputStream(destString);
        // 基本字节流一次读一个字节数组
        byte[] bys=new byte[1024];
        int len=0;
        while((len=fis.read(bys))!=-1){
            fos.write(bys, 0, len);
        }
        //释放资源
        fis.close();
        fos.close();

    }

    //基本字节流一次读一个字节
    private static void method1(String srcString, String destString) throws IOException {
        //封装数据源
        FileInputStream fis = new FileInputStream(srcString);
        //封装目的地
        FileOutputStream fos = new FileOutputStream(destString);
        //基本字节流一次读一个字节
        int by=0;
        while((by=fis.read())!=-1){
            fos.write(by);
        }
        //释放资源
        fis.close();
        fos.close();
    }
}

6、计算机如何识别中文

package org.westos_字节缓冲输入输出流;

import java.util.Arrays;

/**
 * 计算机是如何识别中文的?
 *      1)每个中文左边对应的字节一定是负数
 *      2)GBK格式:右边的字节可以中正数,可以是0,可以是负数
 * @author 小鑫
 *
 */
public class StringDemo {

    public static void main(String[] args) {
        //定义一个字符串
        String s1="abcde";
        byte[] bys1 = s1.getBytes();

        String s2="你好世界";
        byte[] bys2 = s2.getBytes();
        System.out.println(bys1);//[B@33a17727
        System.out.println(Arrays.toString(bys1));
        //[97, 98, 99, 100, 101]
        System.out.println(bys2);//[B@3654919e
        System.out.println(Arrays.toString(bys2));
        //[-60, -29, -70, -61, -54, -64, -67, -25]
    }
}

三、字符输出输入流

1、 字符输出流:Writer:是一个抽象类
* 使用的是该抽象类的子类:OutputStreamWriter——>字符转换流:可以将字节输出流转换字符流
* public OutputStreamWriter(OutputStream out,Charset cs):创建一字符输出转换流对象,指定编码格式
* 字节输出流+编码格式—->字符输出流

package org.westos_字符输出输入流;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/**
 *      编码格式:使用平台的默认编辑集进行编码:GBK ,
 *      public OutputStreamWriter(OutputStream out);
 *  打开记事本时，要保证记事本编码集格式与字符输出流编码集格式一致，否则乱码。
 * @author 小鑫
 *
 */
public class OutputStreamWriterDemo {

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

        //创建一个字符输出流对象
        //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));//平台默认编码集为"GBK"格式
        //写数据
        osw.write("你好世界");
        //释放资源
        osw.close();
    }
}

2、字符输入流

package org.westos_字符输出输入流;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 字符输入流:字节输入流+编码格式(默认GBK)--->解码
 * public InputStreamReader(InputStream in,charset sc) ;
 * 
 * @author 小鑫
 * 
 */
public class InputStreamReaderDemo {

    public static void main(String[] args) throws IOException {
        // 创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "osw.txt"), "GBK");
        //一次读取一个字符
        char[] ch=new char[1024];
        int len=0;
        while((len=isr.read(ch))!=-1){
            System.out.println(new String(ch, 0, len));
        }
        //释放资源
        isr.close();

    }
}

3、字符输出流写数据的方法

package org.westos_字符输出输入流;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 关于字符输出流写数据的方法: 
 *    public void write(int c):写单个字符 public void write(char[]cbuf):写一个字符数组 
 *    public void write(char[] cbuf):写一个字符数组
 *    public abstract void write(char[] cbuf,int off,intlen):写入字符数组的一部分
 *    public void write(String str):写字符串 
 *    public void write(Stringstr, int off,int len):写字符串的一部分
 * @author 小鑫
 * 
 */
public class OutputStreamWriterDemo2 {

    public static void main(String[] args) throws IOException {
        // 创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "osw.txt"));
        //public void write(int c):写单个字符
        osw.write(97);
        osw.write('a');

        //public void write(char[] cbuf):写一个字符数组
        char[] chs={'a','b','c','d','e'};
        osw.write(chs);
        //public abstract void write(char[] cbuf,int off,intlen):写入字符数组的一部分
        osw.write(chs, 1, 3);

        //public void write(String str):写字符串
        String str="你好世界";
        osw.write(str);
        //public void write(String str, int off,int len):写字符串的一部分
        osw.write(str, 0, 2);
        //刷新该流
        osw.flush();
        //释放资源
        osw.close();
        //osw.write('x');//已经关闭流，继续写入会报以下异常
        //java.io.IOException: Stream closed
    }

}

4、字符输入流读数据的方式

package org.westos_字符输出输入流;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 字符输入流读数据的方式: public int read():一次读取一个字符 public int read(char[]
 * chs):一次读取一个字符数组
 * 
 * @author 小鑫
 * 
 */
public class InputStreamReaderDemo2 {

    public static void main(String[] args) throws IOException {
        // 创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "osw.txt"));

        /*//一次读取一个字符
        int ch=0;
        while((ch=isr.read())!=-1){
            System.out.print((char)ch);
        }
        isr.close();*/

        //一次读取一个字符数组
        char[] chs=new char[1024];
        int len=0;
        while((len=isr.read(chs))!=-1){
            System.out.println(new String(chs, 0, len));
        }
        //释放资源
        isr.close();
    }
}

5、字符流的便捷类：FileWriter和FileReader

package org.westos_字符输出输入流;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 使用字符转化流进行操作数据的时候：字节流+编码格式
 * 书写名称较长，Java提供了简单的类：便捷类
 *    字符转换输出流：OutputStreamWriter--->FileWriter
 *                  FileWriter(String fileName)
 *    字符转换输入流：InputStreamReader--->FileReader
 *                  FileReader(String fileName) 
 * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 使用字符流进行读写操作
 * 分析：
 *     数据源：a.txt--->字符流读数据：InputStreamReader---->便捷类：FileReader
 *     目的地：b.txt--->字符流写数据：OutputStreamWriter--->便捷类：FileWriter            
 * @author 小鑫
 *
 */
public class FileCopyDemo {

    public static void main(String[] args) throws IOException {
        //封装数据源
        FileReader fr = new FileReader("a.txt");
        //封装目的地
        FileWriter fw = new FileWriter("b.txt");
        //一次读取一个字符数组
        char[] chs=new char[1024];
        int len=0;
        while((len=fr.read(chs))!=-1){
            fw.write(chs, 0, len);
        }
        //释放资源
        fr.close();
        fw.close();
    }
}

四、编码和解码

编码:就是能看懂的字符串转换成看不懂的字节数组
* public byte[] getBytes(Charset charset):将字符串转换成字节数组,指定编码格式(字符集)
解码:就是将看不懂的字节数组—–>能看懂的:将字节数组—>字符串
* public String(byte[] bytes, Charset charset):
* 通过使用指定的 编码格式 解码指定的 byte数组，构造一个新的 String
编码和解码必须保持一致

package org.westos_编码和解码;

import java.io.IOException;
import java.util.Arrays;

/**
 * 编码:就是能看懂的字符串转换成看不懂的字节数组
 *      public byte[] getBytes(Charset charset):将字符串转换成字节数组,指定编码格式(字符集)
 * 解码:就是将看不懂的字节数组----->能看懂的:将字节数组--->字符串
 *      public String(byte[] bytes, Charset charset):
 *      通过使用指定的 编码格式 解码指定的 byte数组，构造一个新的 String
 * 注意事项：
 *    1）编码和解码必须保持一致
 *    2）当不给出编码解码格式时，默认GBK格式。
 * @author 小鑫
 *
 */
public class StringDemo {

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

        String s="你好世界";
        //编码
        //public byte[] getBytes(Charset charset)
        byte[] bys = s.getBytes("GBK");
        System.out.println(bys);//[B@2d95bbec
        System.out.println(Arrays.toString(bys));
        //[-60, -29, -70, -61, -54, -64, -67, -25]

        //解码
        //public String(byte[] bytes, Charset charset):
        String string = new String(bys, "GBK");
        System.out.println(string);//你好世界


    }
}

五、字符缓冲输入输出流

*字符流为了提高读写速度,Java就提供了一个字符缓冲流的类:
BufferedReader:字符缓冲输入流
BufferedWriter:字符缓冲输出流
1、字符缓冲输出流

package org.westos_字符缓冲输入输出流;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小，或者接受默认的大小
 * 
 * 构造方式: public BufferedWriter(Writer out):创建默认缓冲区大小的一个字符缓冲输出流
 * 
 * @author 小鑫
 * 
 */
public class BufferedWriterDemo {

    public static void main(String[] args) throws IOException {
        // 创建字符缓冲输出流对象
        /*BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream("bw.txt")));*/
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
        //写数据
        bw.write("hello");
        bw.write("world");
        bw.write("Java");
        bw.write("你好世界");
        //刷新流
        bw.flush();
        //释放资源
        bw.close();
    }
}

2、字符缓冲输入流

package org.westos_字符缓冲输入输出流;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 字符缓冲输入流：BufferedReader 构造方式：BufferedReader(Reader in) :创建默认缓冲大小
 * 
 * @author 小鑫
 * 
 */
public class BufferedReaderDemo {

    public static void main(String[] args) throws IOException {
        // 创建字符缓冲输入流对象
        /*BufferedReader br = new BufferedReader(new InputStreamReader(
                new FileInputStream("bw.txt")));*/
        FileReader fr = new FileReader("bw.txt");

        /*//一次读取一个字符
        int ch=0;
        while((ch=fr.read())!=-1){
            System.out.print((char)ch);
            //helloworldJava你好世界
        }
        fr.close();*/

        //一次读取一个字符数组
        char[] chs=new char[1024];
        int len=0;
        while((len=fr.read(chs))!=-1){
            System.out.println(new String(chs, 0, len));
            //helloworldJava你好世界
        }
        //释放资源
        fr.close();
    }
}

3、字符缓冲的特有功能
* BufferedWriter: public void newLine():写入一个换行符号
* BufferReader:public String readLine():一次读取一行

package org.westos_字符缓冲输入输出流;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 关于字符缓冲的特有功能: 
 * BufferedWriter: public void newLine():写入一个换行符号 
 * BufferReader:public String readLine():一次读取一行
 * 
 * 
 * @author 小鑫
 * 
 */
public class BufferedDemo {

    public static void main(String[] args) throws IOException {
        writer();
        read();
    }

    //读数据
    private static void read() throws IOException {
        //创新字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
        //当全部内容读完之后返回null
        String line=null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        //释放资源
        br.close();
    }

    //写数据
    private static void writer() throws IOException {
        // 创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
        //写数据
        for(int i=1;i<=10;i++){
            bw.write("helloworld"+i);
            //原来的换行符
            //bw.write("\r\n");
            //BufferedWriter: public void newLine():写入一个换行符号 
            bw.newLine();
            //刷新流
            bw.flush();
        }
        //释放资源
        bw.close();
    }
}

4、标准输出输入流：System.in和System.out

package org.westos_字符缓冲输入输出流;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class SystemDemo {

    public static void main(String[] args) throws IOException {
        //systemIn();
        systemOut();
    }

    private static void systemOut() throws IOException {
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        bw.write("hello world");
        bw.flush();
        bw.close();

    }

    private static void systemIn() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一个整数");
        String line = br.readLine();
        int number = Integer.parseInt(line);
        System.out.println("您输入的整数是："+number);
    }
}

5、方法递归
递归:三个条件:
* 1)定义一个方法
* 2)必须有规律
* 3)要有出口条件

package org.westos_字符缓冲输入输出流;
/**
 * 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
 * 假如兔子都不死，问第二十个月的兔子对数为多少？
 * 找规律：
 *     第一个月：1
 *     第二个月：1
 *     第三个月：2
 *     第四个月：3
 *     第五个月：5
 *     第六个月：8
 * 规律：从第三个月起：每个月的兔子数量等于前两个月兔子数量之和
 * 
 * 把每个月相邻兔子对数数据当做:a,b
 * 第一个月和第二个月相邻的数据:a=1,b=1
 * 第二个月和第三个月相邻 的数据:a=1,b=2
 * 第三个月和第四个月相邻的数据:a=2,b=3
 * 第四个月和第五个月相邻的数据:a=3,b=5
 * 下一次的a是上一次的b,下一次的b是上一次的a+b
 * @author 小鑫
 *
 */
public class DiGuiDemo {

    public static void main(String[] args) {
        //动态初始化定义一个数组
        int[] arr=new int[20];
        arr[0]=1;
        arr[1]=1;
        //arr[2]=arr[0]+arr[1];
        for(int x=2;x<arr.length;x++){
            arr[x]=arr[x-1]+arr[x-2];
        }
        System.out.println("第二十个月的兔子数量是:"+arr[19]);//第二十个月的兔子数量是：6765
        System.out.println("第二十个月的兔子数量是:"+fib(20));//第二十个月的兔子数量是:6765
    }
    /**
     * 
     * @param n
     *    表示月份
     * @return
     *    返回的是兔子的对数
     */
    //递归：方法调用方法，直到满足出口条件
    private static int fib(int n){
        if(n==1 || n==2){//出口条件
            return 1;
        }else{
            //规律:第一个月和第二个月兔子的对数1:从第三个月开始,每一个月兔子对数的数据是前两个月之和
            return fib(n-1)+fib(n-2);
        }
    }
}

day19

一、数据流

针对Java基本数据类型的数据进行读写操作
DataOutputStream和DataInputStream

package org.westos_01_数据流;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * DataOutputStream和DataInputStream
 * 都属于数据流:可以针对Java基本数据类型的数据进行读写操作
 * 
 * DataOutputStream构造方法
 *      public DataOutputStream(OutputStream out)
 * DataInputStream构造方法
 *      public DateInputStream(InputStream in)
 * @author 小鑫
 *
 */
public class DataStreamDemo {

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

        //writer();
        //写进去的数据我们看不懂，需要读出来
        read();

    }

    private static void read() throws IOException {
        //创建数据输入流对象
        DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));
        //读数据
        byte b = dis.readByte();
        int i = dis.readInt();
        short s = dis.readShort();
        long l = dis.readLong();
        char ch = dis.readChar();
        boolean flag = dis.readBoolean();
        double d = dis.readDouble();
        float f = dis.readFloat();
        //释放资源
        dis.close();
        System.out.println(b);
        System.out.println(i);
        System.out.println(s);
        System.out.println(l);
        System.out.println(ch);
        System.out.println(flag);
        System.out.println(d);
        System.out.println(f);

    }

    private static void writer() throws FileNotFoundException, IOException {
        //创建数据输出流对象
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
        //写数据
        dos.writeByte(100);
        dos.writeInt(1000);
        dos.writeShort(10);
        dos.writeLong(100000L);
        dos.writeChar('A');
        dos.writeBoolean(true);
        dos.writeDouble(12.34);
        dos.writeFloat(12.34F);
        //释放资源
        dos.close();
    }
}

二、内存操作流

针对内存的数据进行操作的,程序一结束,这些内存中的数据就消失掉了!
特点:针对小文件进行操作!
该流对象可以不用关闭资源
ByteArrayInputStream和ByteArrayOutStream(重点)

package org.westos_02_内存操作流;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * ByteArrayOutputStream:内存操作输出流
 *      构造方法：public ByteArrayOutputStream():创建默认的缓冲区大小的内存操作输出流(单位是字节)
 *      成员方法:
 *          public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
 *          void reset():重置内存操作输出流
 * ByteArrayInputStream:内存操作输入流:
 *      构造方法：public ByteArrayInputStream(byte[] buf):参数数一个字节数组(缓冲数组)
 * @author 小鑫
 */
public class ByteArrayStreamDemo {

    public static void main(String[] args) throws IOException {
        //创建内存操作输出流对象
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //写数据
        for(int x=1;x<=5;x++){
            baos.write(("hello"+x).getBytes());
        }
        //关闭资源
        //查看源码，没有具体的关闭流对象，所以此处可以不用关闭流对象
        //public void close() throws IOException {}
        //baos.close();

        //将内存操作输出流对象转换成字节数组
        byte[] array = baos.toByteArray();
        //创建内存操作输入流对象
        ByteArrayInputStream bais = new ByteArrayInputStream(array);
        //一次读取一个字节
        int by=0;
        while((by=bais.read())!=-1){
            System.out.print((char)by);
            //hello1hello2hello3hello4hello5
        }
    }
}

三、打印流

打印流:
* 字节打印流:PrintStream
* 字符打印流:PrintWriter
1、字符打印流

package org.westos_03_打印流;

import java.io.IOException;
import java.io.PrintWriter;

/**
 *  打印流特点:
 *      1)在复制文件的,打印流不能操作数据源,只能操作目的地的数据(只能操作输出数据)
 *      2)打印流可以有自动刷新的功能
 *      3)打印流可以直接针对文本文件进行操作:
 *          什么情况下是直接可以针对文本文件进行操作?
 *          查API的时候,看流中构造方法,只要构造方法的参数有File类或者是String类型,都可以针对文本文件进行操作
 *          FileInputStream
 *          FileOutputStream
 *          FileReader
 *          FileWriter
 *          
 * PrintWriter:
 *      构造方法:
 *          public PrintWriter(String fileName)
 * @author 小鑫
 */
public class PrintWriterDemo {

    public static void main(String[] args) throws IOException {
        //创建字符打印流对象
        PrintWriter pw = new PrintWriter("pw.txt");
        //写数据
        pw.write("hello");
        pw.write("world");
        pw.write("你好世界");

        //刷新流
        pw.flush();
        //关闭流
        pw.close();

        //记事本内容：helloworld你好世界
    }
}

2、PrintWriter的自动刷新功能
public PrintWriter(Writer out,boolean autoFlush)
* 第二个参数指定为true,则启动自动刷新

package org.westos_03_打印流;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * PrintWriter:有自动刷新功能:
 *  public PrintWriter(Writer out,boolean autoFlush)
 *      第二个参数指定为true,则启动自动刷新
 *      PrintWriter pw = new PrintWriter(new FileWriter("pw.txt"),true) ;
 * 加入自动刷新功能并且在写数据的时候,使用println():换行
 *      
 * println("hello")相当于:
 *      pw.write("") ;
 *      pw.newLine() ;
 *      pw.flush() ;
 * @author 小鑫
 *
 */
public class PrintWriterDemo2 {

    public static void main(String[] args) throws IOException {
        //创建字符打印流对象
        PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"),true);
        //写数据
        //public void println(String x):打印字符串,并且终止该行
        pw.println("hello");
        pw.println("world");
        pw.println("你好世界");
        //关闭流对象
        pw.close();

        /*记事本内容：
          hello
          world
             你好世界*/
    }
}

3、复制文件
readLine()和println()

package org.westos_03_打印流;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * 复制文件 需求:将当前项目下的ByteArrayStreamDemo.java中的内容复制到当前项目下Copy.java文件中 分析：
 * 数据源：ByteArrayStreamDemo.java--->BufferReader--->readLine()
 * 目的地：Copy.java--->BufferedWrier--->写数据--->println()
 * 
 * @author 小鑫
 * 
 */
public class CopyFileDemo {

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

         /*// 封装数据源 
         BufferedReader br = new BufferedReader(new FileReader(
                "ByteArrayStreamDemo.java"));
         // 封装目的地
         BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
         //使用BufferedReaderde的独有功能
         String line=null;
         while((line=br.readLine())!=null){ 
         //写数据 
         bw.write(line);
         bw.newLine(); 
         bw.flush(); 
         } 
         //释放资源
         br.close(); 
         bw.close();*/


        // 封住数据源
        BufferedReader br = new BufferedReader(new FileReader(
                "ByteArrayStreamDemo.java"));
        // 封装目的地
        PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
        //读数据
        String line=null;
        while((line=br.readLine())!=null){
            pw.println(line);
        }
        //关闭资源
        br.close();
        pw.close();
    }
}

四、标准输入输出流

1、System类中有两个字段:
* in:—–>InputStream is = System.in ;
* out—–>PrintStream ps = System.out ;

package org.westos_04_标准输入输出流;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 标准输入和输出流
 * System类中有两个字段:
 *          in:----->InputStream is = System.in ; 
 *          out----->PrintStream ps = System.out ;
 * 
 * @author 小鑫
 *
 */
public class SystemOutDemo {

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

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        //写数据
        bw.write("hello");
        bw.newLine();
        bw.write("world");
        bw.newLine();
        bw.write("你好世界");
        bw.newLine();
        bw.flush();
        bw.close();
    }
}

2、键盘录入数据的两种方式

package org.westos_04_标准输入输出流;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 键盘录入的两种方式 1)Scanner类 Scanner sc = new Scanner(System.in) ; 2)使用IO流的形式进行录入数据
 * BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
 * 
 * @author 小鑫
 * 
 */
public class SystemInDemo {

    public static void main(String[] args) throws IOException {
        /*
         * //创建一个字节输入流对象 InputStream is=System.in;
         * //BufferedReader字符缓冲输入流只能对字符流进行操作 InputStreamReader isr = new
         * InputStreamReader(is); BufferedReader br = new BufferedReader(isr);
         */

        // 另一种录入数据的方式
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请您输入一个字符串：");
        String line = br.readLine();
        System.out.println("您输入的字符串是："+line);
        System.out.println("请您输入一个整数：");
        String s = br.readLine();
        int n = Integer.parseInt(s);
        System.out.println("您输入的整数是:"+n);
        /*请您输入一个字符串：
        hello
        您输入的字符串是：hello
        请您输入一个整数：
        24
        您输入的整数是:24*/

    }
}

五、随机访问流

RandomAccessFile：随机访问流:
此类的实例支持对随机访问文件的读取和写入，不是实际意义上的流,因为它继承自Object类

package org.westos_05_随机访问流;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 常用的构造方法:
 *      public RandomAccessFile(String name, String mode)
        参数一:指定该文件的路径
        参数二:指定的一种模式:常用的模式:"rw",这种模式是可以读也可以写
 * @author 小鑫
 *
 */
public class RandomAccessFileDemo {

    public static void main(String[] args) throws IOException {
        //write();
        read();
    }

    private static void read() throws IOException {
        //创建随机访问流对象
        RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
        byte b = raf.readByte();
        System.out.println(b);//100
        //public long getFilePointer():返回此文件中的当前偏移量。 文件开头的偏移量(以字节为单位)
        System.out.println(raf.getFilePointer());//1

        char ch = raf.readChar();
        System.out.println(ch);//a

        String utf = raf.readUTF();
        System.out.println(utf);//你好世界
    }

    private static void write() throws FileNotFoundException, IOException {
        //创建随机访问流对象
        RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
        //写数据
        raf.writeByte(100);
        raf.writeChar('a');
        raf.writeUTF("你好世界");
        raf.close();
    }
}

六、合并流

1、合并复制两个文件

package org.westos_06_合并流;

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;

/**
 * SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联 合并流在复制文件的时候,只能操作数据源,不能操作目的地 
 * 构造方法:
 * public SequenceInputStream(InputStream s1,InputStream s2)
 * 需求:dos.txt和ByteArrayStreamDemo.java两个java文件中的内容复制到Copy.txt文件中 分析：
 * 数据源：dos.txt和ByteArrayStreamDemo.jaba--->SequenceInputStream--->分别读取
 * 目的地：Copy.txt--->BufferedOutputStream--->写数据
 * 
 * @author 小鑫
 */
public class SequenceInputStreamDemo {

    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream f1 = new FileInputStream("dos.txt");
        FileInputStream f2 = new FileInputStream("ByteArrayStreamDemo.java");
        // 创建合并流对象
        SequenceInputStream sis = new SequenceInputStream(f1, f2);
        // 封装目的地
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("Copy.txt"));
        //一次读取一个字节数组
        byte[] bys=new byte[1024];
        int len=0;
        while((len=sis.read(bys))!=-1){
            bos.write(bys, 0, len);
        }
        sis.close();
        bos.close();
    }
}

2、合并复制多个文件
构造方法：
public SequenceInputStream(Enumeration

package org.westos_06_合并流;

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

/**
 * SequenceInputStream的另一种构造方法:复制多个文件
 * public SequenceInputStream(Enumeration<? extends InputStream> e)
 * Vector集合中的特有功能:
 *      public Enumeration<E> elements()
 * 需求:将DataSteamDemo.java,ByteArrayStreamDemo.java,以及Copy.java将这三个文件中的内容复制到当前项目下:CopyThree.java文件
 * 分析：
 *    数据源：DataSteamDemo.java,ByteArrayStreamDemo.java,Copy.java--->SequenceInpuyStream--->读数据
 *    目的地：CopyThree.java--->BufferedOutputStream--->写数据
 * @author 小鑫
 *
 */
public class SequenceInputStreamDemo2 {

    public static void main(String[] args) throws IOException {
        //创建Vector集合，泛型数据类型<InputStream>
        Vector<InputStream> v = new Vector<InputStream>();
        //封装数据源
        FileInputStream f1 = new FileInputStream("DataStreamDemo.java");
        FileInputStream f2 = new FileInputStream("ByteArrayStreamDemo.java");
        FileInputStream f3 = new FileInputStream("Copy.java");
        //添加到集合
        v.add(f1);
        v.add(f2);
        v.add(f3);
        //特有功能：public Enumeration<E> elements()
        Enumeration<InputStream> en = v.elements();
        //创建合并流对象
        SequenceInputStream sis = new SequenceInputStream(en);
        //封装目的地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("CopyThree.java"));
        //一次读取一个字节数组
        byte[] bys=new byte[1024];
        int len=0;
        while((len=sis.read(bys))!=-1){
            bos.write(bys, 0, len);
        }
        sis.close();
        bos.close();
    }
}

七、序列化流和反序列化流

1、序列化流:将对象像流的方式或者网络传输中的数据写数据.对象—->流数据:ObjectOutputStream
2、反序列化流:将流数据或者网络传输中的流数据读取出来.流数据—->还原成对象:ObjectInputStream
3、Serializeable:序列化接口
4、生成固定ID或者随机ID
5、transient:不用被序列化的时候用它修饰

package org.westos_07_序列化流和反序列化流;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * ObjectOutputStream中的成员方法:
 *      public final void writeObject(Object obj):将obj对象写入到当前的序列化流中
 * ObjectInputStream中的成员方法:
 *      public final Object readObject():从当前反序列化流中读取一个对象
 * @author 小鑫
 */
public class ObjectStreamDemo {

    public static void main(String[] args) throws IOException, IOException, ClassNotFoundException {
        write();
        read();
    }

    private static void read() throws IOException, IOException, ClassNotFoundException {
        // 创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
        //使用反序列化:将流数据--->对象
        //public final Object readObject()
        Object obj = ois.readObject();
        ois.close();
        //System.out.println(obj);
        //org.westos_07_序列化流和反序列化流.Person@544764a1

        //Person类中需要重写toString()
        System.out.println(obj);
        //Person [name=欧文, age=26]
    }

    private static void write() throws IOException, FileNotFoundException {
        //创建Person对象
        Person p = new Person("欧文", 26);
        //创建序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
        //写数据
        //public final void writeObject(Object obj)
        oos.writeObject(p);
        //释放资源
        oos.close();
    }
}

package org.westos_07_序列化流和反序列化流;

import java.io.Serializable;

/**
 * java.io.NotSerializableException:报这个异常:没有实现序列化接口的异常
 * Serializeable:序列化接口
 * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化,如果自定义一个类没有实现这个接口,就不能使用
 * 序列化或者是反序列化!如果一个接口中没有字段,没有构造方法,没有成员方法,叫做标记接口
 * 更改了Pereson类中的一个成员变量,重新去反序列化:出现异常:
 * java.io.InvalidClassException
 * 序列化和反序列化版本号不一致,会出现InvalidClassException
 * 解决这个异常两种方案:
 *          1)要么改动当前某个类中的数据之后,然后重新序列化和反序列化
 *              这种做法不符实实际要求,在实际开发中,可能直接读数据:将流数据--->还原成对象
 *          2)发现黄色警告线,点击它:生成一个固定ID
 * 注意事项:
 *      比如一个类中有很多成员变量,并不想让一些成员变量被序列化,Java提供了一个关键字:
 *      transient:不用被序列化的时候用它修饰
 * @author 小鑫
 *
 */
public class Person implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    //private  transient int age;//Person [name=欧文, age=0]
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}

序列化和反序列化考点:
* 1)将对象—>流数据或者流数据—>对象,该对象所在的类要实现一个标记接口:serializable
* 2)序列化和反序列化生产的版本Id不一致的时候,会出现异常,所以使用生产随机ID或者固定ID解决
* 3)transient:修饰的变量不会被序列化…
八、集合属性类
Properties:属性集合类,该类继承自Hashtable

package org.westos_08_属性集合类;

import java.util.Properties;
import java.util.Set;

/**
 * Properties:属性集合类,该类继承自Hashtable<K,V>,该类属于Map集合
 *   Properties 类表示了一个持久的属性集。
 *   Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串(一般情况:它用作配置文件去使用,MySQL或者Oracle中用它做配置文件)
 *   构造方法:
 *      public Properties():创建一个空属性列表
 * @author 小鑫
 *
 */
public class PropertiesDemo {

    public static void main(String[] args) {
        //创建属性集合类对象
        Properties prop = new Properties();
        //添加元素
        prop.put("张三", 30);
        prop.put("李四", 40);
        prop.put("王五", 50);
        prop.put("赵六", 60);
        //遍历
        Set<Object> keySet = prop.keySet();
        for(Object key:keySet){
            Object value = prop.get(key);
            System.out.println(key+"---"+value);
            /*赵六---60
                 王五---50
                 张三---30
                 李四---40*/

        }
    }
}

2、Properties有自己的遍历和添加元素的功能
* public Object setProperty(String key,String value)：给属性列表中添加元素
* public Set stringPropertyNames():获取当前属性列表中所有的键的集合,键值都是String类型
* public String getProperty(String key)用指定的键在此属性列表中搜索属性值

package org.westos_08_属性集合类;

import java.util.Properties;
import java.util.Set;

/**
 * 属性集合类:Properties有自己的遍历和添加元素的功能
 *      public Object setProperty(String key,String value)：给属性列表中添加元素
 *      public Set<String> stringPropertyNames():获取当前属性列表中所有的键的集合,键值都是String类型
 *      public String getProperty(String key)用指定的键在此属性列表中搜索属性值
 * @author 小鑫
 *
 */
public class PropertiesDemo2 {

    public static void main(String[] args) {
        Properties prop = new Properties();
        //添加元素
        //public Object setProperty(String key,String value)：给属性列表中添加元素
        prop.setProperty("张三", "30");
        prop.setProperty("李四", "40") ;
        prop.setProperty("王五", "50") ;
        prop.setProperty("赵六", "60") ;
        //遍历属性:public Set<String> stringPropertyNames()
        //获取当前属性列表中所有的键的集合,键值都是String类型
        Set<String> keySet = prop.stringPropertyNames();
        for(String key:keySet){
            //public String getProperty(String key)
            String value = prop.getProperty(key);
            System.out.println(key+"---"+value);
            /*赵六---60
                  王五---50
                  张三---30
                  李四---40*/

        }
    }
}

3、Properties 可保存在流中或从流中加载。
* 将文件中的数据加载到属性集合中:public void load(Reader reader)
* 将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)： 第二个参数:comments:对当前属性列表的描述

package org.westos_08_属性集合类练习;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

/**
 * Properties 可保存在流中或从流中加载。
 * 将文件中的数据加载到属性集合中:public void load(Reader reader)
 * 将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)
 *              第二个参数:comments:对当前属性列表 的描述
 * @author 小鑫
 */
public class PropertiesDemo {

    public static void main(String[] args) throws IOException {
        myStore();
        myLoad();
    }

    private static void myLoad() throws IOException {
        //创建属性集合类对象
        Properties prop = new Properties();
        //创建字符输入流对象
        FileReader fr = new FileReader("user.txt");
        //将文件中的数据加载到属性集合中:public void load(Reader reader)
        prop.load(fr);
        //释放资源
        fr.close();
        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        //创建属性集合类对象
        Properties prop = new Properties();
        //给集合添加元素
        prop.setProperty("张三", "30");
        prop.setProperty("李四", "40");
        prop.setProperty("王五", "50");
        //将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)
        //第二个参数:comments:对当前属性列表 的描述
        //创建字符输出流对象
        FileWriter fw = new FileWriter("user.txt");
        prop.store(fw, "name comments");
        //释放资源
        fw.close();
    }
}

4、练习

package org.westos_08_属性集合类练习;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/**
 * 我有一个文本文件(user.txt)，我知道数据是键值对形式的，但是不知道内容是什么。
 * 请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其值为”100”
 *  
 * 分析：
 *   1）将user.txt文件中的内容加载到属性集合类中
 *   2）遍历集合属性类，获取所有键的集合：stringPropertyName(String key)
 *      判断：如果“lisi”这个键中key相等
 *          修改：setProperty(key,"100")
 *   3）重新将集合属性数据写入user.txt中       
 * @author 小鑫
 *
 */
public class PropertiesTest {

    public static void main(String[] args) throws IOException {
        //创建集合属性类对象
        Properties prop = new Properties();
        //创建字符输入流对象
        FileReader fr = new FileReader("user.txt");
        //加载到属性集合中
        prop.load(fr);
        //关闭流资源
        fr.close();

        //遍历属性集合
        //stringPropertyName(String key):获取所有键的集合
        Set<String> keySet = prop.stringPropertyNames();
        for(String key:keySet){
            if("李四".equals(key)){
                //setProperty(key,"100")
                prop.setProperty(key, "100");
            }
        }
        //修改完之后，要重新把属性集合类写入文件user.txt中
        //创建字符输出流对象
        FileWriter fw = new FileWriter("user.txt");
        prop.store(fw, "name comments");
        //关闭流资源
        fw.close();
    }
}