List 转为 Map<id, bean>
 
User是List对象的元素，List<User>
List对象的变量名为：userList
id 将作为 Map 的 Key
 
Map<String, User> idMap =
	userList.stream().collect(
		Collectors.toMap(User::getId, b->b)
	);
 
一主多子 javaBean List 转为 Map<id, Map<id, itemBean> >
 
一主，主Bean： User
 多子，子Bean： UserItem
 集合：List<User>
 转Map：Map<User_id, Map <UserItem_id, UserItem> >
 
 
 
一主多子的主javaBean为List对象的元素，List <User>
 此处List对象的变量为：userList
 
 
Map<String, Map<String, UserItem>> collect = 
	userList.stream().collect(
		Collectors.toMap(
			User::getId, b -> {
				return b.getUserItem().stream().collect(
						Collectors.toMap(UserItem::getId, c -> c)
				);
            }
        )
    );

1.根据传入的对象生成Map集合
 @Test
    public void test02(){
        User user = new User();
        user.setId(1);
        user.setName("Albert");
        user.setSex("男");
        try{
            Map<String, Object> map = getFieldVlaue(user);
            System.out.println("通过反射获取属性值："+map);
        }catch(Exception e) {

        }
    }

    /**
     * 利用反射生成map
     * @param obj
     * @return
     * @throws Exception
     */
    public static Map<String, Object> getFieldVlaue(Object obj) throws Exception {
        Map<String, Object> mapValue = new HashMap<String, Object>();
        Class<?> cls = obj.getClass();
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            String name = field.getName();
            String strGet = "get" + name.substring(0, 1).toUpperCase() + name.substring(1, name.length());
            Method methodGet = cls.getDeclaredMethod(strGet);
            Object object = methodGet.invoke(obj);
            String value = object != null ? object.toString() : "";
            mapValue.put(name, value);
        }
        return mapValue;
    }

一、最常见的初始化方式
 
先创建，再添加元素
 
List
 
从源码可以看出：
 
List 的默认长度为10
递增后的长度为先前长度的 1.5 倍
最大长度是 Integer.MAX_VALUE，即 2,147,483,647 或 0x7f ff ff ff
 
List<String> list = new ArrayList<>();
list.add("str1");
list.add("str2");
list.add("str3");
 
当元素是静态对象时，可以使用静态代码块在初始化时进行赋值
 
private static List<String> static_list = new ArrayList<>();
static {
    static_list.add("str1");
    static_list.add("str2");
    static_list.add("str3");
}
 
Map
 
从源码可以看出：
 
hashMap 的初始长度为 16
递增后的长度为之前的 2 倍
最大长度是 1<<30 - 1，即 1,073,741,824‬ - 8 或 0x40 00 00 00 - 1
 
Map<String, String> map = newHashMap<>();
map.put("key1", "value1");
map.put("key2", "value2");
map.put("key3", "value3");
 
当元素是静态对象时，可以使用静态代码块在初始化时进行赋值
 
private static Map<String, String> static_map = new HashMap<>();
static {
    static_map.put("key1", "value1");
    static_map.put("key2", "value2");
    static_map.put("key3", "value3");
}
 
二、使用双花括号在初始化的同时赋值
 
外层的 {} 定义了一个匿名内部类。内层的 {} 定义了一个实例初始化代码块。这个代码块在初始化内部类时执行。所以这里相当于定义了一个匿名内部类，并使用 add 添加元素来初始化。
 
但这种方式有几个缺点：
 
使用匿名内部类，会有效率上的损失。当然在大多数情况下，这点效率都是可接受的。
静态内部类持有所在外部类的引用。如果需要将 List 返回给到其他地方使用，可能造成内存泄漏。
 
List
 
List<String> list = new ArrayList<String>() {
 {
        add("str1");
        add("str2");
        add("str3");
}};
 
Map
 
Map<String, String> map = new HashMap<String, String>() {
{
        put("key1", "value1");
        put("key2", "value2");
        put("key3", "value3");
}};
 
三、利用Arrays工具类
 
List
 
Arrays.asList使用了静态内部类，该类继承自 AbstractList，实现了 RandomAccess，内部使用了一个数组来存储元素。注意：内部定义的 ArrayList 并没有实现 List 接口，所以也不支持修改元素。
 
ArrayList(E[] array) {
	a = Objects.requireNonNull(array);
}
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
 
查看源码可以发现，虽然 Arrays 和 ArrayList 都是在 java.utils 包下，但它们创建的 ArrayList 确是两个同名，但不同的东西。
 
Arrays 中声明了一个ArrayList 的内部类，但是该类不支持增删元素，如果使用了诸如 add 方法，在编译时不会报错，但运行时会报 UnsupportedOperationException
 
 由于 Arrays 的 asList 方法使用了 “变长参数列表”，因此即使直接使用多个字符串作为参数，在编译时也会被自动装包成数组。
 
List<String> list1 = Arrays.asList(new String[] {"str1 ", "str2", "str3"});

List<String> list2 = Arrays.asList("str1 ", "str2", "str3");
 
四、利用Lists工具类
 
List
 
List 工具类提供了一个 newArrayList 的静态方法，从源码可以看出，newArrayList 实际只是对 ArrayList 无参初始化方法的封装，然后通过遍历迭代器 Iterator，将迭代器中的所有元素加入 List 而已
 
public static <E> ArrayList<E> newArrayList(final Iterator<? extends E> iterator) {
	final ArrayList<E> list = newArrayList();
	Iterators.addAll(list, iterator);
	return list;
}
public static <E> ArrayList<E> newArrayList() {
	return new ArrayList<>();
}
public static <T> boolean addAll(final Collection<T> collection, final Iterator<? extends T> iterator) {
	Objects.requireNonNull(collection);
	Objects.requireNonNull(iterator);
	boolean wasModified = false;
	while (iterator.hasNext()) {
	    wasModified |= collection.add(iterator.next());
	}
	return wasModified;
}
 
Lists 提供了两个方法：一个是创建一个空列表；一个是创建空列表的同时遍历迭代器，将它的值添加到列表中。
 
List<String> list = Lists.newArrayList();
list1.add("str1");
list1.add("str2");
list1.add("str3");
 
注意：这里并不能用双花括号表达式直接添加元素
 
List<String> list = Lists.newArrayList(list.iterator());
 
五、利用Collections工具类
 
List
 
创建一个固定长度的 CopiesList，List 长度不能改变，且元素都一样，且也是不可改变的。Java在实现时，仅使用了一个空间，用来存存放元素，当N足够大时，可以节省空间和性能。
 
同样，和 Arrays 创建的 List 一样，都没有实现 List 接口，因此使用add方法，同样会在编译时报错java.lang.UnsupportedOperationException
 
 
CopiesList<String> list1 = Collections.nCopies(5, "str");
 
此外，Collections 还提供了一个为 List 一次性添加所有元素的方法，弥补了原先 List 只能添加 Collections，而不支持数组的缺憾。
 
List<String> list2 = new ArrayList<>();
Collections.addAll(list1, new String[]{"str1", "str2", "str3"});
Collections.addAll(list1, "str4", "str5", "str6");
 
六、流式转化
 
流是 Java8 的新特性，提供了一种类似 SQL 语句从数据库中查询数据的方式，通过封装好的函数和链式调用，高阶抽象并简化操作。
 
它可以对传入流内部的元素进行筛选、排序、聚合等中间操作（intermediate operate），最后由最终操作（terminal operation）得到前面处理的结果。
 
通过静态的 Stream.of 方法接收元素，然后通过 collect 方法处理得到最终结果。
 
List
 
List<String> list1 = Stream.of("str1", "str2", "str3").collect(Collectors.toList());
 
Map
 
Collectors.toMap() 知识点：
 
 
Java 8 中我们可以通过 :: 关键字来访问类的构造方法，对象方法，静态方法。
Java8 允许在接口中加入具体方法，接口中的具体方法有两种，default 方法和 static 方法，identity () 就是 Function 接口的一个静态方法。Function.identity() 是一个返回一个跟输入一样的 Lambda 表达式对象，形式为 t -> t 。
 
第三个参数是合并函数，如果不指定 mergeFunction，当存在两个 key 相同的元素时，会报 java.lang.IllegalStateException: Duplicate key g1 at java.util.stream.Collectors.lambda$throwingMerger 错误。 
  
key相同时当前值替换原始值
 (oldVal, currVal) -> currVal
key相同时保留原始值
 (oldVal, currVal) -> oldVal
 
 
Test.java
 
Map<String, Book> map = books.stream()
	.sorted(Comparator.comparing(Book::getISBN))
	.collect(Collectors.toMap(Book::getISBN, Function.identity(), (oldVal, currVal) -> oldVal));
 
Book.java
 
public class Book {
    public String name;
    public String author;
    public float price;
    public String ISBN;

    public Book(String name, String author, float price, String ISBN) {
        this.name = name;
        this.author = author;
        this.price = price;
        this.ISBN = ISBN;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getName() {
        return name;
    }

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

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public String getISBN() {
        return ISBN;
    }

    public void setISBN(String ISBN) {
        this.ISBN = ISBN;
    }
}

通过读取配置文件生成map对象便于提取文件内容和转码
 
文本文件为config下的device.ini
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.springframework.util.ResourceUtils;

public class TransDeviceCode {
    /**读取config文件下device.in文件，
     * 
     * @param file  device.ini文件地址
     * @return
     */
    private Map<String,String> tempMap;
    public TransDeviceCode(){
    }
    public TransDeviceCode(String fileName){
        tempMap=new HashMap<String,String>();
        String strLine;
        BufferedReader bufferedReader;
        StringBuffer buffer;
        File file;
        try {
            file=ResourceUtils.getFile("classpath:"+fileName);
            bufferedReader = new BufferedReader(new FileReader(file));
            while ((strLine = bufferedReader.readLine()) != null) {
                strLine = strLine.trim();
                char arr[] = strLine.toCharArray();
                if(strLine.indexOf('#')>=0) {
                    continue;
                }
                if(strLine.length() == 0) {
                    continue;
                }
                buffer = new StringBuffer();
                for(int i=0; i<arr.length; i++) {
                    char c = arr[i];
                    int ascii = (int)c;
                    if(ascii == 65533 || ascii == 0) {
                        continue;
                    }else{
                        buffer.append(arr[i]);
                    }
                }
                String sarr[] = buffer.toString().split("   ");
                tempMap.put(sarr[1].trim(), sarr[3].trim());   //这里需要哪一列的信息就提取哪一列
            }
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //可以通过此方法转码
    public String getValue(String key){
        key=key.trim();
        String value=this.tempMap.get(key);
        if(value==null || value==""){
            value=key;
        }
        value=value.trim();
        return value;
    }
}