JAVASE19

JAVASE19

一、XML的删除与修改

父节点.remove(子节点)

   public static void main(String[] args) throws DocumentException, IOException {
        //1.流
        SAXReader reader = new SAXReader();
        //2.加载xml
        Document document = reader.read("src/user.xml");
        //3.遍历
        Element root = document.getRootElement();

        List<Element> list = root.elements();

        list.forEach(e->{
            //如果是no为102的用户,性别修改为男
            if(e.attributeValue("no").equals("102")){
                e.attribute("sex").setValue("男");
            }

            List<Attribute> ats = e.attributes();
            ats.forEach(attribute -> {
                System.out.println(attribute.getName()+"--->"+attribute.getValue());
            });


            List<Element> list2 = e.elements();
            list2.forEach(element -> {
                System.out.println(element.getName()+"====>"+ element.getData());
                //如果name为张三.同时子标签名为haha,就删除haha这个标签
                if(e.element("name").getText().equals("张三") &&  element.getName().equals("haha")){
                    e.remove(element);
                }
            });

        });

        //写出
        //1.输出格式
        OutputFormat format = OutputFormat.createPrettyPrint();
        //2.XMLWriter输出流
        XMLWriter writer = new XMLWriter(new FileWriter("src/user.xml"),format);
        //3.写出
        writer.write(document);
        //4.刷出
        writer.flush();
        //5.关闭
        writer.close();
    }

二、正则表达式（了解即可）

正则表达式是用来描述具有一定特征的字符串的特殊字
符串 Regular Expression。

作用: 可以用来对字符串进行校验,匹配,筛选…

  public static void main(String[] args) {
        String str = "jflkajl1sjlkfj kl1slkdfjlk1jdldksj";
        String str1 = "jflkajl1sjlkfj kl3slkdfjlk5jdldk8sj";
        //分隔 1
        String[] arr = str.split("1");
        System.out.println(Arrays.toString(arr));

        arr = str1.split("\\d");
        System.out.println(Arrays.toString(arr));

        //String
        String msg = "abc123qwe456";
        String regex = "[a-z]{3}\\d+";
        //matches(regex)判断当前字符串是否满足参数正则语法规则 -->完全匹配,子串匹配不可以
        System.out.println(msg.matches(regex));

        //replaceAll(regex,newString)  满足指定正则语法的子串被新串替换
        System.out.println(msg.replaceAll("[a-z]{3}","XXX"));
        System.out.println(msg);

        //Pattern 正则表达式表示类型  模式器
        Pattern p = Pattern.compile("(ac*)(b+)");
        Matcher m = p.matcher("aaaaacccbbaaab");
        boolean b = m.matches(); //完全匹配
        //查找是否存在满足条件的字串，每次可以继续找到
        while(m.find()){
            //组
            //group() 获取查找的字串
            //group(int index) 获取当前匹配到的字串中指定索引分组的缓存内容

            System.out.println(m.groupCount()+"-->"+m.group()+"-->"+m.group(0));
            //0-->整个表达式
            //分组索引从 1 开始获取
            System.out.println(m.group(1)+"-->"+m.group(2));
        }


    }

三、Stream流

Stream JAVA8新特性
对数据源中的数据，进行运行|计算的元素序列

注意：
数组|集合可以作为存储数据的数据源，stream不能存储数据，只能对数据源中的数据进行计算，得到新的结果，得到一个新的stream
stream不会影响数据源中的数据
流是一次性的流，使用过一次以后不能再次使用，每次会得到一个新的流
stream流特点： 延迟执行|惰性加载 ： 进行一些列中见操作的时候，如果没有进行终止行为，就不会执行中间操作，会在进行终止行为的时候统一执行

使用步骤：
1.根据数据源获取流
2.一些列流式的中间操作
3.终止行为

  public static void main(String[] args) {
        //1.Arrays.stream(数组)
        int[] arr = {1,2,3,4,5,6};
        IntStream stream1 = Arrays.stream(arr);

        //2.Collection的实现类 stream()
        List<String> ls = List.of("aaa","bbb","ccc");
        Stream<String> stream2 = ls.stream();

        //parallelStream 并行流
        stream2 = ls.parallelStream();

        //3.Stream.of(数据1，数据2，数据3)
        Stream<Integer> s = Stream.of(1,2,3,4,5);

        //终止行为
        stream1.forEach(System.out::println);
        stream2.forEach(System.out::println);
        s.forEach(System.out::println);
    }

①中间操作：筛选和切片

public static void main(String[] args) {
        List<User> list = Arrays.asList(
                new User(01 ,"张三", 18),
                new User(02 ,"李四", 38),
                new User(02 ,"李四", 38),
                new User(03 ,"王五", 50),
                new User(04 ,"赵六", 16),
                new User(05 ,"田七", 28)
        );


        //获取流
        Stream<User> stream = list.stream();
        //过滤filter
        //条件： 找到年龄》=18随的用户信息
        // limit(num)-截断流，使其元素不超过给定数量
         skip-跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。
        //distinct 去重 （按照重写hashcode与equals方法相等去重）
        stream.filter(user -> {
            System.out.println("过滤年龄》=18随的用户信息");
            return  user.getAge()>=18;
        }).limit(3).skip(1).distinct().forEach(System.out::println);


    }

②排序

 public static void main(String[] args) {
        List<User> list = Arrays.asList(
                new User(01 ,"张三", 18),
                new User(02 ,"李四", 38),
                new User(02 ,"李四", 38),
                new User(05 ,"王五", 50),
                new User(04 ,"赵六", 16),
                new User(03 ,"田七", 28)
        );

        Stream<User> stream = list.stream();

        //默认根据内部比较器排序
        //stream.sorted().distinct().forEach(System.out::println);

        //默认根据外部比较器排序
        stream.sorted((x,y)->Integer.compare(y.getId(),x.getId())).forEach(System.out::println);
    }

③map

中间操作 map : 把流操作的每一个数据，当作function接口中抽象的参数传递，根据指定的实现行为（lambda）得到一个结果，最终把所有的结果返回一个新的流
如果每一个结果都是一个流，最终会返回一个存放每一个流的一个新的流-》流中存放流
flatMap： 作用与map相等，特点中每一个数据必须返回一个流，最终会结合称为一个整个流 --》 流中存放数据

public static void main(String[] args) {
        List<User> list = Arrays.asList(
                new User(01 ,"张三", 18),
                new User(02 ,"李四", 38),
                new User(02 ,"李四", 38),
                new User(05 ,"王五", 50),
                new User(04 ,"赵六", 16),
                new User(03 ,"田七", 28)
        );

        Stream<User> stream = list.stream();

        //获取所有用户的年龄，然后升序排序
        /*stream.map(u->{
            List<Character> ls = new ArrayList<>();
            char[] arr = u.getName().toCharArray();
            for(char ch:arr){
                ls.add(ch);
            }
            return ls.stream();
        }).forEach(s->{
            s.forEach(System.out::println);
        });//{{a,b,c},{a,b,d},{a,a,a}}*/

       stream.flatMap(u->{
            List<Character> ls = new ArrayList<>();
            char[] arr = u.getName().toCharArray();
            for(char ch:arr){
                ls.add(ch);
            }
            return ls.stream();
        }).forEach(System.out::println); //{{zhang,san,b,c}

    }

④终止操作 reduce归约

  public static void main(String[] args) {
        List<User> list = Arrays.asList(
                new User(01 ,"张三", 18),
                new User(02 ,"李四", 38),
                new User(02 ,"李四", 38),
                new User(05 ,"王五", 50),
                new User(04 ,"赵六", 16),
                new User(03 ,"田七", 28)
        );

        Stream<User> stream = list.stream();

        //Optional<T> reduce(BinaryOperator<T> accumulator) 把流操作的前两个数据作为抽象方法的参数，经过运算得到结果，结果作为下一次计算的第一个参数，流操作的下一个数据作为第二个参数，重复，最终得到结果返回
        /*Integer sum = stream.map(User::getId)
                .distinct().sorted()
                .reduce((x,y)->{
                    System.out.println(x+"-->"+y);
                    return x+y;
                }).get();*/


        // T reduce(T identity, BinaryOperator<T> accumulator); 把第参数100作为抽象方法的第一个参数，流操作的数据作为第二个参数，经过运算得到结果，结果作为下一次计算的第一个参数，流操作的下一个数据作为第二个参数，重复，最终得到结果返回
       /* Integer sum = stream.map(User::getId)
                .distinct().sorted()
                .reduce(100,(x,y)->{
                    System.out.println(x+"-->"+y);
                    return x+y;
                });
        System.out.println(sum);*/

        //了解
        //并行流
        System.out.println(List.of(1,2,3,4,5).parallelStream()
                .reduce(1000,(x,y)->{
            System.out.println(Thread.currentThread().getName()+" : "+x+"-->"+y);
            return x+y;
        },(x,y)->{
            System.out.println("结果："+" : "+x+"-->"+y);
            return x+y;
        }));



    }

 public static void main(String[] args) {
        List<User> list = Arrays.asList(
                new User(01 ,"张三", 18),
                new User(02 ,"李四", 38),
                new User(02 ,"李四", 38),
                new User(05 ,"王五", 50),
                new User(04 ,"赵六", 16),
                new User(03 ,"田七", 28)
        );

        Stream<User> stream = list.stream();

        // allMatch-检查是否匹配所有元素
        //System.out.println(stream.allMatch(u->u.getAge()>=0));;

        //System.out.println(stream.max((x,y)->x.getAge()-y.getAge()).get());;

        //收集所有用户的姓名,返回一个存储姓名的集合
       /* List<String> names = stream.map(User::getName).collect(Collectors.toList());
        System.out.println(names);*/

        //System.out.println(stream.map(User::getName).collect(Collectors.toSet()));

        Map<Integer,String> map = stream.distinct().collect(Collectors.toMap(User::getId,User::getName));
        System.out.println(map);
    }