List＜Map＜String, Object＞＞——多层嵌套的数据结构

需求

【仓库明细表】增加【关联公司】列，取值于【仓库管理】中各仓库对应的【关联公司】；增加【合作期限】列，方便显示仓库合作时间。

实现步骤

明细表之前的数据早就已经从数据库中查询出来，而且新添加的数据在存储结构关联的表中也没有，因此把数据查询出来后，put进list中，便不用再修改存储结构

List＜Map＜String, Object＞＞

在其中使用了多层嵌套的数据结构，需要层层分解。
List＜Map＜String, Object＞＞首先可以看到两种结构，分别是List和Map。
那List＜Map＜String, Object＞＞不就是元素为Map的List吗？即List集合中的对象是一个Map对象,而这个Map对象的键是String类型,值是Object类型。

Map基础知识

Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键对象和一个值对象。其中，map中键可以是任意类型的对象,键对象不允许重复，每个键都有一个对应的值。值对象可以重复，并且值对象还可以是 Map 类型的。

键-值对（key-value）就如同数组中的下标和值，通过通过键找值就如同下标找数组值。

Map本身是一个接口，要使用Map需要通过子类进行对象实例化。

如声明Map<String, List> map = null;

对map方法名称的一些说明
get(Object key)：返回 Map 集合中指定键对象所对应的值。
put(K key, V value)：向 Map 集合中添加键-值对，返回 key 以前对应的 value，如果没有， 则返回 null
remove(Object key)：从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果没有，则返回null
entrySet()：返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry
keySet()：返回 Map 集合中所有键对象的 Set 集合

List

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下 >标）来访问List中的元素，这类似于Java的数组。

void add(String item)  //依次往后添加添加元素
void add(String item, int index) //在指定位置处添加元素
void remove(int position) //删除第几个元素（索引从0开始）
void remove(String item) //删除相同的元素
void removeAll() //删除所有元素

遍历List＜Map＜String,Object＞＞集合

import java.util.*;
public class HelloWorld {
    public static void main(String []args) {
    

	//定义一个List<Map<String,Object>>集合：
  	List<Map<String, Object>> listMaps = new ArrayList<Map<String, Object>>();
  	
  	//定义第一个Map<String,Object>集合，并在其中添加数据
    Map<String, Object> map1 = new HashMap<String, Object>();
    map1.put("1", "a");
    map1.put("2", "b");
    map1.put("3", "c");
    listMaps.add(map1);

	//定义第二个Map<String,Object>集合，并在其中添加数据
    Map<String, Object> map2 = new HashMap<String, Object>();
    map2.put("11", "aa");
    map2.put("22", "bb");
    map2.put("33", "cc");
    listMaps.add(map2);

	//第一种遍历List<Map<String,Object>>集合的方式
    for (Map<String, Object> map : listMaps) {
        for (String s : map.keySet()) {
            System.out.print(map.get(s) + "  ");
        }
    }
    System.out.println();  //打印结果：a  b  c  aa  bb  cc 

    System.out.println("========================");
    
    //第二种遍历方式
    for (int i = 0; i < listMaps.size(); i++) {
        Map<String, Object> map = listMaps.get(i);
        Iterator iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            String string = (String) iterator.next();
            System.out.println(map.get(string));
        }
    }
​    /**
​    打印结果：
​    a
​	b
​	c
​	aa
​	bb
​	cc
​	*/
​	
    System.out.println("++++++++++++++++++++++++++++");
    
	//第三种遍历方式
    for (Map<String, Object> map : listMaps) {
        for (Map.Entry<String, Object> m : map.entrySet()) {
            System.out.print(m.getKey() + "    ");
            System.out.println(m.getValue());
        }
    }
​    /**
​    打印结果：
​    1    a
​	2    b
​	3    c
​	11    aa
​	22    bb
​	33    cc
​    */
    System.out.println("-----------------------------");

	//List<Map<String,Object>>集合 Map<String,Object>集合的区别：
	 for (Map<String, Object> map : listMaps) {
		System.out.println("List<Map>的值："+ map);
   }
   /**打印结果：
​    List<Map>的值：{1=a, 2=b, 3=c}
​	List<Map>的值：{11=aa, 22=bb, 33=cc}
​	*/
​	
​	System.out.println(map1);
​	//打印结果：{1=a, 2=b, 3=c}
​	
​	//遍历map1集合
	for (Map.Entry<String, Object> m : map1.entrySet()) {
		System.out.print(m.getKey() + "    ");
		System.out.println(m.getValue());
	}
​	/**打印结果：
​	1    a
​	2    b
​	3    c
​	*/
​	
	for (Map<String, Object> map : listMaps) {
		map.forEach((e, k) -> {
			if(e.equals("11")){
				k = k + "11";
			}
			System.out.println("e:"+ e + ",k:" + k);
		});
    }
​    /** 打印结果：
​	e:11,k:aa11
​	e:22,k:bb
​	e:33,k:cc
​	e:1,k:a
​	e:2,k:b
​	e:3,k:c
​	*/

}