java guava map创建,数组合并,数组分割连接

引入依赖

https://search.maven.org/search?q=guava

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<!-- https://search.maven.org/artifact/com.google.guava/guava/ -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

fox.风

案例 数组 拼接(连接)成 字符串

//创建 map xx
Map<Long,String > xx= Maps.newHashMap();
xx.put(1L,"ssss");
xx.put(2L,"bbbbb");
//创建 map xx2
Map<Long,String > xx2= Maps.newHashMap();
xx2.put(3L,"ssss");
xx2.put(4L,"bbbbb");
//创建数组 aooList
List<String> aooList = Lists.newArrayList(xx.values());
//把  xx2 所有值 存入数组 xx2.values() 
aooList.addAll(xx2.values());
//输出
log.info("at ={}",aooList);
//把 List 数组 用 ,  号 拼接(连接)成 字符串,并跳过 null 值
String str= Joiner.on(",").skipNulls().join(aooList);
log.info("join str ={}",str);

输出

at =[ssss, bbbbb, ssss, bbbbb]
join str =ssss,bbbbb,ssss,bbbbb

案例 字符串 分割成数组

String strArr = "ssss,bbbbb,ssss,,bbbbb";
// 自带分割
String[] arr1 = strArr.split(",");
//转换为 list ,注意这个list 不能再添加原素,否则报错
List<String> list2 = Arrays.asList(arr1);
log.info("List arr1 ={}", list2);
//转换为 list,注意这个list 可以再添加原素  
List<String> list3 = Lists.newArrayList(Arrays.asList(arr1));
//转换为 list,注意这个list 可以再添加原素  
List<String> list4 = new ArrayList<>(Arrays.asList(arr1));

//分割,去除 空值 转换为 List
List<String> strings1 = Splitter.on(',').trimResults().omitEmptyStrings().splitToList(strArr);
//分割,去除 空值
Iterable split = Splitter.on(",").trimResults().omitEmptyStrings().split(strArr);
log.info(" Iterable split ={}", split);
//转换为 list
List<String> list = Lists.newArrayList(split);
log.info(" List list ={}", list);
// List<String>  转换 为long[]
long[] array =list.stream().mapToLong(t->t.longValue()).toArray(); 

输出

List arr1 =[ssss, bbbbb, ssss, , bbbbb]
Iterable split =[ssss, bbbbb, ssss, bbbbb]
List list =[ssss, bbbbb, ssss, bbbbb]

初始化创建

String[] arrays = ObjectArrays.newArray(String.class, 100);
//100 表示长度

Map<String, String> map = ImmutableMap.of("二维码","100","人脸","400");

//创建不可变的集合
ImmutableSet<String> type = ImmutableSet.of("人脸","二维码");
ImmutableSet<String> copy = ImmutableSet.copyOf(type);//返回不可变的集合

List 去重去除null

    /**
     * 去重和去除 null
     *
     * @param list
     * @return
     */
    public static List<String> distinctNull(List<String> list) {
        return ImmutableSet.copyOf(Iterables.filter(list, Predicates.not(Predicates.isNull()))).asList();
    }

双键map

Table<rowKeys, columnKeys, values>

@Data
public class TestDto implements Serializable {
    private String name;
}

// 1. 双键测试
Table<String, String, TestDto> table = HashBasedTable.create();
TestDto dto=new TestDto();
dto.setName("name1");
table.put("1", "a", dto);
//
TestDto dto2=new TestDto();
dto2.setName("name2");
table.put("1", "b", dto2);
//
TestDto dto3=new TestDto();
dto3.setName("name3");
table.put("2", "a", dto3);
//
TestDto dto4=new TestDto();
dto4.setName("name4");
table.put("2", "b", dto4);

System.out.println(table.get("1", "a"));
System.out.println(table.get("1", "b"));
System.out.println(table.get("2", "a"));
System.out.println(table.get("2", "b"));

输出

TestDto(name=name1)
TestDto(name=name2)
TestDto(name=name3)
TestDto(name=name4)

获取对应列集合

接着上面代码

//
		//rowKey或columnKey的集合
		Set<String> rowKeys = table.rowKeySet();
		Set<String> columnKeys = table.columnKeySet();
		//value集合
		Collection<TestDto> values = table.values();
		System.out.println(rowKeys);
		System.out.println(columnKeys);
		System.out.println(values);

输出

[1, 2]
[a, b]
[TestDto(name=name1), TestDto(name=name2), TestDto(name=name3), TestDto(name=name4)]

输出内容

//
        for (String key : table.rowKeySet()) {
            Set<Map.Entry<String, TestDto>> rows = table.row(key).entrySet();
            System.out.println("rows:" + rows);
            for (Map.Entry<String, TestDto> row : rows) {
                System.out.println("row:" + row);
            }
        }

输出

rows:[a=TestDto(name=name1), b=TestDto(name=name2)]
row:a=TestDto(name=name1)
row:b=TestDto(name=name2)
rows:[a=TestDto(name=name3), b=TestDto(name=name4)]
row:a=TestDto(name=name3)
row:b=TestDto(name=name4)

转换rowKey和columnKey

Table<String, String, TestDto> table2 = Tables.transpose(table);
        Set<Table.Cell<String, String, TestDto>> cells = table2.cellSet();
        cells.forEach(cell->
                System.out.println(cell.getRowKey()+","+cell.getColumnKey()+":"+cell.getValue())
        );

输出

a,1:TestDto(name=name1)
b,1:TestDto(name=name2)
a,2:TestDto(name=name3)
b,2:TestDto(name=name4)

转为嵌套的Map

 Map<String, Map<String, TestDto>> rowMap = table.rowMap();
        Map<String, Map<String, TestDto>> columnMap = table.columnMap();
        System.out.println("rowMap:" + rowMap);
        System.out.println("columnMap:" + columnMap);

输出

rowMap:{1={a=TestDto(name=name1), b=TestDto(name=name2)}, 2={a=TestDto(name=name3), b=TestDto(name=name4)}}
columnMap:{a={1=TestDto(name=name1), 2=TestDto(name=name3)}, b={1=TestDto(name=name2), 2=TestDto(name=name4)}}

BiMap - 双向Map : 根据value查找对应的key

HashBiMap的value是禁止重复的,如果需要更新替换,那么请用biMap.forcePut("卡","900");

HashBiMap<String, String> biMap = HashBiMap.create();
        biMap.put("二维码","100");
        biMap.put("人脸","200");
        biMap.put("卡","300");
        biMap.put("身份证","400");
        biMap.put("替换测试","900");
        biMap.forcePut("替换测试","1000");//强制更新替换
        //使用key获取value
        System.out.println(biMap.get("身份证"));
        BiMap<String, String> inverse = biMap.inverse();
        //使用value获取key
        System.out.println(inverse.get("300"));

输出

400

Multimap - 多值Map

Multimap<String, String> multimap = ArrayListMultimap.create();
        multimap.put("类型","二维码");
        multimap.put("类型","人脸");
        multimap.put("类型","身份证");
        multimap.put("类型","卡");
        multimap.put("人","小王");
        multimap.put("人","小刘");
        System.out.println(multimap);

输出

{=[小王, 小刘], 类型=[二维码, 人脸, 身份证, 卡]}
ArrayListMultimap<String, String> multimap = ArrayListMultimap.create();
        multimap.put("类型","二维码");
        multimap.put("类型","人脸");
        multimap.put("类型","身份证");
        multimap.put("类型","卡");
        multimap.put("人","小王");
        multimap.put("人","小刘");
        List<String> type = multimap.get("类型");
        List<String> user = multimap.get("人");
        System.out.println(type);
        System.out.println(user);

输出

[二维码, 人脸, 身份证, 卡]
[小王, 小刘]

RangeMap - 范围Map

价格区间判断

RangeMap<Integer, String> rangeMap = TreeRangeMap.create();
        //  0<= 范围   <100
        rangeMap.put(Range.closedOpen(0, 100), "没有优惠");
        //  100<= 范围   <500
        rangeMap.put(Range.closedOpen(100, 500), "优惠70");
        //  500<= 范围   <=1000
        rangeMap.put(Range.closed(500, 1000), "8折优惠");
        //  1000<= 范围   <=10000
        rangeMap.put(Range.openClosed(1000, 10000), "5折优惠");
        System.out.println("59:"+rangeMap.get(59));
        System.out.println("100:"+rangeMap.get(100));
        System.out.println("200:"+rangeMap.get(200));
        System.out.println("500:"+rangeMap.get(500));
        System.out.println("600:"+rangeMap.get(600));
        System.out.println("1200:"+rangeMap.get(1200));
        System.out.println("1000:"+rangeMap.get(1000));
        System.out.println("1001:"+rangeMap.get(1001));

输出

59:没有优惠
100:优惠70
200:优惠70
500:8折优惠
600:8折优惠
1200:5折优惠
1000:8折优惠
1001:5折优惠

ClassToInstanceMap - 实例Map

@Data
public class OrderDto implements Serializable {
    private String orderNo;
    private String orderId;
}
@Data
public class TestDto implements Serializable {
    private String name;
}

ClassToInstanceMap<Object> instanceMap = MutableClassToInstanceMap.create();
        OrderDto order = new OrderDto();
        order.setOrderId("1");
        order.setOrderNo("100000001");
        TestDto dto = new TestDto();
        dto.setName("name1");
        instanceMap.putInstance(OrderDto.class, order);
        instanceMap.putInstance(TestDto.class, dto);
        System.out.println("OrderDto:" + instanceMap.get(OrderDto.class));
        System.out.println("TestDto:" + instanceMap.get(TestDto.class));

输出

OrderDto:OrderDto(orderNo=100000001, orderId=1)
TestDto:TestDto(name=name1)

筛选

筛选订单数据类型为 SUCCESS

@Data
public class OrderDto implements Serializable {
    private String orderNo;
    private String orderId;
    private String type;
}

//
OrderDto dto = new OrderDto();
        dto.setOrderId("1");
        dto.setOrderNo("100000001");
        dto.setType("SUCCESS");
        OrderDto dto2 = new OrderDto();
        dto2.setOrderId("2");
        dto2.setOrderNo("100000002");
        dto2.setType("NOT_PAID");
        OrderDto dto3 = new OrderDto();
        dto3.setOrderId("3");
        dto3.setOrderNo("100000003");
        dto3.setType("CHECK");
        //
        List<OrderDto> list = Lists.newArrayList(dto, dto2, dto3);
        System.out.println("OrderDto:" + list);
        ImmutableMultiset<OrderDto> orderDtos = ImmutableMultiset.copyOf(Collections2.filter(list, new Predicate<OrderDto>() {
            @Override
            public boolean apply(OrderDto orderDto) {
                return "SUCCESS".equals(orderDto.getType());
            }
        }));
        System.out.println("filter:SUCCESS:" + orderDtos);

输出

OrderDto:[OrderDto(orderNo=100000001, orderId=1, type=SUCCESS), OrderDto(orderNo=100000002, orderId=2, type=NOT_PAID), OrderDto(orderNo=100000003, orderId=3, type=CHECK)]

filter:SUCCESS:[OrderDto(orderNo=100000001, orderId=1, type=SUCCESS)]

获取对象某一个列,返回数组

OrderDto dto = new OrderDto();
        dto.setOrderId("1");
        dto.setOrderNo("100000001");
        dto.setType("SUCCESS");
        OrderDto dto2 = new OrderDto();
        dto2.setOrderId("2");
        dto2.setOrderNo("100000002");
        dto2.setType("NOT_PAID");
        OrderDto dto3 = new OrderDto();
        dto3.setOrderId("3");
        dto3.setOrderNo("100000003");
        dto3.setType("CHECK");
        //
        List<OrderDto> list = Lists.newArrayList(dto, dto2, dto3);
        System.out.println("OrderDto:" + list);
        List<String> transform = Lists.transform(list, new Function<OrderDto, String>() {
            @Override
            public String apply(OrderDto input) {
                return input.getOrderId();
            }
        });
        System.out.println("transform:" + transform);

输出

OrderDto:[OrderDto(orderNo=100000001, orderId=1, type=SUCCESS), OrderDto(orderNo=100000002, orderId=2, type=NOT_PAID), OrderDto(orderNo=100000003, orderId=3, type=CHECK)]
//
transform:[1, 2, 3]

排序

只对可排序类型做排序(数字,日期)

List<String> list = Lists.newArrayList("100", "2", "900", "313", "41", "544", "15", "25", "二维码", "人脸", "卡");

        //natural 正序排序
        Ordering<Comparable> natural = Ordering.natural();
        list.sort(natural);
        System.out.println(list);
        //反转 反过来
        list.sort(natural.reverse());
        System.out.println(list);

        List<Integer> ints = Lists.newArrayList(121, 12, 13, 433, 3, 444, 7, 5);
        //natural 正序排序
        ints.sort(natural);
        System.out.println(ints);
        //反转 反过来
        ints.sort(natural.reverse());
        System.out.println(ints);

输出

[100, 15, 2, 25, 313, 41, 544, 900, 二维码, 人脸, 卡]
[卡, 人脸, 二维码, 900, 544, 41, 313, 25, 2, 15, 100]
[3, 5, 7, 12, 13, 121, 433, 444]
[444, 433, 121, 13, 12, 7, 5, 3]

按首字母排序

List<String> list = Lists.newArrayList("100", "2", "900", "313", "41", "544", "15", "25", "二维码", "人脸", "卡");
        // 按首字母
        Ordering<String> stringOrdering = new Ordering<String>() {
            @Override
            public int compare(String left, String right) {
                return Collator.getInstance(Locale.CHINA).compare(left, right);
            }
        };
        list.sort(stringOrdering);
        System.out.println(list);

输出

[100, 15, 2, 25, 313, 41, 544, 900, 二维码, 卡, 人脸]

按名字首字母排序

@Data
public class OrderDto implements Serializable {
    private String orderNo;
    private String orderId;
    private String type;
    private String customer;
}

        /**
         * 按 name 排序,一定要判断一下对比的对象以及字段为null的情况,不然会bug的,虽然你当时可能不会报错。
         */
        Ordering<OrderDto> ordering = new Ordering<OrderDto>() {
            @Override
            public int compare(OrderDto left, OrderDto right) {
                if (left == null && right == null) {
                    return 0;
                }
                if (left == null) {
                    return 1;
                }
                if (right == null) {
                    return -1;
                }
                if (left.getOrderId() == null && right.getOrderId() == null) {
                    return 0;
                }
                if (left.getOrderId() == null) {
                    return 1;
                }
                if (right.getOrderId() == null) {
                    return -1;
                }
                return Collator.getInstance(Locale.CHINA).compare(left.getCustomer(), right.getCustomer());
            }
        };
        OrderDto dto = new OrderDto();
        dto.setOrderId("1");
        dto.setOrderNo("100000001");
        dto.setType("SUCCESS");
        dto.setCustomer("张三");
        OrderDto dto2 = new OrderDto();
        dto2.setOrderId("2");
        dto2.setOrderNo("100000002");
        dto2.setType("NOT_PAID");
        dto2.setCustomer("李四");
        OrderDto dto3 = new OrderDto();
        dto3.setOrderId("3");
        dto3.setOrderNo("100000003");
        dto3.setType("CHECK");
        dto3.setCustomer("啊黄");
        List<OrderDto> list = Lists.newArrayList(dto, dto2, dto3);
        System.out.println("OrderDto:" + list);
        list.sort(ordering);
        System.out.println("ordering:" + list);
        list.forEach(item -> System.out.print(item.getCustomer() + " " + item + "\n"));

输出

OrderDto:[OrderDto(orderNo=100000001, orderId=1, type=SUCCESS, customer=张三), OrderDto(orderNo=100000002, orderId=2, type=NOT_PAID, customer=李四), OrderDto(orderNo=100000003, orderId=3, type=CHECK, customer=啊黄)]
ordering:[OrderDto(orderNo=100000003, orderId=3, type=CHECK, customer=啊黄), OrderDto(orderNo=100000002, orderId=2, type=NOT_PAID, customer=李四), OrderDto(orderNo=100000001, orderId=1, type=SUCCESS, customer=张三)]

啊黄 OrderDto(orderNo=100000003, orderId=3, type=CHECK, customer=啊黄)
李四 OrderDto(orderNo=100000002, orderId=2, type=NOT_PAID, customer=李四)
张三 OrderDto(orderNo=100000001, orderId=1, type=SUCCESS, customer=张三)

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

风.foxwho

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值