我们如果想要获取某个map的值怎么做呢?
 
 
package main

import "fmt"

func main() {

    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }

    fmt.Println("Geting values")
    courseName := m["a"]
}
 
 
如果获取了一个不存在的key 怎么处理呢?
 
 
例如:
 
 
package main

import "fmt"

func main() {

    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }

    fmt.Println("Geting values")
    courseName := m["d"]
}
 
 
输出结果会为空字串. 我们怎么防止空字串的问题呢?
 
 
package main

import "fmt"

func main() {

    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }

    fmt.Println("Geting values")
    courseName, ok := m["a"]
    fmt.Println(courseName,ok)
    if courseName, ok := m["d"]; ok{
        fmt.Println(courseName)
    }else{
        fmt.Println("key does not exist")
    }
}
 
 
这里我们使用到了两个变量接受值. 用第二个值来判断boolean值
 
 
 

获取List<Map<String, Object>中Map的属性值列表，
 
获取所有map对象的某个属性列表
 
 
================================
 
©Copyright 蕃薯耀 2021-06-29
 
https://blog.csdn.net/w995223851
 
 
/**
     * 获取List列表中的Map对象属性的值
     * @param <T>
     * @param list List<Map<String, Object>> 
     * @param mapValueName Map对象属性名
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static <T> List<T> getMapValues(List<Map<String, Object>> list, String mapValueName) throws Exception{
        
        log.info("mapValueName = " + mapValueName);
        
        if(StringUtils.isBlank(mapValueName)) {
            throw new ValidationException("Map对象属性名不能为空");
        }
        
        List<T> objectidList = new ArrayList<T>();
        
        for (Map<String, Object> map : list) {
            objectidList.add((T) map.get(mapValueName));
        }
        return objectidList;
    }
 
 
Main方法
 
 public static void main(String[] args) throws Exception {

        List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
        Map<String, Object> map1 = new HashMap<String, Object>();
        map1.put("name", "aa");
        map1.put("age", 25);
        map1.put("long", 10000000000L);
        map1.put("double", 10000.25d);
        
        
        Map<String, Object> map2 = new HashMap<String, Object>();
        map2.put("name", "bb");
        map2.put("age", 24);
        map2.put("long", 20000000000L);
        map2.put("double", 20000.25d);
        
        Map<String, Object> map3= new HashMap<String, Object>();
        map3.put("name", "cc");
        map3.put("age", 26);
        map3.put("long", 30000000000L);
        map3.put("double", 30000.25d);
        
        list.add(map1);
        list.add(map2);
        list.add(map3);
        
        List<String> listResult = getMapValues(list, "name");
        System.out.println(listResult);
        
        List<Integer> listAge = getMapValues(list, "age");
        System.out.println(listAge);
        
        List<Long> listLong = getMapValues(list, "long");
        System.out.println(listLong);
        
        List<Long> listDouble = getMapValues(list, "double");
        System.out.println(listDouble);
    }
 
 
输出结果：
 
mapValueName = name
[aa, bb, cc]

mapValueName = age
[25, 24, 26]

mapValueName = long
[10000000000, 20000000000, 30000000000]

mapValueName = double
[10000.25, 20000.25, 30000.25]
 
 
 
================================
 
©Copyright 蕃薯耀 2021-06-29
 
https://blog.csdn.net/w995223851

 1、方式一：使用TreeSet去重
 
 
 
      List<Map<String,String>>  dataList = dataList .stream().collect(
                 collectingAndThen(toCollection(() -> new TreeSet<>(Comparator.comparing( o -> o.get("id") ))),
                         ArrayList::new)
 
 
       );
 
 
2、方式二：使用map去重
 
 
 
     List<Map<String,String> dataList = dataList .stream()
                 .filter(distinctByKey(o -> o.get("id") ))
                 .collect(Collectors.toList());
    
 
 
    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
         Map<Object, Boolean> seen = new ConcurrentHashMap<>();
         return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
     }
 
 
 2.1、Map集合中put与putIfAbsent的区别
 
 
 
V put(K key, V value);       
 
 
V putIfAbsent(K key, V value)；
 
 
这两种方法都是以key-value键值对的形式存在到map集合中，返回的都是上一次的值。 如果上次没值，直接返回null.
 
 
我们可以从map官网注释中看出：
 
1.使用put方法添加键值对，如果map集合中没有该key对应的值，则直接添加，并返回null；如果已经存在对应的值，则会覆盖旧值，value为新的值；并返回 旧值。
 
2.使用putIfAbsent方法添加键值对，如果map集合中没有该key对应的值，则直接添加，并返回null；如果已经存在对应的值，则value依旧为原来的值。并返回 原来的值。
 
 
 
public class Java8StreamTest {

    public static class Book{

        private String id;

        private String name;

        public Book(String id, String name) {
            this.id = id;
            this.name = name;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Book{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
        }
    }

    @Test
    public void testUnique(){
        List<Book> books = Lists.newArrayList(new Book("1","1"),new Book("2","2"),new Book("3","3"),new Book("2","2"));

		//方式一：使用TreeSet去重
        List<Book> unique1 = books.stream().collect(
                collectingAndThen(toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getId()))),
                        ArrayList::new));

        System.out.println(unique1);

		//方式二：使用map去重
        List<Book> unique2 = books.stream()
                .filter(distinctByKey(o -> o.getId()))
                .collect(Collectors.toList());
        System.out.println(unique2);

    }

    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        System.out.println("这个函数将应用到每一个item");
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

}
 
 

有两种情况：
 
1.map的key已知为某字符串常量，要查对应value。
 
<#list list as item >
 ${item["total"]}
 </#list>
 
 

 
 
例子中,item是一个List<Map>一个map对象。
 
想要得到map.get("total")同效果的值，使用${item["total"]}。
 

 
 
2.map的key需要进行动态获取，以查对应value。
 
<#list list as item>
 <tr>
 <td>${item_index + 1}</td>
 <td style="text-align: left">${item["title"]}</td>
 <#list zyList as key>
 <td rowspan="1">${item[key]}</td>
 </#list>
 <td>${item["total"]}</td>
 </tr>
 </#list>
 
 
例子中的list与item同上。
 
zyList是一个List<String>的实例对象。
 
key为zyList某次得到的某个String对象。
 
key的值在是动态得到的。
 
因此使用${item[key]}来获得。