java常用工具类

Arrays(数组操作)

		/**
         * 串行： 单线程
         * 并行： 多线程
         */
        Integer[] num = {1, 1, 98, 8, 24, 2, 86, 54, 86, 3};
        /**
         * 返回值解释:
         * 当返回值大于0时不交换,为负数时交换
         */
        Arrays.sort(num, (o1, o2) -> {
            // 比较o1和o2。如果o1大于o2则返回1,相等返回0,小于返回-1(升序)
            return o1.compareTo(o2);
        });
        System.out.println(Arrays.toString(num));
        // 串行排序(升序)  数据量小(20W以下)的情况下效率更高
        Arrays.sort(num);
        // 并行排序(升序)  数据量大(20W以上)的情况下效率更高
        Arrays.parallelSort(num);

        /**
         * setAll: 串行获取下标(顺序)并返回结果值
         * jdk1.8新增
         * parallelSetAll: 并行获取下标(不保证顺序)并返回结果值
         */
        // 并行得到下标(value)并重新赋值  注：并行执行所有下标不是按照顺序获取的
        Arrays.parallelSetAll(num, value -> {
            // 如果值等于2,那么最后结果该值等于0
            return num[value] == 2 ? 0 : num[value];
        });
        Arrays.setAll(num, value -> {
            return num[value];
        });

        /**
         * 指定值填充满指定数组:
         * 重载方法有 从startIndex到endIndex位置. 含头不含尾
         */
        Arrays.fill(num, 0, 2, 9);

        Arrays.sort(num, (o1, o2) -> {
            // 倒序
            return o2.compareTo(o1);
        });
        System.out.println(Arrays.toString(num));
        /**
         * 二分查找指定值 返回下标, 不存在时返回 索引(从1开始)位置处,表明在该key是在索引值与左边值的中间
         *
         * 注: 只限于升序排序的数组
         */
        int i = Arrays.binarySearch(num, 9, (o1, o2) -> {
            // 参数1为二分值, 参数2为比较值
            // 返回0,找到了。 返回1从左边找, 返回-1从右边找
            if (o1 == o2) {
                return 0;
            } else {
                return o1.compareTo(o2) >= 0 ? -1 : 1;
            }
        });

        /**
         * 可分割迭代器  (重点:以后有机会深入了解)
         * 数据量大可以分割为多个,多线程并行执行。
         */
        Spliterator<Integer> spliterator = Arrays.spliterator(num);
        // 相当于iterator中的next + hashNext结合   获取是否有下一个元素的同时执行跳转
        boolean b = spliterator.tryAdvance(integer1 -> {
            // 打印
        });
        // 顺序遍历值
        /*spliterator.forEachRemaining(integer -> {
            System.out.println(integer);
        });*/
        // 尝试剩余值进行两分分组,生成新的迭代器。 如果没有剩余值那么返回null值
        Spliterator<Integer> split = spliterator.trySplit();
        long l = spliterator.estimateSize();
        // 当迭代器拥有SIZED特征时，返回剩余元素个数；否则返回-1
        long exactSizeIfKnown = spliterator.getExactSizeIfKnown();
        // 查询是否包含指定特征
        boolean b1 = spliterator.hasCharacteristics(Spliterator.SIZED);
        split.forEachRemaining(integer -> {
            // 打印
        });

        /**
         * 复制数组(只是重新增加了引用, 如果修改了引用对象,因为都指向的一个,所有其他引用都会修改)
         * 提供:
         * Arrays.copyOf : 复制指定长度数组, 下标从0开始
         * Arrays.copyOfRange: 复制指定开始下标到结束下标之间的数据,(含头不含尾)
         */
        Integer[] integers = Arrays.copyOfRange(num, 1, 5);

Stream(流)

		/**
         * Stream: 流对象 jdk1.8新增
         * 每个流只能使用一次。
         * 注: 第二次使用会抛java.lang.IllegalStateException: stream has already been operated upon or closed
         */
        Integer[] num = {1, 2, 3, 5, 8, 91, 354, 867, 231, 12};
        Stream<Integer> stream = Arrays.stream(num);
        // 遍历  (不能退出)  遍历完为止
        stream.forEach(integer -> {
            System.out.println(integer);
        });
        // 过滤数据
        Object[] objects = stream.filter(integer -> {
            // 保留(true) 丢弃(false)
            return integer != 2;
        }).toArray();

        // 转为intStream  里面有很多数据计算的方法
        IntStream intStream = stream.mapToInt(value -> {
            return value;
        });

        /**
         * Collectors:
         * Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
         */
        // 转换为自定义泛型流 或 映射结果
        List<String> collect = stream.map(integer -> {
            return String.valueOf(integer * integer) + "2asss";
        }).collect(Collectors.toList());

        // 排序
        stream.sorted((o1, o2) -> {return o2.compareTo(o1);}).forEach(System.out::println);

正则表达式

		/**
         * java中正则表达式详解:
         * Pattern类:  配置规则
         * Matcher类: 根据规则获取匹配值
         * CharSequence接口: 字符类型的都实现了这个接口。例如:String、StringBuffer、StringBuilder等
         * Predicate接口: 配置规则链接，顺序执行，只要前一个返回false，后台均不会执行。
         * 正则分组：
         * (pattern): 匹配pattern并分组
         * (?:pattern): 匹配pattern不分组
         * (?=pattern): 从左向右匹配规则值不分组
         * (?!pattern): 从左向右匹配非规则值不分组
         * (?<=pattern): 从右向左匹配规则值不分组
         * (?
        // 创建一个匹配 3sa或3sbb 的规则配置类
        Pattern pattern = Pattern.compile("(sa)(d)");
        // 规则字符串
        String regex = pattern.pattern();
        // 以指定规则拆分字符串
        System.out.println(Arrays.toString(pattern.split("哈哈3sa嘻嘻3sbb咕咕")));
        // 以指定规则拆分字符串,最多分成几个数组(如果只能分3组,数组长度为3)
        System.out.println(Arrays.toString(pattern.split("哈哈3sa嘻嘻3sbb咕咕", 5)));
        // 拆分结果以Stream的形式返回
        Stream<String> stream = pattern.splitAsStream("哈哈3sa嘻嘻3sbb咕咕");
        /**
         * 生成一个包含规则的Predicate实例
         * 当每个值通过Pattern规则后,会执行Predicate链中匹配,只要其中有返回false的，后面不会执行。
         */
        Predicate<String> predicate = pattern.asPredicate();
        predicate = predicate.and(s -> {
            return s.equalsIgnoreCase("3sa");
        });
        stream.filter(predicate).forEach(System.out::println);
        Matcher matcher = pattern.matcher("1sad哈哈sad哈哈sad");
        // 对整个字符串进行匹配,只有全部通过才返回true
        boolean matches = matcher.matches();
        // 只要有匹配项就返回true
        boolean b = matcher.find();
        // 从指定下标开始寻找匹配(不能超过总字符长度)
//        boolean b2 = matcher.find(1);
        // 只有字符串在最前面才返回true   相当于自带了^符号
//        boolean b1 = matcher.lookingAt();
        /**
         * 使用跟上面的find、matches、find方法有关,
         * 只有匹配通过并且有分组信息时,才会正确返回.否则抛异常 java.lang.IllegalStateException: No match available
         */
        // 分组数量
        int i = matcher.groupCount();
        // 获取所有分组匹配值
        String group = matcher.group();
        // 获取指定分组匹配值
        String group1 = matcher.group(1);
        // 返回第一个匹配的开头下标,  重载方法指定第几分组
        int start = matcher.start();
        // 第一个匹配的结尾下标 重载方法指定第几分组
        int end = matcher.end();
        // 设置只匹配前10个字符
        matcher.region(0, 10);
        // 返回开始索引(0)
        int regionStart = matcher.regionStart();
        // 返回结束索引(10)
        int regionEnd = matcher.regionEnd();
        // 重置匹配器(比如设置了范围区间，则会被重置)
        matcher.reset();
        // 重置指定字符串
        matcher.reset("1sad哈哈sad哈哈sad");
        // 更改用于匹配的规则类
        matcher.usePattern(Pattern.compile("sad"));