Day13

属性集

package com.ioText.shuXingJi;

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

/*
        java.util.Properties集合 extends Hashtable<k,v>implements Map<k,v>
        Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。
        Properties集合是唯一一个和IO流结合的集合
            可以使用Properties集合中的方法store，把集合中的临时  数据，持久化写入到硬盘中存储
            可以使用Properties集合中的方法load，把硬盘中的文件（键值对），读取到集合中使用
        属性列表中每个键及其对应值都是一个字符串。
            Properties集合是一个双链集合，key和value默认都是字符串
     */
public class Demo02 {
        public static void main(String[] args) throws IOException {
            show02();
        }
        /*
            可以使用Properties集合中的方法store，把ihe中的临时数据，持久化写入到硬盘中存储
            void store（OutputStream out,String comments）
            void store（Writer writer,String comments）
            参数：
                OutputStream out：字节输出流，不能写入中文
                Writer writer；字符输出流，可以写中文
                String comments：注释，用来解释是说明保存的文件是做什么的
                                不能使用中文，会产生乱码，默认Unicode编码
                                一般使用""空字符串

           使用步骤：
                1.创建Properties集合，添加数据
                2.创建字节输出流/字符输出流对象，构造方法中绑定输出的目的地
                3.使用Properties集合中的方法store，把集合中的临时数据，持久化写入硬盘存储中
                4.释放资源
         */
        private static void show02() throws IOException {
            //1.创建Properties集合，添加数据
            Properties prop=new Properties();
            //使用setProperty往集合里添加数据
            prop.setProperty("赵丽颖","168");
            prop.setProperty("迪丽热巴","165");
            prop.setProperty("古力娜扎","160");
            //2.创建字节输出流/字符输出流对象，构造方法中绑定输出的目的地
            FileWriter fw=new FileWriter("基础语法\\prop.txt");
            //3.使用Properties集合中的方法store，把集合中的临时数据，持久化写入硬盘存储中
            prop.store(fw,"save date");
            //4.释放资源
            fw.close();

        }
        /*
            使用Properties集合存储数据，遍历取出Properties集合中的数据
            Properties集合是一个双链集合，key和value默认都是字符串
            Properties集合有一些操作字符串的特有方法
                Object setProperty(String Key,String Value) 调用Hashtable的方法put
                String getProperty(String key) 用指定的键在此属性列表搜索属性(通过key找到value)，此方法相当于Map集合中的get（key）方法
                Set<String> stringPropertyNames（） 返回此属性列表中的键集，其中该键及其相对应值是字符串，此方法相当于Map集合中的keySet方法
         */

    }

package com.ioText.shuXingJi;

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

/*
        java.util.Properties集合 extends Hashtable<k,v>implements Map<k,v>
        Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。
        Properties集合是唯一一个和IO流结合的集合
            可以使用Properties集合中的方法store，把集合中的临时  数据，持久化写入到硬盘中存储
            可以使用Properties集合中的方法load，把硬盘中的文件（键值对），读取到集合中使用
        属性列表中每个键及其对应值都是一个字符串。
            Properties集合是一个双链集合，key和value默认都是字符串
     */
public class Demo03 {
    public static void main(String[] args) throws IOException {
        show03();
    }
    /*
        可以使用Properties集合中的方法load，把硬盘中的文件（键值对），读取到集合中使用
        load(InputStream inStream)
        load(Reader reader)
        参数：
            load(InputStream inStream)：字节输入流，不能读取含有中文的键值对
            load(Reader reader);字符输入流，能读取含有中文的键值对
        使用步骤：
            1.创建Properties集合对象
            2.使用Properties集合对象中的方法load读取保存键值对的文件
            3.遍历Properties集合
        注意：
            1.存储键值对的文件中，键与值的链接符号可以使用=，空格（其他符号）
            2.存储键值对的文件中，可以使用#进行注释，被注释的键值对不会在被读取
            3.存储键值对的文件中，键与值默认都是字符串，不用在加引号
     */
    private static void show03() throws IOException {
        //1.创建Properties集合对象
        Properties prop = new Properties();
        //2.使用Properties集合对象中的方法load读取保存键值对的文件
        prop.load(new FileReader("基础语法\\prop.txt"));
        //3.遍历Properties集合
        Set<String> set = prop.stringPropertyNames();
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }
    }

        /*
            使用Properties集合存储数据，遍历取出Properties集合中的数据
            Properties集合是一个双链集合，key和value默认都是字符串
            Properties集合有一些操作字符串的特有方法
                Object setProperty(String Key,String Value) 调用Hashtable的方法put
                String getProperty(String key) 用指定的键在此属性列表搜索属性(通过key找到value)，此方法相当于Map集合中的get（key）方法
                Set<String> stringPropertyNames（） 返回此属性列表中的键集，其中该键及其相对应值是字符串，此方法相当于Map集合中的keySet方法
         */

}

缓冲流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YSluLdCz-1613780352914)(C:\Users\lcj\AppData\Roaming\Typora\typora-user-images\image-20210217101945512.png)]

流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OgwOV8Cp-1613780352917)(C:\Users\lcj\AppData\Roaming\Typora\typora-user-images\image-20210217102701874.png)]

字节缓冲流

package com.ioText.huangChongQu;

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

/*
    java.io.BufferedOutputStream extends OutputStream
    BufferedOutputStream:字节缓冲输出流

    继承自父类的共性成员方法：
    -publi void close（）:关闭此输出流并释放与此相关联的任何资源
    -publi void flush（）:刷新此输出流并强制任何缓冲的输出字节被写入
    -publi void write（byte[] b）:将b.length字节从指定的字节数组写入此输出流
    -publi void write（byte[] b，int off，int len）:从指定字节数组len字节，从偏移量off开始输出到此输出流
    -publi abstract void write（byte[] b）从指定的字节输出流

    构造方法；
        BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
        BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
    参数：
        OutputStream out：字节输出流
            我们可以传递FileOutputStream，缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率
        int size：指定缓冲区内部缓冲区大小，不指定默认
    使用步骤：（重点）
        1.创建一个FileOutputStream对象，构造方法中绑定要输出的目的地
        2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率
        3.使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中
        4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区的数据，刷新到文件中
        5.释放资源（会自动先调用flush方法刷新数据，所以第四步可以省略）
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream对象，构造方法中绑定要输出的目的地
        FileOutputStream fos = new FileOutputStream("基础语法\\m.txt");
        //2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //3.使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中
        bos.write("我把数据写入到内部缓冲区中".getBytes());
        //4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区的数据，刷新到文件中
        bos.flush();
        //5.释放资源（会自动先调用flush方法刷新数据，所以第四步可以省略）
        bos.close();
    }
}

package com.ioText.huangChongQu;

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

/*
    java.io.BufferedInputStream extends InputStream
    BufferedInputStream:字节缓冲输入流

    继承自父类的成员方法：
        int read（）从输入流中读取数据的下一字节。
        int read（byte[] b）从输入流中读取一定数量的字节，并将器存储在缓冲区宿主b中
        void close（）；关闭输入流并释放与该流关联的所有系统资源。
    构造方法：
        BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
        BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
        参数：
            InputStream in：字节输入流
                我们可以传递FileInputStream，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率
            int size：指定缓冲区内部缓冲区大小，不指定默认
    使用步骤（重点）：
        1.创建FileInputStream对象，构造方法中绑定要读取的数据源
        2.创建BufferedInputStream对象，构造方法中传递FileInputStream，提高FileInputStream对象读取的效率
        3.使用BufferedInputStream对象中的方法read，读取文件
        4.释放资源
 */
public class Demo02 {
    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("基础语法\\m.txt");
        //2.创建BufferedInputStream对象，构造方法中传递FileInputStream，提高FileInputStream对象读取的效率
        BufferedInputStream bis = new BufferedInputStream(fis);
        //3.使用BufferedInputStream对象中的方法read，读取文件
//        int len=0;每次读取到的字节
//        while ((len=bis.read())!=-1){
//            System.out.println(len);
//        }
        byte[] bytes=new byte[1024];
        int len =0;//记录读取到有效字节的个数；
        while((len=bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        //4.释放资源
        bis.close();
    }
}

文件复制

package com.ioText.huangChongQu;

import java.io.*;

/*
    文件复制练习：一读一写
    明确：
        数据源：c:\\jpg
        数据的目的地：d:\\jpg
   文件复制的步骤：
        1.创建字节缓冲输入流对象，构造方法中传递字节输入流
        2.创建字节缓冲输出流对象，构造方法中传递字节输出流
        3.使用字节缓冲输入流对象中的方法read读取文件
        4.使用字节缓冲输出流中的write，把读取到的数据写入到内部的缓冲区中
        5.释放资源
 */
public class Demo03Text {
    public static void main(String[] args) throws IOException {
        long s=System.currentTimeMillis();
        //1.创建字节缓冲输入流对象，构造方法中传递字节输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c:\\2.jpg"));
        //2.创建字节缓冲输出流对象，构造方法中传递字节输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\2.jpg"));
        //3.使用字节缓冲输入流对象中的方法read读取文件
        byte[] bytes=new byte[1024];
        int len=0;
        while ((len=bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        //4.使用字节缓冲输出流中的write，把读取到的数据写入到内部的缓冲区中

        //5.释放资源
        bos.close();
        bis.close();
        long e=System.currentTimeMillis();
        System.out.println("文件复制耗时"+(e-s));

    }
}

字符缓冲流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-POmN1ZRu-1613780352918)(C:\Users\lcj\AppData\Roaming\Typora\typora-user-images\image-20210217154434095.png)]

package com.ioText.huangChongQu.ziJie;

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

/*
    java.io.BufferedWriter extends Writer
    BufferedWriter:字符缓冲输出流

    继承自父类的共性成员方法：
        void write(int c)写入单个字符。
        void write(char[] cbuf)写入字符数组
        abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分，off,数组开始索引，len 写的字符个数。
        void write (String str)写入字符串
        void write (String str,int off,int len)写入字符串的额一部分，off字符串开始索引，len写的字符个数
        void write()刷新该流的缓冲
        void close（）关闭此流，但要先刷新

     构造方法：
        BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
        BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
        参数：
            Writer out：字符输出流
                我们可以传递FileWriter，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率
            int sz：指缓冲区的大小，不写默认大小
     特有的成员方法：
        void newLine()写入一个分隔符。 会根据不同的操作系统，获取不同的换行分隔符

     使用步骤：
        1.创建字符缓冲输出流对象，构造方法中传递字符输出流
        2.调用字符缓冲输出流的方法write，把数据写入内存缓冲区中
        3.调用字符缓冲区中的flush，把内存缓冲区中的数据，刷新到文件中
        4.释放资源
 */
public class Demo01{
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("基础语法\\c.txt"));
        for (int i = 0; i < 10; i++) {
            bw.write("传智播客");
            bw.newLine();//会根据不同的操作系统，获取不同的换行分隔符  不需要根据操作系统的不同来写不同的换行分隔符
        }
        bw.flush();
        bw.close();
    }
}

package com.ioText.huangChongQu.ziFu;

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

/*
    java.io.BufferedReader extends Reader
    继承自父类的共性成员方法：
        int read（） 读取单个字符并返回
        int read（char[] cbuf） 一次读取多个字符，将字符读入数组
        void close（）关闭资源并释放与之关联的所有资源
    构造方法：
        BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
        BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
        参数：
            Reader in：字符输入流
                我们传递FileReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取数据
    特有的成员方法：
        String readLine() ：读取一个文本行。 读取一行数据
            行的终止符号：通过下列字符之一即可认为某行已终止：换行（'\n'）、回车（'\r'）或回车直接跟着换行（\r\n）
        返回值：
            包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

    使用步骤：
        1.创建字符缓冲输入流对象，构造方法中传递字符输入流
        2.使用字符缓冲输入流对象中的方法read/readLine读取文本
        3.释放资源

 */
public class Demo02 {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new FileReader("基础语法\\c.txt"));

//        String s = br.readLine();
//        System.out.println(s);
//        s = br.readLine();
//        System.out.println(s);
//        s = br.readLine();
//        System.out.println(s);
//        s = br.readLine();
//        System.out.println(s);

        //发现上面的代码重复   所以使用while循环优化
        //while结束的调节，读取到null结束。
        String line;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }

//        char[] chars=new char[1024];
//        int len=0;
//        while((len=br.read(chars))!=-1){
//            System.out.println(new String(chars,0,len));
//        }
        br.close();



    }
}

练习：文本排序

3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小
悉以咨之，然后施行，必得裨补阙漏，有所广益。
8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎;陛下亦宜自谋，以咨锻善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
4 .将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之日能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
⒉.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义以塞忠谏之路也。
9.今当远离,临表涕零，不知所言。
6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分速。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
5.亲贤臣$远小人，此先汉所以兴隆也;亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

package com.ioText.huangChongQu.ziFu;

import java.io.*;
import java.util.HashMap;

/*
    练习：
        对文本的内容排序
        按照（1，2，3，4······）顺序排序
    分析：
        1.创建HashMap集合对象，key可以存储内行文本的序号（1，2，3，4······）；value：存储每行的文本
        2.创建字符缓冲输入流对象，构造方法中绑定字符输入流
        3.创建字符缓冲输出流对象，构造方法中绑定字符输出流
        4.使用字符缓冲输入流的方法readLine，逐行读取文本
        5.对读取到的文本经行切割，获取行中的序号和文本内容
        6.把切割好的序号和文本的内容存储到HashMap集合中（Key序号是有序的，会自动排序1，2，3，4，5····）
        7.遍历HashMap集合，获取每一个键值对
        8.把每一个键值对，拼接为一个文本行
        9，把拼接好的文本，使用字符缓冲输出流中的方法write，写入文件中
        10.释放资源
 */
public class Demo03Text {
    public static void main(String[] args) throws IOException {
        HashMap<String, String> map = new HashMap<>();
        BufferedReader br = new BufferedReader(new FileReader("基础语法\\c.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("基础语法\\l.txt"));
        String line;
        while ((line=br.readLine())!=null){
            String[] arr = line.split("\\.");
            map.put(arr[0],arr[1]);
        }
        for (String key:map.keySet()) {
            String value=map.get(key);
            line=key+"."+value;
            bw.write(line);
            bw.newLine();
        }
        bw.close();
        br.close();
    }
}