乙巳🐍年

acc8226 的博客

发表于 更新于 分类于 ，

方法引用

方法引用分为三种，方法引用通过一对双冒号 :: 来表示，方法引用是一种函数式接口的另一种书写方式

  1. 静态方法引用，通过 类名::静态方法名， 如 Integer::parseInt
  2. 实例方法引用，通过 实例对象::实例方法，如 str::substring
  3. 类名::实例方法名, 如 String::substring
  4. 构造方法引用，通过 类名::new， 如 User::new

第三点: 若 Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： 类名::实例方法名

类名::方法名，相当于对这个方法闭包的引用，类似 js 中的一个 function。比如：

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
public static void main(String[] args) {
    Consumer<String> printStrConsumer = DoubleColon::printStr;
    printStrConsumer.accept("printStrConsumer");

    Consumer<DoubleColon> toUpperConsumer = DoubleColon::toUpper;
    toUpperConsumer.accept(new DoubleColon());

    BiConsumer<DoubleColon,String> toLowerConsumer = DoubleColon::toLower;
    toLowerConsumer.accept(new DoubleColon(),"toLowerConsumer");

    BiFunction<DoubleColon,String,Integer> toIntFunction = DoubleColon::toInt;
    int i = toIntFunction.apply(new DoubleColon(),"toInt");
}

static class DoubleColon {

    public static void printStr(String str) {
        System.out.println("printStr : " + str);
    }

    public void toUpper(){
        System.out.println("toUpper : " + this.toString());
    }

    public void toLower(String str){
        System.out.println("toLower : " + str);
    }

    public int toInt(String str){
        System.out.println("toInt : " + str);
        return 1;
    }
}

用::提取的函数，最主要的区别在于静态与非静态方法，非静态方法比静态方法多一个参数，就是被调用的实例。

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
// 使用双冒号::来构造非静态函数引用
String content = "Hello JDK 8";

// public String substring(int beginIndex)
// 写法一: 对象::非静态方法
Function<Integer, String> func = content::substring;
String result = func.apply(1);
System.out.println(result);

// 写法二:
IntFunction<String> intFunc = content::substring;
result = intFunc.apply(1);
System.out.println(result);

// 写法三: String::非静态方法
BiFunction<String,Integer,String> lala = String::substring;
String s = lala.apply(content, 1);
System.out.println(s);

// public String toUpperCase()
// 写法一: 函数引用也是一种函数式接口，所以也可以将函数引用作为方法的参数
Function<String, String> func2 = String::toUpperCase;
result = func2.apply("lalala");
System.out.println(result);

// 写法二: 可以改写成Supplier: 入参void, 返回值String
Supplier<String> supplier = "alalal"::toUpperCase;
result = supplier.get();
System.out.println(result);

数组引用

1
2
3
4
5
6
7
8
9
// 传统Lambda实现
IntFunction<int[]> function = (i) -> new int[i];
int[] apply = function.apply(5);
System.out.println(apply.length); // 5

// 数组类型引用实现
function = int[]::new;
apply = function.apply(10);
System.out.println(apply.length); // 10

Optional 的用法

1
2
3
4
5
6
7
8
9
10
11
12
// Optional 类已经成为 Java 8 类库的一部分，在 Guava 中早就有了，可能 Oracle 是直接拿来使用了
// Optional 用来解决空指针异常，使代码更加严谨，防止因为空指针 NullPointerException 对代码造成影响
String msg = "hello";
Optional<String> optional = Optional.of(msg);
// 判断是否有值，不为空
boolean present = optional.isPresent();
// 如果有值，则返回值，如果等于空则抛异常
String value = optional.get();
// 如果为空，返回 else 指定的值
String hi = optional.orElse("hi");
// 如果值不为空，就执行 Lambda 表达式
optional.ifPresent(opt -> System.out.println(opt));

Stream 的操作

有些 Stream 可以转成集合，比如前面提到 toList,生成了 java.util.List 类的实例。当然了，还有还有 toSet 和toCollection，分别生成 Set 和 Collection 类的实例。

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
final List<String> list = Arrays.asList("jack", "mary", "lucy");

// 过滤 + 输出
System.out.println("过滤 + 输出: ");
Stream<String> stream = list.stream();
stream.filter(item -> !item.equals("zhangsan"))
    .filter(item -> !item.equals("wangwu"))
    .forEach(item -> System.out.println(item));

// 限制为2
System.out.println("limit(2): ");
list.stream().limit(2).forEach(System.out::println);

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

// 取出最大值
System.out.println("max: ");
String result = list.stream().max((o1, o2) -> o1.compareTo(o2)).orElse("error");
System.out.println(result);


// toList
System.out.println("toList: ");
List<Integer> collectList = Stream.of(1, 2, 3, 4)
        .collect(Collectors.toList());
System.out.println("collectList: " + collectList);
// 打印结果
// collectList: [1, 2, 3, 4]

// toSet
System.out.println("toSet: ");
Set<Integer> collectSet = Stream.of(1, 2, 3, 4)
        .collect(Collectors.toSet());
System.out.println("collectSet: " + collectSet);
// 打印结果
// collectSet: [1, 2, 3, 4]

list 转 map(通过 stream)

1
2
3
4
5
6
7
8
9
10
11
List<Person> list = new ArrayList<>();
list.add(new Person(1, "mary"));
list.add(new Person(2, "lucy"));

Map<Integer, Person> map = list.stream().collect(Collectors.toMap(Person::getId, Function.identity()));
System.out.println(map);
// 输出: {1=Main3$Person@42f30e0a, 2=Main3$Person@24273305}

Map<Integer, String> map2 = list.stream().collect(Collectors.toMap(Person::getId, Person::getName));
System.out.println(map2);
// 输出: {1=mary, 2=lucy}

分割数据块

1
2
3
4
5
Map<Boolean, List<Integer>> map = Stream.of(1, 2, 3, 4)
        .collect(Collectors.partitioningBy(item -> item > 2));
    System.out.println(map);

// 输出: {false=[1, 2], true=[3, 4]}

函数的返回值只能将数据分为两组也就是 ture 和 false 两组数据。

groupingBy 数据块分组

数据分组是一种更自然的分割数据操作， 与将数据分成 true 和 false 两部分不同，可以使用任意值对数据分组。

groupingBy 是都集合进行分组，分组之后的结果形如 Map<key,List>。其中，key 是进行分组的字段类型，比如按 Ussr 类中的 type（用户类型：1、2、3、4）进行分组，type的类型为Integer，分组之后的Map的key类型就是Integer。并且最多会分成四组，所以最后的结果即 Map<Integer,List>。
假设我们想用户类型为 1 的集合，首先先进行分组，如：

1
Map<Integer,List<User>> userMap = allUserList.parallelStream().collect(Collectors.groupingBy(User::getType));

接下来直接从 Map 中 get(1) 即可，如：List<User> userList = userMap.get(1);

groupingBy 与 partitioningBy 之间的坑

  1. 必须要提的一点是：在进行 get 时，groupingBy 分组若 key 不存在则返回 null，partitioningBy 则会返回空数组，groupingBy 分组注意判空。
  2. stream 处理集合的效率并不一定比迭代器高，如果不要求顺序可以使用 parallelStream 进行并行流的处理。

根据俩个字段进行分组

1
2
Map<Integer, Map<BigDecimal, List<User>>> collect = userList.stream().filter(Objects::nonNull)
            .collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getMoney)));

复杂分组

1
2
Map<Integer, Map<BigDecimal, List<Long>>> collect = userList.stream().filter(Objects::nonNull)
        .collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getMoney, Collectors.mapping(User::getId, Collectors.toList()))));

collect

Collectors.joining 收集 Stream 中的值，该方法可以方便地将 Stream 得到一个字符串。joining 函数接受三个参数，分别表示允（用以分隔元素）、前缀和后缀。

1
2
3
4
5
String strJoin = Stream.of("1", "2", "3", "4")
        .collect(Collectors.joining(",", "[", "]"));
System.out.println("strJoin: " + strJoin);
// 打印结果
// strJoin: [1,2,3,4]

distinct

去重

limit

limit方法可以对流进行截取，只取用前n个。

peek

流由三部分组成：数据源、零个或多个中间操作以及零个或一个终端操作。

peek() 是一个中间操作，由于是惰性，所以如果没有对管道应用终端操作则不会执行。

peek() 的 Javadoc 页面说：“这个方法的存在主要是为了支持调试，如果希望在元素流过管道中的某个点时看到它们的值”。
最重要的是， peek() 在另一种情况下很有用：想要改变元素的内部状态时。 例如，假设想在打印之前将所有用户名转换为小写。

举例

1
2
3
4
5
6
7
8
9
10
@Test
public void test(){
    List<String> collect = Stream.of("one", "two", "three", "four")
            .filter(e -> e.length() > 3)
            .peek(e -> System.out.println("过滤值: " + e))
            .map(String::toUpperCase)
            .peek(e -> System.out.println("映射值: " + e))
            .collect(Collectors.toList());
    System.out.println(collect);
}

skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流

sorted 排序

stream 中有两个 sorted 方法：

  1. 一个无参的方法 Stream<T> sorted();查看它的实现类，往里进，发现它默认使用的是自然排序 compareTo。
  2. 一个有参的方法 Stream<T> sorted(Comparator<? super T> comparator); 该方法需要传一个比较器参数。

默认为升序
userList = userList.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());

改为降序

userList = userList.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());

多条件排序

userList = userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getId)).collect(Collectors.toList());

应用：进行分页

1
2
3
4
5
final TableDataInfo dataTable = getDataTable(resultList);
final int pageSize = (query.getPageSize() != null && query.getPageSize() > 0) ? query.getPageSize() : 8;
final int pageNum = (query.getPageNum() != null && query.getPageNum() > 0) ? query.getPageNum() : 0;
dataTable.setRows(resultList.stream().skip((long) (pageNum - 1) * pageSize).limit(pageSize).
        collect(Collectors.toList()));

遇到过的问题

Java8 流处理过程进行 toMap 规约处理时的 java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133) 异常

解决方法：规约处理时进行冲突兼容处理，即出现冲突时进行取值选择

冲突处理选择方法，在 toMap(key, value, (v1,v2) -> v1)中添加冲突时选值参数“（v1, v2）-> v1”表示出现 key 冲突时取第一次出现的 key 的值,，“（v1, v2）-> v2” 表示出现 key 冲突时取最后一次出现的 key 的值，在实际中根据自己的实际情况取值。

1
2
3
Map<String, Integer> nameAgeMap = employList
  .stream()
  .collect(Collectors.toMap(Employee :: getName, Employee :: getAge, (v1, v2) -> v1));

参考

JDK1.8 新特性(三): 方法引用 ::和 Optional
https://blog.csdn.net/vbirdbest/article/details/80207673

https://blog.csdn.net/IO_Field/article/details/54971761
Java 8 系列之 Stream 的基本语法详解

Java8 新特性 Stream 使用心得之：groupingBy 与 partitioningBy_G_axis 的博客-CSDN博客
https://blog.csdn.net/V_Axis/article/details/86095053

这可能是史上最好的 Java8 新特性 Stream 流教程 - osc_bnuaa5jy 的个人空间 - OSCHINA
https://my.oschina.net/u/4271175/blog/3265285

Java8 中使用 stream 进行分组统计和普通实现的分组统计的性能对比_冯立彬的博客-CSDN 博客_java stream 分组统计
https://blog.csdn.net/fenglibing/article/details/80238310

发表于 更新于 分类于 ，

Random 类

让系统产生随机数使用

产生 0~9 的随机数 (int)(Math.random()*10);
产生 0~10 的随机数为 (int)(Math.random()*(11));
产生 0~999 的随机数 (int)(Math.random()*1000);

产生 1~10 的随机数为 (int)(Math.random()*10) + 1;

生成从 0 到 n-1 的随机整数 即返回值[0,n) (int)(Math.random()*(n+1);
生成从 0 到 n 的随机整数 即返回值[0,n] (int)(Math.random()*(n+1);

生成从 a 到 b 的随机整数 即返回值[a,b]
a + (int)(Math.random()*(b-a+1));

其实 Math 的 random 方法用的就是 util 包中的 Random 类。因此可以 Random.nextDouble() 替换 Math.random(), 但是这样说不太准确。

阅读全文 »

发表于 更新于 分类于 ，

标准输入输出流

字符输入: char c = (char)System.in.read();

字符串输入:

1
2
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
String str = buf.readLine();

使用 System.out 输出

(标准输出流 System.out )提供的如下方法

  1. print()方法：实现不换行的数据输出；
  2. println()方法：与上面方法的差别是输出数据后将换行。
  3. printf()方法：带格式描述的数据输出。该方法包含两个参数，第一个参数中给出输出格式的描述，第 2 个参数为输出数据，其中，输出格式描述字符串中需要安排与输出数据对应的格式符。常用格式符包括：%d 代表十进制数；%f 代表浮点数；%e 代表科学表示法的指数位数；%n 代表换行符；%x 代表十六进制数；%s 代表字符串。
阅读全文 »

发表于 更新于 分类于 ，

Localizing Date 本地化时间
Localizing Currency 本地化货币
Localizing Number 本地化数字
Localing Text 本地化文本

对于本地化，java 的 Locale 类。Util 包的使用方法如下

1
2
Locale l = new Locale ("de","DE");
//第一个参数：语言代码；  第二个参数：城市代码

Localizing Date 本地化时间

1
2
3
DateTimeFormatter localFormater=
DateTimeFormatter.ofPattern("yyyy/MM/dd E a HH:mm:ss", new Locale("en", "US"));
System.out.println(LocalDateTime.now().format(localFormater));
阅读全文 »

发表于 更新于 分类于 ，

什么是 ClassLoader
ClassLoader 简称类加载器，主要用于加载和校验编译后的 Java 文件(即：以.class结尾的文件)；

有哪些类加载器(ClassLoader)
AppClassLoader(应用类加载器)
ExtClassLoader(扩展类加载器注意：JDK1.8后被修改为平台类加载器)
BootstrapClassLoader(启动类加载器)

获取类加载器
通过简单的 demo 来得到类加载器

1
2
3
4
5
6
7
8
9
public class User {
    public static void main(String[] args) {
        User user = new User();
        Class<? extends User> userClass = user.getClass();
        System.out.println(userClass.getClassLoader());
        System.out.println(userClass.getClassLoader().getParent());
        System.out.println(userClass.getClassLoader().getParent().getParent());
    }
}
阅读全文 »
0%