stream练习

将字符串转换为键值对存储

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
public class streamPractice02 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,12");
        list.add("lisi,17");
        list.add("wangwu,15");
        list.add("zhaoliu,13");

        Map<String, Integer> collect = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 13)
                .collect(Collectors.toMap(
                        s -> s.split(",")[0],
                        s -> Integer.parseInt(s.split(",")[1])));
        System.out.println(collect);
    }
}

IO练习

删除文件及其文件夹

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.io.File;

public class fileDemo02 {
    public static void main(String[] args) {
        //删除文件夹下的所有文件，，，切记不要删错盘符切记切记
        File f=new File("D:\\Python爬虫");
        deleteFile(f);
    }

    private static void deleteFile(File f) {
        File[] files = f.listFiles();
        assert files != null;
        for (File file : files) {
            if(file.isFile()){
                file.delete();
            }
            else {
                deleteFile(file);
            }
        }
        f.delete();
    }
}

查找本地所有盘符下以jpg为结尾的图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.io.File;

public class fileDemo01 {
    public static void main(String[] args) {
        findDir();
    }

    private static void findDir() {
        //显示盘符
        File[] f = File.listRoots();
        //打印盘符
        for (File file : f) {
            findDir(file);
        }
    }

    private static void findDir(File f) {
        File[] files = f.listFiles();
        //判断files是否为空
        if (files != null) {
            for (File file : files) {
                //搜索所有以jpg结尾的图片
                if (file.isFile() && file.getName().endsWith("jpg")) {
                    System.out.println(file);
                } else {
                    //递归搜索
                    findDir(file);
                }
            }
        }
    }
}

统计文件大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.io.File;

public class fileDemo03 {
    public static void main(String[] args) {
        //统计目录下的文件大小
        File f = new File("D:\\admin");
        long lon = getlen(f);
        System.out.println(lon);

    }

    private static long getlen(File f) {
        long len = 0;
        File[] src = f.listFiles();
        assert src != null;
        for (File file : src) {
            if (file.isFile()) {
                len = len + file.length();
            } else {
                len = len + getlen(file);
            }
        }
        return len;
    }
}

统计某文件夹下文件的总个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
mport java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class fileDemo04 {
    public static void main(String[] args) {
        //统计文件夹下每个文件的个数
        File file = new File(" ");//要查找的文件路径
        HashMap<String, Integer> hm = getCount(file);
        System.out.println(hm);
    }
    private static HashMap<String, Integer> getCount(File file) {
        //定义集合来进行统计
        HashMap<String, Integer> hashMap = new HashMap<>();
        //用数组来存储file集合
        File[] files = file.listFiles();
        assert files != null;
        for (File f : files) {
            if (f.isFile()) {
                //进行切割
                String[] arr = f.getName().split("\\.");
                if (arr.length >= 2) {
                    //获取键值对
                    String name = arr[arr.length - 1];
                    if (hashMap.containsKey(name)) {
                        //如果集合里面存在该键，++
                        //获取对应的值
                        int count = hashMap.get(name);
                        count++;
                        hashMap.put(name, count);
                    } else {
                        //不存在的情况
                        hashMap.put(name, 1);
                    }
                }
            } else {
                HashMap<String, Integer> sonDir = getCount(f);
                //先进行遍历操作
                Set<Map.Entry<String, Integer>> entries = sonDir.entrySet();
                for (Map.Entry<String, Integer> entry : entries) {
                    //判断子目录在父目录下是否存在，如果存在个数相加，如果不存在直接进行put方法
                    String key = entry.getKey();
                    if (hashMap.containsKey(key)) {
                        int value = hashMap.get(key) + entry.getValue();
                        hashMap.put(key, value);
                    } else {
                        //不存在
                        hashMap.put(key, entry.getValue());
                    }
                }
            }
        }
        return hashMap;
    }
}

文件拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class fileDemo05 {
    public static void main(String[] args) throws IOException {
        //拷贝文件以及文件夹

        //1创建对象表示对象源
        File src = new File("");//要拷贝的源文件

        //2创建对象表示目标对象
        File object = new File("");//要拷贝的目的地

        //构造方法进项文件拷贝
        copyDir(src, object);

    }

    private static void copyDir(File src, File object) throws IOException {
        //直接创建目标文件夹
        object.mkdir();

        File[] files = src.listFiles();

        for (File file : files) {
            if (file.isFile()) {
                //创建字节流,拷贝文件
                FileInputStream fis = new FileInputStream(src);
                FileOutputStream fos = new FileOutputStream(object);
                byte[] bytes = new byte[1024 * 4];
                int len;
                while ((len = fis.read(bytes)) != -1) {
                    fos.write(bytes, 0, len);
                    fos.close();
                    fis.close();
                }
            }
            else {
                copyDir(file,new File(object,file.getName()));
            }

        }
    }
}

图片加解密

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class fileDemo06 {
    public static void main(String[] args) throws IOException {
        //加密解密图片
        //思想，用一个数字进行异或运算，加密操作，再次进行异或运算，就是解密
        FileInputStream fis = new FileInputStream("");
        FileOutputStream fos = new FileOutputStream("");

        byte[] bytes = new byte[1024 * 5];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(len ^ 20);
        }
        //解密操作

    }
}

文件复制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.io.*;

public class fileDemo07 {
    //复制文件
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("..\\Javaplus\\a.txt"));
        BufferedWriter writer = new BufferedWriter(new FileWriter("..\\Javaplus\\b.txt"));
        String len;
        while ((len = reader.readLine()) != null) {
            System.out.println(len);
            writer.write(len);
            writer.newLine();
        }

        writer.close();
        reader.close();

    }
}

a.txt

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

出师表按序号进行排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.io.*;
import java.util.ArrayList;
public class fileDemo08 {
    //出师表排序
    public static void main(String[] args) throws IOException {
        //方法一
        //创建对象
        BufferedReader br = new BufferedReader(new FileReader("..\\Javaplus\\csb.txt"));
        String len;
        //创建一个集合
        ArrayList<String> list = new ArrayList<>();

        while ((len = br.readLine()) != null) {
//            System.out.println(len);
            //先对点进行其切割
            list.add(len);

        }
        //重写构造方法
        list.sort((o1, o2) -> {
            int s1 = Integer.parseInt(o1.split("\\.")[0]);
            int s2 = Integer.parseInt(o2.split("\\.")[0]);
            return s1 - s2;
        });
        for (String s : list) {
            System.out.println(s);
        }
        br.close();
        //写出
//        BufferedWriter bf = new BufferedWriter(new FileWriter("\\"));
//        for (String s : list) {
//            bf.write(s);
//            bf.newLine();
//        }

        //写入操作方法二用treemap

    }
}

csb.txt

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

爬取网页上的姓氏，生成名字假数据

写入到本地文件夹

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
package demo07;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test1 {
    public static void main(String[] args) throws IOException {
        /*
         制造假数据：
             获取姓氏：https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0
             获取男生名字：http://www.haoming8.cn/baobao/10881.html
             获取女生名字：http://www.haoming8.cn/baobao/7641.html
        */

        //1.定义变量记录网址
        String familyNameNet = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0";
        String boyNameNet = "http://www.haoming8.cn/baobao/10881.html";
        String girlNameNet = "http://www.haoming8.cn/baobao/7641.html";

        //2.爬取数据,把网址上所有的数据拼接成一个字符串
        String familyNameStr = webCrawler(familyNameNet);
        String boyNameStr = webCrawler(boyNameNet);
        String girlNameStr = webCrawler(girlNameNet);

        //3.通过正则表达式，把其中符合要求的数据获取出来
        ArrayList<String> familyNameTempList = getData(familyNameStr,"(.{4})(，|。)",1);
        ArrayList<String> boyNameTempList = getData(boyNameStr,"([\\u4E00-\\u9FA5]{2})(、|。)",1);
        ArrayList<String> girlNameTempList = getData(girlNameStr,"(.. ){4}..",0);

        //4.处理数据
        //familyNameTempList（姓氏）
        //处理方案：把每一个姓氏拆开并添加到一个新地集合当中
        ArrayList<String> familyNameList = new ArrayList<>();
        for (String str : familyNameTempList) {
            //str 赵钱孙李  周吴郑王   冯陈褚卫   蒋沈韩杨
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                familyNameList.add(c + "");
            }
        }
        //boyNameTempList（男生的名字）
        //处理方案：去除其中的重复元素
        ArrayList<String> boyNameList = new ArrayList<>();
        for (String str : boyNameTempList) {
            if(!boyNameList.contains(str)){
                boyNameList.add(str);
            }
        }
        //girlNameTempList（女生的名字）
        //处理方案：把里面的每一个元素用空格进行切割，得到每一个女生的名字
        ArrayList<String> girlNameList = new ArrayList<>();

        for (String str : girlNameTempList) {
            String[] arr = str.split(" ");
            Collections.addAll(girlNameList, arr);
        }

        //5.生成数据
        //姓名（唯一）-性别-年龄
        ArrayList<String> list = getInfos(familyNameList, boyNameList, girlNameList, 70, 50);
        Collections.shuffle(list);


        //6.写出数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("..\\Javaplus\\names.txt"));
        for (String str : list) {
            bw.write(str);
            bw.newLine();
        }
        bw.close();


    }

    /*
    * 作用：
    *      获取男生和女生的信息：张三-男-23
    *
    * 形参：
    *      参数一：装着姓氏的集合
    *      参数二：装着男生名字的集合
    *      参数三：装着女生名字的集合
    *      参数四：男生的个数
    *      参数五：女生的个数
    * */
    public static ArrayList<String> getInfos(ArrayList<String> familyNameList,ArrayList<String> boyNameList,ArrayList<String> girlNameList, int boyCount,int girlCount){
        //1.生成男生不重复的名字
        HashSet<String> boyhs = new HashSet<>();
        while (true){
            if(boyhs.size() == boyCount){
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(boyNameList);
            boyhs.add(familyNameList.get(0) + boyNameList.get(0));
        }
        //2.生成女生不重复的名字
        HashSet<String> girlhs = new HashSet<>();
        while (true){
            if(girlhs.size() == girlCount){
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(girlNameList);
            girlhs.add(familyNameList.get(0) + girlNameList.get(0));
        }
        //3.生成男生的信息并添加到集合当中
        ArrayList<String> list = new ArrayList<>();
        Random r = new Random();
        //【18 ~ 27】
        for (String boyName : boyhs) {
            //boyName依次表示每一个男生的名字
            int age = r.nextInt(10) + 18;
            list.add(boyName + "-男-" + age);
        }
        //4.生成女生的信息并添加到集合当中
        //【18 ~ 25】
        for (String girlName : girlhs) {
            //girlName依次表示每一个女生的名字
            int age = r.nextInt(8) + 18;
            list.add(girlName + "-女-" + age);
        }
        return list;
    }



    /*
    * 作用：根据正则表达式获取字符串中的数据
    * 参数一：
    *       完整的字符串
    * 参数二：
    *       正则表达式
    * 参数三：
    *      获取数据
    *       0：获取符合正则表达式所有的内容
    *       1：获取正则表达式中第一组数据
    *       2：获取正则表达式中第二组数据
    *       ...以此类推
    *
    * 返回值：
    *       真正想要的数据
    *
    * */
    private static ArrayList<String> getData(String str, String regex,int index) {
        //1.创建集合存放数据
        ArrayList<String> list = new ArrayList<>();
        //2.按照正则表达式的规则，去获取数据
        Pattern pattern = Pattern.compile(regex);
        //按照pattern的规则，到str当中获取数据
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()){
            list.add(matcher.group(index));
        }
        return list;

    }

    public static String webCrawler(String net) throws IOException {
        //1.定义StringBuilder拼接爬取到的数据
        StringBuilder sb = new StringBuilder();
        //2.创建一个URL对象
        URL url = new URL(net);
        //3.链接上这个网址
        //细节：保证网络是畅通的，而且这个网址是可以链接上的。
        URLConnection conn = url.openConnection();
        //4.读取数据
        InputStreamReader isr = new InputStreamReader(conn.getInputStream());
        int ch;
        while ((ch = isr.read()) != -1){
            sb.append((char)ch);
        }
        //5.释放资源
        isr.close();
        //6.把读取到的数据返回
        return sb.toString();
    }
}

压缩文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package demo07;

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class zip {
    public static void main(String[] args) throws IOException {
        //创建一个zipEntry对象
        //需要解压缩的zip
        File src = new File(" ");
        File dest = new File("");

        //自定义方法
        unzip(src, dest);
    }

    private static void unzip(File src, File dest) throws IOException {

        //创建解压缩流
        ZipInputStream zis = new ZipInputStream(new FileInputStream(src));
        ZipEntry z;
        //循环读取每个对象
        while ((z = zis.getNextEntry()) != null) {

            if (z.isDirectory()) {
                //是文件夹
//                System.out.println(z.getName());
                File f = new File(dest, z.getName());
                f.mkdir();

            } else {
                //不是文件夹
                FileOutputStream fos = new FileOutputStream(new File(dest, z.getName()));
                int b;
                while ((b = zis.read()) != -1) {
                    fos.write(b);
                }
                fos.close();
            }
        }
        zis.close();
    }
}