Stream——数字类型的字符串排序

前言

想到给数据进行排序，一开始头脑中想到的就是sorted()，本篇文章重点说明：

数字类型的字符串数据排序。

其他类型数据排序参考之前的文章：Stream——集合数据按照某一字段排序

什么是数字类型的字符串

数字类型的字符串，准确说是我自己定义的一个名词，就好比下列的数据类型。

"1" "2"

一个简单的坑demo

如标题所示，就是一个坑！如下所示：

List<String> intStrArray = Arrays.asList("1","2","3","4","5","9","13","10","12","11");

List<String> collect = Optional.ofNullable(intStrArray).orElse(new ArrayList<String>())
        .stream()
        .filter(x -> x != null)
        .sorted()
        .collect(Collectors.toList());
collect.forEach(x-> System.out.println(x));

如案例中所示，代码看着是没问题的，但是执行后控制台中打印的结果如下所示:

按照第一位排序，第一位排序完成后，才开始进行第二位排序！

拯救坑代码

如何才能说按照数字的形式，从小到大依次排序呢？

功能实现，还是有方法的。

如下所示

List<String> intStrArray = Arrays.asList("1","2","3","4","5","9","13","10","12","11");

IntStream intStream = intStrArray
                .stream()
                .filter(x -> x != null)
                .mapToInt(x -> Integer.parseInt(x));
                
intStream.sorted().forEach(x-> System.out.println(x));

先将String类型的数组，转换成Inter的数据流，再排序输出，完美。

但是这里并没转换其他类型的数组，没找到对应的方法，后续还需要继续研究。

对象集合中的数字类型排序(有坑)

如下所示，并不是简单的String集合，采取对象封装的方式，构成对象集合，对象如下所示：

@Data
class User{
    private String age;

    public User(String age) {
        this.age = age;
    }
}

写一个简单的数据集合，如下：

List<User> users = Arrays.asList(new User("1")
                , new User("5")
                , new User("3")
                , new User("9")
                , new User("15")
                , new User("12")
                , new User("10")
                , new User("11"));

依旧采取上述的sorted()排序，这里是对象，所以需要指明具体的属性列，逻辑如下：

import java.util.*;
import java.util.stream.Collectors;

public class Test2 {
    public static void main(String[] args) {
        List<User> users = Arrays.asList(new User("1")
                , new User("5")
                , new User("3")
                , new User("9")
                , new User("15")
                , new User("12")
                , new User("10")
                , new User("11"));

        List<User> collect = Optional.ofNullable(users).orElse(new ArrayList<User>())
                .stream()
                .filter(x -> x.getAge() != null)
                .sorted(Comparator.comparing(User::getAge))
                .collect(Collectors.toList());
        collect.forEach(x-> System.out.println(x));
    }
}
@Data
class User{
    private String age;

    public User(String age) {
        this.age = age;
    }
}

代码执行后，控制台打印日志信息如下所示：

回到了文章开头所描述的现象！！

对象集合中的数字类型排序 解决

排序依旧是使用sorted(Comparator.comparing(User::getAge))，但是在源码中存在一种新的方式，传递两种参数：

使用这个方法进行测试，怎么玩呢，代码继续往下看：

 List<User> users = Arrays.asList(new User("1")
                , new User("5")
                , new User("3")
                , new User("9")
                , new User("15")
                , new User("12")
                , new User("10")
                , new User("11"));

List<User> collect = Optional.ofNullable(users).orElse(new ArrayList<User>())
                .stream()
                .filter(x -> x.getAge() != null)
                .sorted(Comparator.comparing(User::getAge,Comparator.comparingInt(Integer::parseInt)))
                .collect(Collectors.toList());

collect.forEach(x-> System.out.println(x));

执行后，控制台输出如下数据信息：

完美实现功能要求！！

扩展

将数字类型字符串数组转换为Integer集合

List<String> rowsLists = Arrays.asList("1"
                ,"2"
                ,"3"
                ,"4"
                ,"5"
                ,"6"
                ,"7"
                ,"8"
                ,"9"
                ,"10"
                ,"11"
                ,"12"
                ,"13"
                ,"14"
                ,"15"
                ,"16"
                ,"17"
                ,"18"
                ,"19"
                ,"20");

List<Integer> collect = rowsLists.stream()
.filter(x -> x != null)
.mapToInt(Integer::parseInt)
.sorted() // 排序
.boxed() // 流中的元素 全部装箱，转换为流
.collect(Collectors.toList());

collect.forEach(x-> System.out.println(x));

总结

.sorted(Comparator.comparing(User::getAge,Comparator.comparingInt(Integer::parseInt)))