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): 从右向左匹配规则值不分组
* (?<!pattern): 从右向左匹配规则值不分组
* (sa)(\12): 匹配sasa2. 其中\1是复用sa这个规则,而复用的只能是\1-\9范围内
*
*/
// 创建一个匹配 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"));
146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
