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

已于 2022-05-24 18:31:24 修改
阅读量6.1k 收藏 3
点赞数
分类专栏： java 文章标签： java guava
于 2019-07-10 13:03:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fenglailea/article/details/95324469
版权

引入依赖

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=张三)
风.foxwho
关注
专栏目录
java guava map_Guava - Map
weixin_33172127的博客
02-16 705
创建Map通常在创建map时使用new HashMap<>();的方法，guava提供了一个简洁的方法Maps.newHashMap();List转换MapList list= new ArrayList<>();//普通写法Map map= Maps.newHashMap();for(Solution a:list){map.put(a.id,a);}//Maps.uni...
java集合分组(Guava)
03-11
因工作的需要，利用Guave对集合进行分组。这是个最简单的例子，希望对大家有用。
Guava之Maps教程
热门推荐
neweastsun的专栏
04-14 3万+
Guava之Maps教程 本文我们学习Guava Maps对java Map封装和升级，实现强大、简洁应用方式。 首先让我们看看Guava不用new创建HashMap： Map&lt;String, String&gt; aNewMap = Maps.newHashMap(); ImmutableMap 创建不可变Map： @Test public void...
Java三维数组
最新发布
weixin_63490470的博客
08-11 579
三维数组是一种用于存储三维数据的数据结构，通常用于表示三维空间中的数据，如立方体、三维矩阵等。通过声明、初始化、访问、修改和遍历三维数组，可以方便地管理和操作三维数据。三维数组的每个元素都有三个索引，分别表示三个维度的位置。理解三维数组的结构和用途，可以更好地选择和使用适合的数据结构来处理不同类型的数据。
利用guava创建MapCache
baidu_20608025的博客
01-16 1058
LoadingCache&lt;String, Object&gt; DETECTION_RULE_CACHE = CacheBuilder.newBuilder() //设置并发级别为8，并发级别是指可以同时写缓存的线程数 .concurrencyLevel(8) //设置写缓存后8秒钟过期 //....
guava之map
jackyrongvip的专栏
11-19 408
先来看下传统方法建立map,list: List list = new ArrayList(); Map map = new HashMap(); 有了guava，则可以简单了： List list = Lists.newArrayList(); Map list = Maps.newHashMap(); 用到的是lists,maps的工具...
【最佳工具库】：Java字符串到数组转换的第三方库使用指南
Java字符串到数组转换的基本概念 在编程世界中，字符串与数组是数据处理的基础结构。Java中，字符串到数组的转换是常见的需求，尤其在处理文本数据时。理解这一转换的原理和方法，对于提升数据处理能力和优化程序...
【Java字符串分割：高效替代方案】：Guava库字符串分割的性能优势解析
![【Java字符串分割：高效替代方案】：Guava库字符串分割的性能优势解析]...在Java中，字符串分割功能通常涉及到内置的`split`方法，以及第三方库如Guava提供的高级字
Java代码优化：字符串数组处理的性能挑战与解决方案
字符串对象在Java中是不可变的，意味着一旦创建，其内容不能被改变。这一特性在提高线程安全的同时，也可能带来性能上的开销。为了高效地使用字符串，开发者必须掌握其性能特性，包括内存占用和处理速度，尤其是在...
字符串转换数组的艺术：Java分隔符处理的高级技巧
[字符串转换数组的艺术：Java分隔符处理的高级技巧](https://beginnersbook.com/wp-content/uploads/2013/12/Java_String_trim_method_example.jpg) # 1. 字符串与数组的转换基础 在编程世界中，字符串与数组的相互...
字符串与数组的转换比拼：Java中转换方法的性能对决
[字符串与数组的转换比拼：Java中转换方法的性能对决](https://www.javastring.net/wp-content/uploads/java-string-join-multiple-array-elements.png) # 1. 字符串与数组转换的理论基础 在计算机科学领域中，字符...
使用guava对list进行分割
weixin_33762130的博客
10-28 3660
实例 List<User> users = userService.findAll(); //按每50个一组分割 List<List<User>> parts = Lists.partition(users, 50); parts.stream().forEach(list -> { ...
Guava（四）：集合基础总结之Map
lly576403061的博客
09-19 3111
其实Guavad的集合操作适合我们平时使用的原生的集合是一样的，只是他将我们平时操作的集合更加的流畅优雅加单。其实Map就和List一样也是在创建的时候和其他的一些很赞的方法，但是呢好像这些方法我们平时的工作中用到的很少，但是呢我们还是来看看把。 首先说一下这几个方法： 1：创建Map方法： Map,String> guavaMap = Maps.newHashMap(); 2：集合di
Guava中的封装的Map操作
熊與貓v
08-21 575
Guava是google公司开发的一款Java类库扩展工具包，内含了丰富的API，涵盖了集合、缓存、并发、I/O等多个方面。使用这些API一方面可以简化我们代码，使代码更为优雅，另一方面它补充了很多jdk中没有的功能，能让我们开发中更为高效。
guava:Cache中使用数组(Object[],int[]...)作为KEY
10km的专栏
11-15 1270
guava是google的一个开源的基础java库，其中提供了一个非常有用的缓存(cache)功能。创建cache的过程大概如下： LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder() .maximumSize(1000) .expireAfterWrite(10, TimeUnit.MINU...
从头认识java-15.7 Map（1）-使用数组来简单模拟Map的创建
raylee2007的专栏
12-30 2566
这一章节我们来使用数组模拟一下Map，了解一下Map的创建。1.Map是什么？Map，映射表，也叫关联数组，维护“键-值”的关联。2.使用数组模拟Mappackage com.ray.ch15; import java.util.HashSet; import java.util.Set; public class Test { public static void main(String[
两个Map对象合并成一个Map对象
m0_67391518的博客
04-28 4958
两个Map对象合并成一个Map对象 两个map合并所用函数为：putAll() 代码如下所示，展示了两个 map 对象的合并，如果是多个 map 合并也是用这种方式。 import java.util.HashMap; import java.util.Map; public class Test06 { public static void main(String[] args) { Map<String,Object> map1=new HashMap<Str
Java guava partition方法拆分集合&自定义集合拆分方法
zuihongyan518的博客
12-25 1284
使用Lists.partition方法进行集合拆分&自定义集合拆分方法
guava Lists下通过了两个创建指定容量的list方法，newArrayListWithExpectedSize，newArrayListWithCapacity。它们主要的区别如下：
种一颗十年前的树
11-16 1090
https://www.cnblogs.com/yorkd/p/12793088.html guava Lists下通过了两个创建指定容量的list方法，newArrayListWithExpectedSize，newArrayListWithCapacity。它们主要的区别如下： 源码： public static ArrayList newArrayListWithCapacity(int initialArraySize) { CollectPreconditions.checkNonnegati
guava中String数组转list
09-28
在Guava中，没有提供专门实现String数组不可变的类。但是你可以使用Guava中的ImmutableList类来实现String数组转为不可变的List。 下面是使用Guava中的ImmutableList实现String数组转为不可变的List的方法： ```java String[] arr = {"1", "2", "4", "6"}; List<String> list = ImmutableList.copyOf(arr); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

风.foxwho

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

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

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

打赏作者

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

抵扣说明：

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

余额充值