3、数组、集合、Lambda、Stream与Optional类
一、数组：
数组保存在JVM堆内存中
1、数组的创建：
（1）、一维数组创建方式一：
//一维数组方式一 Integer[] array01 = {1,2,3};
System.out.println("一维数组创建方式一"); System.out.println("数组长度："+array01.length); for (int i: array01) { System.out.println("Array01["+(i-1)+"]="+array01[i-1]); }
（2）、一维数组创建方式二：
//一维数组方式二 Integer[] array02 = new Integer[2]; array02[0] = 1; array02[1] = 2;
System.out.println("一维数组创建方式二"); System.out.println("数组长度："+array02.length); for (int i: array02) { System.out.println("Array02["+(i-1)+"]="+array02[i-1]); }
（3）、一维数组创建方式三：
//一维数组方式三 Integer[] array03 = new Integer[]{1,2,3};
System.out.println("一维数组创建方式三"); System.out.println("数组长度："+array03.length); for (int i: array03) { System.out.println("Array03["+(i-1)+"]="+array03[i-1]); }
（4）、二维数组同理：
//二维数组同理 Integer[][] array04 = {{1,2},{3,4}}; System.out.println("二维数组创建方式同理"); System.out.println("二维数组长度："+array04.length); for (int i = 0; i < array04.length; i++) { for (int j = 0; j < array04[i].length; j++) { System.out.println("Array04["+(i)+"]"+"["+(j)+"]="+array04[i][j]); } } Integer[][] array05 = new Integer[][]{{1,2},{3,4}}; for (int i = 0; i < array05.length; i++) { for (int j = 0; j < array05[i].length; j++) { System.out.println("Array05["+(i)+"]"+"["+(j)+"]="+array05[i][j]); } } Integer[][] array06 = new Integer[2][2]; array06[0][0] = 1; array06[0][1] = 2; array06[1][0] = 3; array06[1][1] = 4; for (int i = 0; i < array06.length; i++) { for (int j = 0; j < array06[i].length; j++) { System.out.println("Array06["+(i)+"]"+"["+(j)+"]="+array06[i][j]); } }
2、java.util.Arrays工具类详解：
（1）、Arrays.equals()：判断两个数组是否相等
/** * 1、boolean equals(int[] a,int[] b):判断两个数组是否相等。 * @Return false * */ int[] arr1 = new int[]{1,2,3,4}; int[] arr2 = new int[]{1,3,2,4}; boolean isEquals = Arrays.equals(arr1, arr2); System.out.println(isEquals);
（2）、Arrays.toString()：输出数组信息
/** * 2.String toString(int[] a):输出数组信息。 * @Return [1, 2, 3, 4] * */ int[] arr1 = new int[]{1,2,3,4}; System.out.println(Arrays.toString(arr1));
（3）、Arrays.fill()：将指定值填充到数组中
/** * 3、 * void fill(int[] a,int val):将指定值填充到数组中的每一个元素。 * void fill(int[] a,fromIndex,toIndex,int val):将指定值填充的数组中从fromIndex（包含）到toIndex（不包含）范围内的每一个元素。 * */ int[] arr1 = new int[]{1,2,3,4}; Arrays.fill(arr1,10); //toPrint->[10, 10, 10, 10] System.out.println(Arrays.toString(arr1)); Arrays.fill(arr1,1,3,0); //toPrint->[10, 0, 0, 10] System.out.println(Arrays.toString(arr1));
（4）、Arrays.sort()：对数组进行升序排序
/** * 4、 * void sort(int[] a):对数组进行升序排序。 * void sort(int[] a,fromIndex,toIndex):对数组从fromIndex（包含）到toIndex（不包含）范围内进行部分排序。 * 注： * sort() 方法使用快速排序适用于少量数据的排序，parallelSort() 方法使用并行排序适用于大量数据的升序排序 * */ int[] arr1 = new int[]{1,3,2,4}; Arrays.sort(arr1); //toPrint->[1, 2, 3, 4] System.out.println(Arrays.toString(arr1)); int[] arr2 = new int[]{1,3,2,7,4}; Arrays.sort(arr2,1,3); //toPrint->[1, 2, 3, 7, 4] System.out.println(Arrays.toString(arr2));
（5）、Arrays.binarySearch()：二分查找搜索数组中指定值的位置
/** * 5.int binarySearch(int[] a,int key):使用二分查找搜索指定的值，找到了则返回该值在数组中的下标，没找到则返回一个负数 * @Return 8 * */ int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333}; int index = Arrays.binarySearch(arr3, 210); if(index >= 0){ System.out.println(index); }else{ System.out.println("未找到"); }
（6）、Arrays.asList()：将数组转化成List集合的方法
注： 参考自
1）、该方法适用于对象型数据的数组（String、Integer...），不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）；
2）、该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新；
3）、该方法得到的List的长度是不可改变的，添加或删除一个元素时（add()、remove()、clear()等方法）程序就会抛出异常；
总结：
如果你的List只是用来遍历，就用Arrays.asList()。如果你的List还要添加或删除元素，还是乖乖地new一个java.util.ArrayList，然后一个一个的添加元素。
/** * 6.List<T> asList(T... a):将数组转化成List集合的方法，此方法得到的List的长度是不可改变的，添加或删除一个元素时程序就会抛出异常 * */ String[] arr4 = {"a","b","c","d","e","f","g"}; List<String> list = Arrays.asList(arr4); //list.add("k"); //抛出异常：java.lang.UnsupportedOperationException for (String i: list ) { System.out.println(i); }
3、八大排序算法之一：冒泡排序法
/** * 冒泡排序: * 八大排序算法之一 * 1、比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换位置（从小到排） * 2、每次比较，都会产生一个最大，或最小的数 * 3、下一轮则可以少一次排序 * 4、依次循环，直至结束 * */ public static void BubbleSort(int[] array){ for (int i = 0; i < array.length-1; i++){ //每个数字需要循环比较n-1次,随着数据被排序,未匹配数字越来越少,与外层循环形成反比 公式为:length-i-1,没匹配到一个数,减少一次循环 for (int j = 0; j < array.length-i-1; j++){ //每次将数据进行比较,将最大值或最小值放入到比较数中 //如果第一个数大于第二个数,将交换位置,比较数永远是最大数 if (array [j] > array [j+1]){ //将前一个元素,放入到临时位置 int temp = array [j]; //将后一个元素,赋值给前一个元素,进行替换 array [j] = array[j+1]; //在将前一个元素的值,替换到后一个元素中,形成交换 array [j+1] = temp; } } } System.out.println("排序后数组为:"+ Arrays.toString(array)); }
二、集合：
1、集合详解：
（1）、Collection父接口：
单列集合，以单个方式存储元素对象
- 增：add(Object obj)
- 删：remove(int index) / remove(Object obj)
- 改：set(int index, Object ele)
- 查：get(int index)
1、List接口：
存储有序可重复的数据。常见的List接口的实现类有ArrayList、LinkedList、CopyOnWriteArrayList和Vector。
（1）、ArrayList：
1）、特点：
- 底层数组，检索效率高、增删效率低
- 初始化容量默认10，默认的扩容倍数1.5（即每次扩容容量增加 50%）
- 非线程安全的
2）、底层分析：
数组机制：
- 由于数组是一段连续的内存空间，为了保证数组的连续性，当要在某一索引处进行插入或删除一个元素时，需要将该索引后的所有元素都后移或前移一个单位，故ArrayList检索效率高、增删效率低
扩容机制：
- 底层初始容量为10，容量不足时，会触发扩容
- 扩容策略是通过 grow() 方法来实现的，默认的扩容倍数1.5，即它会将当前容量增加 50%
- 每次扩容都会底层创建一个新的更大容量的数组，然后将原数组中的元素复制到新数组中，最后再插入新的数据
- 为提高效率，减少后续的扩容次数，可以在创建 ArrayList 时指定初始容量，例如 ArrayList<Integer> list = new ArrayList<>(20)
|
如果你向一个初始容量为 10 的 ArrayList 中插入 20 个元素，扩容的过程如下 |
|
一、初始状态：
二、第一次扩容：
三、第二次扩容：
总结：在插入 20 个元素的过程中，ArrayList 总共进行了两次扩容操作。 |
3）、使用场景：
当需要快速随机访问元素且插入和删除操作不频繁时
List<String> arrayList = new ArrayList<>(); arrayList.add("Apple"); arrayList.add("Banana"); String fruit = arrayList.get(0); // 快速随机访问
（2）、LinkedList：
1）、特点：
- 底层双向链表，检索效率低、增删效率高
-
非线程安全的
2）、底层分析：
- LinkedList 没有像 ArrayList 那样的扩容机制，它通过动态的节点连接来管理元素，每次插入操作只需调整指针，而不需要重新分配和复制整个数据结构
3）、使用场景：
当需要频繁插入和删除元素时，尤其是在列表两端
LinkedList<String> linkedList = new LinkedList<>(); linkedList.add("默认在链表末尾添加一个元素"); linkedList.addFirst("在链表开头添加一个元素"); // 快速插入到列表开头 linkedList.addLast("在链表末尾添加一个元素");
（3）、CopyOnWriteArrayList：
1）、特点：
- 底层采用写时复制机制
- 线程安全
2）、底层分析：
- 当需要对 CopyOnWriteArrayList 进行写操作（如添加或修改元素）时，先将原有的集合进行复制，然后对新的副本进行修改操作，最后将修改后的副本替换原有的集合，这种替换是原子操作（依赖于volatile 关键字和内部实现机制），确保了其他线程在替换过程中仍然可以安全地进行读取操作，保证了读写的并发性。由于每次写操作都会创建一个新的副本，所以CopyOnWriteArrayList占用的内存较大，需要根据具体场景进行权衡。
3）、使用场景：
由于每次写操作都会复制整个集合，因此CopyOnWriteArrayList的写操作性能较低，适用于读操作远多于写操作并且需要线程安全的场景
CopyOnWriteArrayList<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>(); copyOnWriteArrayList.add("Apple");
（4）、Vector：
- 底层数组，作为List接口的古老实现类；线程安全的，效率低；底层都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。
- 尽管 Vector 提供了线程安全的操作，但由于其同步操作可能导致性能下降，并且在 Java 2 平台 Collections Framework 引入后，更推荐使用非同步的 ArrayList（通过 Collections.synchronizedList 方法得到线程安全的 List）或者并发包中的 CopyOnWriteArrayList 来替代 Vector
2、Set接口：
存储无序不可重复的数据。常见的Set接口的实现类有HashSet、TreeSet和LinkedHashSet。
（1）、HashSet：
- 底层使用 HashMap实现存储， HashSet封装了一系列HashMap的方法。具体来说，HashSet 的元素被存储为 HashMap 的键，而对应的值则是一个固定的占位对象（比如 PRESENT = new Object()），所有元素共享同一个值
- 适合需要快速查找、插入和删除元素的场景，不关心元素顺序，允许存储 null 元素（只能有一个 null 元素）
- 非线程安全的
（2）、TreeSet：
- 基于红黑树（Red-Black Tree）实现
- 适合需要对元素进行排序的场景，有序访问元素，不允许存储 null 元素
- 非线程安全的
（3）、LinkedHashSet：
- 基于哈希表（HashMap）来保存集合元素，同时使用一个双向链表来维护元素的插入顺序
- 适合需要保持元素插入顺序的场景，同时需要较快的查找操作，允许存储 null 元素
- 非线程安全的
（2）、Map父接口：
双列数据，以键值对key-value方式存储元素对象
存储无序不可重复的数据。常见的Map接口的实现类有HashMap、TreeMap、LinkedHashMap、ConcurrentHashMap。
- 添加：put(Object key,Object value)
- 删除：remove(Object key)
- 修改：put(Object key,Object value)
- 查询：get(Object key)
1、HashMap：
（1）、特点：
- 底层jdk7及之前是数组与单向链表的结合体，jdk8是数组、单向链表与红黑树的结合体
- 初始化容量16，默认加载因子是0.75，当达到75%开始扩容，扩容为原容量的2倍数
- 允许存储null的key和value
- 非线程安全的
（2）、底层分析：
扩容机制：
- 在创建时可以指定底层数组初始容量（默认16）和加载因子（默认0.75），当存储的元素数量达到容量75%时，就会触发扩容操作，扩容为原容量的2倍数
- 每次扩容都会底层创建一个新的、容量是原来的两倍的数组，所有的元素会被重新计算哈希值（调用hashcode（）得到key的哈希值），并放入新的数组中的新位置（哈希值进行取模（通常是数组的长度）映射到数组上的索引）。存储时，如果出现hash值相同的key，此时有两种情况。
a. 如果key相同，则覆盖原始值；
b. 如果key不同（出现冲突），则将当前的key-value放入链表或红黑树中
- 当链表长度大于阈值（默认为8） 时并且数组长度达到64时，将链表转化为红黑树，以减少搜索时间。
- 扩容resize( ) 时，如果红黑树拆分成的树的结点数小于等于临界值6个，则退化成链表
（3）、使用场景：
适合快速存取且不关心顺序的场景
Map<String, Integer> hashMap = new HashMap<>(); hashMap.put("Apple", 1); int count = hashMap.get("Apple"); // 快速查找
2、TreeMap：
- 底层基于红黑树
- 按键的自然顺序或自定义比较器顺序排序，提供有序的键值对存储
- 适合需要键排序的场景
- 非线程安全的
3、LinkedHashMap：
- 底层基于HashMap与双向链表实现，每个元素不仅包含了键值对数据本身，还包含了指向前一个和后一个元素的指针
- 适合需要维护插入顺序或访问顺序的场景
- 非线程安全的
4、ConcurrentHashMap：
- ConcurrentHashMap是一种线程安全的高效Map集合，JDK7与JDK8中做了很多调整。
（1）、在JDK7中：
ConcurrentHashMap底层采用是Segment分段数组+单向链表实现，Segment数组的大小默认为16，一旦初始化之后中间不可扩容。每个Segment都类似于一个小的HashMap，可以挂载一个可扩容的HashEntry数组用来存储具体的元素，如果HashEntry数组中存储的元素发生hash冲突，则可以采用单向链表方式解决。其插入与删除的原理是底层调用hashcode（）得到key的哈希值，在经过哈希算法将其转换成相应segment数组下标，结合equals()方法来判断在对应segment分段下hashEntry数组中数据是否已经存在，在进行操作hashEntry数组中的数据之前，会先判断当前segment对应下标位置是否有线程进行操作，为了线程安全使用的是ReentrantLock可重入锁进行加锁，如果需要获取锁则会使用CAS自旋锁进行尝试
（2）、在JDK8中：
ConcurrentHashMap做了较大的优化，首先是它的数据结构与JDK1.8的hashMap数据结构完全一致，底层放弃了Segment分段的臃肿设计，采用是数组+单向链表与红黑树结合体，通过更轻量级的Node + CAS + Synchronized方式来保证集合的并发安全，synchronized只用锁定当前链表或红黑二叉树的首节点，这样的话只要hash不冲突，就不会产生并发 , 效率得到较大提升
- 适合高并发环境下的使用
5、Hashtable：
- 底层实现基于一个哈希表数组和链表。它使用哈希码来确定存储桶位置，并通过链表解决哈希冲突
- 线程安全的
- 由于 Hashtable 的方法是同步的，因此在多线程环境下使用时，不需要额外的同步措施，可以确保线程安全，但是，在并发量大时可能会导致性能瓶颈，因此，通常推荐使用ConcurrentHashMap
-
HashTable不能存储null的key和value，否则报空指针异常
（3）、总结：
选择 List 实现：
- ArrayList：适合频繁的随机访问。
- LinkedList：适合频繁的插入和删除操作，尤其是在列表中间或两端。
- CopyOnWriteArrayList：适合读操作远多于写操作且需要线程安全的场景。
选择 Map 实现：
- HashMap：适合快速存取且不关心顺序的场景。
- LinkedHashMap：适合需要维护插入顺序或访问顺序的场景。
- TreeMap：适合需要键排序的场景。
- ConcurrentHashMap：适合高并发环境下的使用。
2、java.util.Collections工具类详解：
Collections类是Java中针对集合类的一个工具类，其中提供一系列静态方法。
常用静态方法：
（1）、sort()：对List集合中的元素默认进行升序排序
/** * 1、sort():对List集合中的元素默认进行升序排序 * 注： * 集合指定的泛型T必须实现Comparable<? super T>接口 * */ public static void sortDemo(){ List<Integer> list = new ArrayList<>(); list.add(1); list.add(5); list.add(2); list.add(4); list.add(3); //默认升序排序 Collections.sort(list); System.out.println(list); //toPrint->[1, 2, 3, 4, 5] //降序排序，Collections.reverseOrder()：反向比较器 Collections.sort(list,Collections.reverseOrder()); System.out.println(list); //toPrint->[5, 4, 3, 2, 1] }
（2）、reverse()：反转List集合中的元素
/** * 2、reverse():反转List集合中的元素 * */ public static void reverseDemo(){ List<Integer> list = new ArrayList<>(); list.add(1); list.add(5); list.add(2); list.add(4); list.add(3); //默认升序排序 Collections.sort(list); System.out.println(list); //toPrint->[1, 2, 3, 4, 5] //反转List集合元素 Collections.reverse(list); System.out.println(list); //toPrint->[5, 4, 3, 2, 1] }
（3）、shuffle()：随机打乱List集合中元素的位置
/** * 3、shuffle():随机打乱List集合中元素的位置 * */ public static void shuffleDemo(){ List<Integer> list = new ArrayList<>(); list.add(1); list.add(5); list.add(2); list.add(4); list.add(3); //默认升序排序 Collections.sort(list); System.out.println(list); //toPrint->[1, 2, 3, 4, 5] //随机打乱位置 Collections.shuffle(list); System.out.println(list); //toPrint->[2, 4, 3, 1, 5](随机) }
（4）、copy()：复制并覆盖相应List集合中索引的元素
/** * 4、copy():复制并覆盖相应List集合中索引的元素 * 注： * (1)、第一个参数是目的集合，第二个参数是源集合 * (2)、目的集合必须声明集合大小，即目的集合要等于或者大于源集合的元素的个数。否则报下标界的异常（java.lang.IndexOutOfBoundsException）。 * */ public static void copyDemo(){ List<Integer> list = new ArrayList<>(); list.add(1); list.add(5); list.add(2); list.add(4); list.add(3); System.out.println(list); //toPrint->[1, 2, 3, 4, 5] //copy():复制并覆盖相应List集合中索引的元素,必须指定目的集合大小 //方式一、初始化指定List的大小 List<Integer> list1 = new ArrayList<>(Arrays.asList(new Integer[list.size()])); Collections.copy(list1 , list); System.out.println(list1); //toPrint->[1, 2, 3, 4, 5] //方式二、Collections.addAll()方法将所有指定的元素添加到指定的集合中，从而指定List的大小 List<Integer> list2 = new ArrayList<>(); Collections.addAll(list2,new Integer[list.size()]); Collections.copy(list2 , list); System.out.println(list2); //toPrint->[1, 2, 3, 4, 5] }
（5）、max()/min()：返回集合中最大/小的元素
/** * 5、max()/min():返回集合中最大/小的元素 * */ public static void sizeDemo(){ List<Integer> list = new ArrayList<>(); list.add(1); list.add(5); list.add(2); list.add(4); list.add(3); System.out.println(list); //toPrint->[1, 2, 3, 4, 5] System.out.println("集合中最大元素："+Collections.max(list)); //toPrint->集合中最大元素：5 System.out.println("集合中最小元素："+Collections.min(list)); //toPrint->集合中最小元素：1 }
三、Java函数式操作：
1、Lambda、方法引用、stream与Optional详解：
2、java.util.stream.Collectors相关详解：
3、匿名内部类与Lambda表达式的区别：
/** * 比较匿名内部类与lambda表达式的区别： * */ public static void compareToBoth(){ //匿名内部类形式创建线程 new Thread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); } }).start(); //lambda表达式创建线程 new Thread( () -> System.out.println(Thread.currentThread().getName()) ).start(); }
4、接口与函数式接口：
（1）、接口详解：
1)、JDK8前--->接口中只有常量与抽象方法
2)、JDK8--->接口中除了常量与抽象方法外，还有默认方法(default)和静态方法(static)
3)、JDK9--->接口中除了常量、抽象方法、默认方法(default)和静态方法(static)外，还有私有方法(private)
（2）、函数式接口详解：
1)、定义：有且仅有一个抽象方法，但是可以有多个非抽象方法的接口
2)、函数式接口可以被隐式转换为 lambda 表达式
3)、函数式接口一般会加上@FunctionalInterface：主要用于编译级错误检查,当接口不符合函数式接口定义的时候,编译器会报错
/** * 函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口 * @FunctionalInterface：主要用于编译级错误检查,加上该注解,当接口不符合函数式接口定义的时候,编译器会报错 */ @FunctionalInterface interface LamTest { void demo01(String t); static void demo02() { System.out.println("接口说明：\n" + " 1、JDK8前--->接口中只有常量与抽象方法\n" + " 2、JDK8--->接口中除了常量与抽象方法外，还有默认方法(default)和静态方法(static)\n" + " 3、JDK9--->接口中除了常量、抽象方法、默认方法(default)和静态方法(static)外，还有私有方法(private)\n"); } } class LamTestImp implements LamTest { @Override public void demo01(String t){ System.out.println(t); } }
5、Consumer、Supplier、Predicate与Function函数式接口的区别：
Consumer（消费型），Supplier（供给型）、Predicate（判断型）与Function（转换型）几个函数式接口都处于java.util.function包下
（1）、Consumer（消费型）：
1)、源码：
@FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; } }
2）、使用：
Consumer对应抽象方法：accpet
Consumer<Integer> consumer=new Consumer<Integer>() { @Override public void accept(Integer integer) { System.out.println(integer); } }; consumer.accept(1); }
3）、Consumer总结：
Consumer接口是一个消费型的接口，只要实现它的accept方法，就能作为消费者来输出信息。
lambda、方法引用都可以是一个Consumer类型，因此他们可以作为forEach的参数，用来协助Stream输出信息。
Consumer还有很多变种，例如IntConsumer、DoubleConsumer与LongConsumer等，归根结底，这些变种其实只是指定了Consumer中的泛型而已，方法上并无变化。
（2）、Supplier（供给型）：
1）、源码：
@FunctionalInterface public interface Supplier<T> { T get(); }
2）、使用：
Supplier对应抽象方法：get
Supplier<Double> supplier=()->new Random().nextDouble(); //当然也可以使用方法引用 Supplier<Double> supplier1= Math::random; System.out.println(supplier.get());
3）、Supplier总结：
Supplier是一个供给型的接口，其中的get方法用于返回一个值。
Supplier也有很多的变种，例如IntSupplier、LongSupplier与BooleanSupplier等
（3）、Predicate（判断型）：
1）、源码：
@FunctionalInterface public interface Predicate<T> { boolean test(T t); default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); } default Predicate<T> negate() { return (t) -> !test(t); } default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); } }
2）、使用：
Predicate对应抽象方法：test
Predicate<Integer> predicate=i->i>5;
System.out.println(predicate.test(1));
3）、Predicate总结：
Predicate是一个判断型的接口，用一个test方法去测试传入的参数。
当然，Predicate也有对应的变种。
（4）、Function（转换型）：
1）、源码：
@FunctionalInterface public interface Function<T, R> { R apply(T t); default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); } default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); } static <T> Function<T, T> identity() { return t -> t; } }
2）、使用：
Function对应抽象方法：apply
List<Student> list= Arrays.asList(new Student("jack",1),new Student("tom",2)); Function<Student,Integer> function= Student::getId; list.stream().map(function).forEach(System.out::print);
3）、Function总结：
Function是一个转换型的接口，其中的apply可以将一种类型的数据转化成另外一种类型的数据。
Function的变种就更多了。
四、List集合操作：
1、遍历List集合：
/** * 1、遍历List集合 * 注：避免空指针异常 * */ public static void demo01(){ UserVO vo = new UserVO(1,"a",null); List<UserVO> list = new ArrayList<>(); list.add(vo); //一、过滤集合为空情况，二、过滤group为空的情况 Optional.ofNullable(list).ifPresent(p -> { p.stream().filter(pi -> !ObjectUtils.isEmpty(pi.getGroup())).forEach(po -> { System.out.println("a".equals(po.getGroup())); }); }); //三、List中取出指定字段等于指定值的对象 UserVO userVO = list.stream().filter(pi -> !ObjectUtils.isEmpty(pi.getUuid())) .filter(pi -> pi.getUuid().equals(1)) .findFirst().orElse(null); System.out.printf("结果："+userVO); }
2、List集合转Map<k，T>集合：
/** * 2、List集合转Map<k,T>集合 * */ public static void demo02(){ UserVO vo = new UserVO(1,"a",null); UserVO vo1 = new UserVO(1,"b",null); UserVO vo2 = new UserVO(1,"c",null); UserVO vo3 = new UserVO(2,"a",null); UserVO vo4 = new UserVO(3,"b",null); List<UserVO> list = new ArrayList<>(); list.add(vo); list.add(vo1); list.add(vo2); list.add(vo3); list.add(vo4); //uuid为key，UserVO为value //(k1,k2)->k1 如果有重复的key,则保留第一个 //(k1,k2)->k2 如果有重复的key,则保留最后一个 Map<Integer , UserVO> map1 = list.stream().collect(Collectors.toMap(UserVO::getUuid, p -> p, (k1,k2) -> k1)); Optional.ofNullable(map1.get(1)).ifPresent(p -> { System.out.println(p.getName()); }); }
3、List集合转Map<k，List<T>>集合：
/** * 3、List集合转Map<k,List<T>>集合 * */ public static void demo03(){ UserVO vo = new UserVO(1,"a",null); UserVO vo1 = new UserVO(1,"b",null); UserVO vo2 = new UserVO(1,"c",null); UserVO vo3 = new UserVO(2,"a",null); UserVO vo4 = new UserVO(3,"b",null); List<UserVO> list = new ArrayList<>(); list.add(vo); list.add(vo1); list.add(vo2); list.add(vo3); list.add(vo4); //groupingBy：分组 Map<Integer , List<UserVO>> map = list.stream().collect(Collectors.groupingBy(UserVO::getUuid)); Optional.ofNullable(map.get(1)).ifPresent(p -> { p.stream().forEach(po -> { System.out.println(po.getName()); }); }); }
4、List集合全部/部分复制到另一个List集合：
/** * 4、List集合全部/部分复制到另一个List集合 * 注： * (1)、list集合的全部内容复制到list1集合中 * (2)、list集合中部分（uuid与name）字段的全部内容复制到list2集合中 * (3)、list集合的截取部分内容复制到list3集合中 * */ public static void demo04(){ List<UserVO> list = new ArrayList<>(); List<UserVO> list1 = new ArrayList<>(); List<UserVO> list2 = new ArrayList<>(); List<UserVO> list3 = new ArrayList<>(); UserVO vo = new UserVO(1,"a",null); UserVO vo1 = new UserVO(1,"b",null); UserVO vo2 = new UserVO(1,"c",null); UserVO vo3 = new UserVO(2,"a",null); UserVO vo4 = new UserVO(3,"b",null); list.add(vo); list.add(vo1); list.add(vo2); list.add(vo3); list.add(vo4); //一、list集合的全部内容复制到list1集合中 list1.addAll(list); //二、list集合中部分（uuid与name）字段的全部内容复制到list2集合中 list2 = list.stream().map(p -> new UserVO(p.getUuid(),p.getName())).collect(Collectors.toList()); System.out.println(list2); //三、list集合的截取部分内容复制到list3集合中 list3.addAll(list.subList(0 , 2)); System.out.println(list3); }
5、List集合中根据对象某属性进行计算（求和、最大值与最小值）：
/** * 5、List集合中根据对象某属性进行计算（求和、最大值与最小值） * 注： * (1)、对list集合UserVO对象中uuid字段求和 * (2)、对list集合UserVO对象中uuid字段求最大值 * (3)、对list集合UserVO对象中uuid字段求最小值 * (4)、整合操作 * Comparator：比较器 * */ public static void demo05(){ List<UserVO> list = new ArrayList<>(); UserVO vo = new UserVO(1,"a",null); UserVO vo1 = new UserVO(1,"b",null); UserVO vo2 = new UserVO(1,"c",null); UserVO vo3 = new UserVO(2,"a",null); UserVO vo4 = new UserVO(3,"b",null); list.add(vo); list.add(vo1); list.add(vo2); list.add(vo3); list.add(vo4); //一、对list集合UserVO对象中uuid字段求和 Integer sumVO = list.stream().mapToInt(UserVO::getUuid).sum(); System.out.println(sumVO); //二、对list集合UserVO对象中uuid字段求最大值 Integer maxVO = list.stream().max(Comparator.comparing(UserVO::getUuid)).get().getUuid(); System.out.println(maxVO); //三、对list集合UserVO对象中uuid字段求最小值 Integer minVO = list.stream().min(Comparator.comparing(UserVO::getUuid)).get().getUuid(); System.out.println(minVO); //四、List集合中根据对象某属性进行计算 IntSummaryStatistics cal = list.stream().collect(Collectors.summarizingInt(UserVO::getUuid)); System.out.println("总和"+cal.getSum()); System.out.println("最大"+cal.getMax()); System.out.println("最小"+cal.getMin()); System.out.println("平均"+cal.getAverage()); System.out.println("计数"+cal.getCount()); }
6、List集合转Map<k,List<T>>集合再进行遍历：
/** * 6、List集合转Map<k,List<T>>集合再进行遍历 * */ public static void demo06(){ UserVO vo = new UserVO(1,"a",null); UserVO vo1 = new UserVO(1,"b",null); UserVO vo2 = new UserVO(1,"c",null); UserVO vo3 = new UserVO(2,"a",null); UserVO vo4 = new UserVO(3,"b",null); List<UserVO> list = new ArrayList<>(); list.add(vo); list.add(vo1); list.add(vo2); list.add(vo3); list.add(vo4); //groupingBy：分组 Map<Integer , List<UserVO>> map = list.stream().collect(Collectors.groupingBy(UserVO::getUuid)); if(!ObjectUtils.isEmpty(map)) { Set<Map.Entry<Integer , List<UserVO>>> en = map.entrySet(); for (Map.Entry<Integer , List<UserVO>> entry : en) { //获取KEY值 Integer key = entry.getKey(); //获取VALUE值 List<UserVO> userVOList = entry.getValue(); System.out.println("KEY值："+key+",VALUE值："+userVOList); } } }
注：
//List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8); //Map<Integer, List<Integer>> groups = intList.stream().collect(Collectors.groupingBy(s -> (s - 1) / 3)); //List<List<Integer>> subSets = new ArrayList<List<Integer>>(groups.values());
五、属性转换：
1、相同属性值的对象复制：
BeanUtils.copyProperties（对象A，对象B）;
注：浅拷贝
（1）、说明：
将两个字段相同的对象进行属性值的复制。如果 两个对象之间存在名称不相同的属性，则 BeanUtils 不对这些属性进行处理，需要程序手动处理。
（2）、org.springframework.beans.BeanUtils类的方法：
1）、相同属性进行全量复制
//a对象拷贝到b对象 BeanUtils.copyProperties(a.toString(), b.toString());
2）、过滤属性值为空的相同属性进行复制
BeanUtils.copyProperties(a.toString(), b.toString(), getNullPropertyNames(a));
注：
public static String[] getNullPropertyNames (Object source) { final BeanWrapper src = new BeanWrapperImpl(source); PropertyDescriptor[] pds = src.getPropertyDescriptors(); Set<String> emptyNames = new HashSet<>(); for(PropertyDescriptor pd : pds) { Object srcValue = src.getPropertyValue(pd.getName()); // 值为NULL的参数 if (srcValue == null) { emptyNames.add(pd.getName()); } } String[] result = new String[emptyNames.size()]; return emptyNames.toArray(result); }
（3）、 org.apache.commons.beanutils.BeanUtils类的方法：
//b对象拷贝到a对象 BeanUtils.copyProperties(a, b);
2、Object对象转Map：
/** * Object转map * * */ public static Map<String,Object> objToMap(Object obj){ Map<String,Object> map=new LinkedHashMap<>(); Field[] fields = obj.getClass().getDeclaredFields(); for(Field field:fields){ field.setAccessible(true); try { map.put(field.getName(), field.get(obj)); } catch (IllegalAccessException e) { throw new IllegalArgumentException("属性转换失败。"+ e); } } return map; }
