JAVA中 map list Stream流

@航空母舰

已于 2024-09-03 14:20:53 修改

阅读量5k

点赞数 1

分类专栏： Java 文章标签： map

于 2021-03-10 16:29:53 首次发布

本文链接：https://blog.csdn.net/hudeyong926/article/details/114638987

版权

Java 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

MAP

java为数据结构中的映射定义了一个接口java.util.Map,他实现了四个类，分别是：HashMap，HashTable，LinkedHashMap，TreeMap 。Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。Map不允许键重复，但允许值重复

1.HashMap：

最常用的Map，根据键的hashcode值来存储数据，根据键可以直接获得他的值（因为相同的键hashcode值相同，在地址为hashcode值的地方存储的就是值，所以根据键可以直接获得值），具有很快的访问速度，遍历时，取得数据的顺序完全是随机的，HashMap最多只允许一条记录的键为null，允许多条记录的值为null，HashMap不支持线程同步，即任意时刻可以有多个线程同时写HashMap，这样对导致数据不一致，如果需要同步，可以使用synchronziedMap的方法使得HashMap具有同步的能力或者使用concurrentHashMap。HashMap是输出数据时无序的，即不会记录插入的顺序。

2.HashTable：

与HashMap类似，不同的是，它不允许记录的键或值为空，支持线程同步，即任意时刻只能有一个线程写HashTable，因此也导致HashTable在写入时比较慢!

3.LinkedHashMap：

是HashMap的一个子类，但它保持了记录的插入顺序，遍历时先得到的肯定是先插入的，也可以在构造时带参数，按照应用次数排序，在遍历时会比HahsMap慢，不过有个例外，当HashMap的容量很大，实际数据少时，遍历起来会比LinkedHashMap慢（因为它是链啊），因为HashMap的遍历速度和它容量有关，LinkedHashMap遍历速度只与数据多少有关

4.TreeMap：

实现了sortMap接口，能够把保存的记录按照键排序（默认升序）如果需要降序使用java.util包中DescendingMap()，也可以指定排序比较器，遍历时得到的数据是排过序的

5.MultiValueMap

即一个键对应多个值,Spring的内部实现是LinkedMultiValueMap。使用场景：批量功能

6.IdentityHashMap

有一种key值可以重复的map.IdentityHashMap在比较键（和值）时使用引用相等性（==）而不是Map的equals()方法。IdentityHashMap使用引用相等性，因此两个键分别存储在内存中，因此它们的引用是不相等的。

//内存中有两个相似但不同的实例
Integer key1 = new Integer(10);
Integer key2 = new Integer(10);

//IdentityHashMap中的相同key
IdentityHashMap<Integer, String> identityHashMap = new IdentityHashMap<>();
identityHashMap.put(key1, "India");
identityHashMap.put(key2, "USA");
//Identity HashMap : {10=USA, 10=India}
System.out.println("Identity HashMap : " + identityHashMap);

keySet排序

Hashtable.keySet() 降序
TreeMap.keySet() 升序
HashMap.keySet() 乱序
LinkedHashMap.keySet() 原序

TreeMap<String,String> map = new TreeMap<String, String>();
map.put("name", "zychen");
map.put("password", "123456");
map.put("project", "base");
map.put("tenantId", "192319387131");
map.descendingMap();

//根据指定的key获取对应的value
Object name = map.get("name");
if (name instanceof String) {  //判断键值是否为String类型
    String value = (String) name;  //获取指定的value值
}

//通过key遍历
for (String key: map.keySet()) {
    System.out.println("value:" + map.get(key));
}

MultiValueMap<String, String> valueMap = new LinkedMultiValueMap<>();
valueMap.add("1", "1");
valueMap.add("1", "2");
valueMap.add("1", "3");
valueMap.add("1", "4");
valueMap.add("1", "5");
valueMap.add("2", "1");
valueMap.add("2", "2");
valueMap.add("3", "1");
for (Map.Entry<String, List<String>> stringListEntry : valueMap.entrySet()) {
  System.out.println("key:" + stringListEntry.getKey());
  List<String> value = stringListEntry.getValue();
  System.out.println("value:" + value);
}

什么情况用什么类型的Map：

在Map中插入，删除，定位元素：HashMap
要按照自定义顺序或自然顺序遍历：TreeMap
要求输入顺序和输出顺序相同：LinkedHashMap

Map 缓存

如果 Map 中不存在这个键，可以设置。存在后就不能覆盖设置

Map<String, Integer> map = new HashMap<>();
map.put("key", 10);
 
int value = map.computeIfAbsent("key", k -> 20);
 
System.out.println(value); // 输出: 10
System.out.println(map.get("key")); // 输出: 10

Map遍历

public static void main(String[] args) {
  //创建map集合对象
  Map<String, Integer> map = new HashMap<>();
  map.put("诸葛亮", 1);
  map.put("刘伯温", 2);
  map.put("张良", 3);
  map.put("东方朔", 4);
  map.put("东方朔", 5); //5 key值相同会被覆盖的特性

  map.containsKey("东方朔");

  //JDK8以下推荐写法
  for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey());
    System.out.println(entry.getValue());
  }

  //JDK8推荐写法，简捷
  map.forEach((key, value) -> {
    System.out.println(key);
    System.out.println(value);
  });
}

List

Vector：线程安全的。
ArrayList：适合查找与顺序添加。但增删较慢。线程不同步
LinkedList：适合随机插入与删除。查询较慢

List转String[]

List<String> list = new ArrayList<>();
list.add("mm");
list.add("nn");
list.add("hh");
String[] strings = list.toArray(new String[list.size()]);

List转String

LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println(lList);
lList.addFirst("0");
System.out.println(lList);
lList.addLast("6");
System.out.println(lList);

boolean res = llist.contains(4);
if (res == true) {
    System.out.println("包含");
}

ArrayList<String> list = new ArrayList<String>() ;
list.add("Tom");
System.out.println(list.contains("Tom"));
String allIndex = StringUtils.join(list,",");

Set<String> set = new HashSet<>();
set.add("hello1");
set.add("hello2");
set.add("hello3");
Object[] arr = set.toArray();
System.out.println(StringUtils.join(arr, ","));

//复制，2个内存空间
List<String> copy = new ArrayList<>(list);


List<ApiVO> result = new LinkedList<>();
List<Packages> agPkList = agMapper.getList(ordersNo);
for (Packages info : agPkList) {
  ApiVO vo = new ApiVO();
  BeanUtils.copyProperties(info, vo);
  result.add(vo);
}

for (Map.Entry<String, List<People>> entry : collects.entrySet()) {
    for (People people : entry.getValue()) {
        if (people.getOfflineUnfreeze().equals("1")) {
            System.out.println("对象:" + people.getPhone());
        }
    }
}

public void splitDemo4(){
    String str= "aaa,bbb#ccc";
    //使用,和#分割字符串
    String[] split = str.split(",|#");
    for (int i = 0; i < split.length; i++) {
        System.out.println(split[i]);
    }
}

List 分割

在工作中经常遇到需要将数组分割成多个子数组，然后进行批量处理的需求。那有没有比较优雅的实现呢

引入依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>

代码演示

public static void main(String[] args) {
    //初始化数组
    List<Integer> parList = new ArrayList<>();
    IntStream.range(0, 30).forEach(parList::add);
 
    //分割成子数组
    List<List<Integer>> subList = ListUtils.partition(parList, 10);
 
    //遍历子数组
    subList.forEach(list -> {
        System.out.println(String.format("subList size:%s", list.size()));
        System.out.println(String.format("list:%s", list.toString()));
    });
}

Stream

`Map`转换为`List`

List<String> list = Lists.newArrayList("a", "b", "c", "a", "e", "f");
String result = list.stream().collect(Collectors.joining()); //输出为 abcdef
String result = list.stream().collect(Collectors.joining(",")); //输出为 a,b,c,d,e,f

List<String> valueList = linkedMap.values().stream().collect(Collectors.toList());

过滤筛选

List<Product> math = prodList.stream().filter(
    product -> product.getCategory().contains("啤酒") && "百威啤酒".equals(product.getName()))
    .collect(Collectors.toList());

提取 List 中的某个字段

List<Integer> ids = list.stream().map(User::getId).collect(Collectors.toList());

根据单一字段分组

Product prod1 = new Product(1L, 1, new BigDecimal("15.5"), "面包", "零食");
Product prod2 = new Product(2L, 2, new BigDecimal("20"), "饼干", "零食");
Product prod3 = new Product(3L, 3, new BigDecimal("30"), "月饼", "零食");
Product prod4 = new Product(4L, 3, new BigDecimal("10"), "青岛啤酒", "啤酒");
Product prod5 = new Product(5L, 10, new BigDecimal("15"), "百威啤酒", "啤酒");
Product prod6 = new Product(5L, 7, new BigDecimal("25"), "百威啤酒", "啤酒");

List<Product> prodList = List.of(prod1, prod2, prod3, prod4, prod5, prod6);
Map<String, List<Product>> map1 = prodList.stream().collect(Collectors.groupingBy(Product::getCategory));

输出结果：

啤酒=[Product{id=4, num=3, price=10, name='青岛啤酒', category='啤酒'}, Product{id=5, num=10, price=15, name='百威啤酒', category='啤酒'}, Product{id=5, num=7, price=25, name='百威啤酒', category='啤酒'}]
    
零食=[Product{id=1, num=1, price=15.5, name='面包', category='零食'}, Product{id=2, num=2, price=20, name='饼干', category='零食'}, Product{id=3, num=3, price=30, name='月饼', category='零食'}]

根据不同条件分组

Map<String, List<Product>> map3 = prodList.stream().collect(Collectors.groupingBy(item -> {
    if (item.getNum() > 3) {
        return "num大于3";
    } else if (item.getNum() < 3) {
        return "num小于3";
    } else {
        return "num等于3";
    }
}));
Set<Map.Entry<String, List<Product>>> entries3 = map3.entrySet();
for (Map.Entry<String, List<Product>> entry : entries3) {
    System.out.println(entry);
}

输出结果

num小于3=[Product{id=1, num=1, price=15.5, name='面包', category='零食'}, Product{id=2, num=2, price=20, name='饼干', category='零食'}]
    
num等于3=[Product{id=3, num=3, price=30, name='月饼', category='零食'}, Product{id=4, num=3, price=10, name='青岛啤酒', category='啤酒'}]
    
num大于3=[Product{id=5, num=10, price=15, name='百威啤酒', category='啤酒'}, Product{id=5, num=7, price=25, name='百威啤酒', category='啤酒'}]

使用分组减少循环层数

for (AccountRelationVo relationVo : relationList) {
    for (GatewayRoutingPageVo gatewayRoutingVo : gatewayRoutingList) {
        if (relationVo.getGatewayName().equals(gatewayRoutingVo.getName())) {
            BeanUtils.copyProperties(gatewayRoutingVo, relationVo);
            break;
        }
    }
}
//使用分组后
for (AccountRelationVo relationVo : relationList) {
    BeanUtils.copyProperties(gatewayRoutingMapList.get(relationVo.getGatewayName()), relationVo);
}

去重

list = list.stream().distinct().collect(Collectors.toList());

toMap键值对

toMap(Function, Function) 返回一个 Collector，它将元素累积到一个 Map中，其键和值是将提供的映射函数应用于输入元素的结果。

// 获取正确的<id, phoneNum> map 报空指针，解决方案
Map<Integer, String> stringMap = new HashMap();
if (Phones.size() > 0) {
  stringMap = Phones.stream().collect(Collectors.toMap(Phones::getId,e -> e.getPhoneNum() == null ? "" : e.getPhoneNum()));
}

/**
 * id作为Map的key,name作为value的集合
 */
Map<Integer, String> collect1 = employeeList.stream().collect(Collectors.toMap(Employee::getId, Employee::getName));
System.out.println(collect1);//{101=张三, 102=李四, 103=王五, 104=赵六}

forEach

对于java8中的特殊写法lamada表达式中，不能使用break，会提示错误;java8中使用return，会跳出当前循环，继续下一次循环，作用类似continue;

foreach循环可以遍历输出数组里面的元素，但是不能通过foreach来修改元素.

做forEach，需要把外面的变量赋值如int,long,boolean，需要外面定义原子类型AtomicReference

//循环遍历赋值
list.forEach(f -> f.setCallId("'" + f.getCallId()));

list.forEach(objTrunk -> {
  user.setAreaCode(objTrunk.getAreaCode());
});

AtomicReference<Boolean> isAiExecSuccess = new AtomicReference<>(false);
operationRecords.forEach(rec -> {
  if (StringUtils.isNotEmpty(rec.getRemark())) {
    if (rec.getRemark().equals("数据执行成功")) {
      isAiExecSuccess.set(true);
      return;
    }
  }
});