Collections方法

get, add, addAll, sort, contains, containsAll, remove, removeAll,clear, subList,retainAll

Collections 工具类

这是一个工具类，可以检查 null 元素不被加入集合，合并列表，过滤列表，两个列表的并集、差集、合集。有部分功能在 Java 8 中可以被 Stream API 替换。

  1. public static void main(String[] args) {
  3.     //null 元素不能加进去
  4.     List<String> arrayList1 = new ArrayList<>();
  5.     arrayList1.add("a");
  6.     CollectionUtils.addIgnoreNull(arrayList1, null);
  7.     System.out.println(arrayList1.size());
  9.     //排好序的集合，合并后还是排序的
  10.     List<String> arrayList2 = new ArrayList<>();
  11.     arrayList2.add("a");
  12.     arrayList2.add("b");
  14.     List<String> arrayList3 = new ArrayList<>();
  15.     arrayList3.add("c");
  16.     arrayList3.add("d");
  17.     System.out.println("arrayList3：" + arrayList3);
  19.     List<String> arrayList4 = CollectionUtils.collate(arrayList2, arrayList3);
  20.     System.out.println("arrayList4:" + arrayList4);
  22.     //交集
  23.     Collection<String> strings = CollectionUtils.retainAll(arrayList4, arrayList3);
  24.     System.out.println("arrayList3和arrayList4的交集：" + strings);
  26.     //并集
  27.     Collection<String> union = CollectionUtils.union(arrayList4, arrayList3);
  28.     System.out.println("arrayList3和arrayList4的并集：" + union);
  30.     //差集
  31.     Collection<String> subtract = CollectionUtils.subtract(arrayList4, arrayList3);
  32.     System.out.println("arrayList3和arrayList4的差集：" + subtract);
  34.     // 过滤，只保留 b
  35.     CollectionUtils.filter(arrayList4, s -> s.equals("b"));
  36.     System.out.println(arrayList4);
  37. }

排序操作

  1. //反转
  2. void reverse(List list)
  3.  //随机排序
  4. void shuffle(List list)
  5. //按自然排序的升序排序
  6. void sort(List list)
  7. //定制排序，由Comparator控制排序逻辑
  8. void sort(List list, Comparator c)
  9. //交换两个索引位置的元素
  10. void swap(List list, int i , int j)
  11. //旋转。当distance为正数时，将list后distance个元素整体移到前面。
  12. // 当distance为负数时，将 list的前distance个元素整体移到后面
  13. void rotate(List list, int distance)

查找,替换操作

  1. //对List进行二分查找，返回索引，注意List必须是有序的
  2. int binarySearch(List list, Object key)
  3. //根据元素的自然顺序，返回最大的元素。 
  4. // 类比int min(Collection coll)
  5. int max(Collection coll)
  6. //根据定制排序，返回最大元素，排序规则由Comparatator类控制。
  7. //类比int min(Collection coll, Comparator c)
  8. int max(Collection coll, Comparator c)
  9. //用指定的元素代替指定list中的所有元素
  10. void fill(List list, Object obj)
  11. //统计元素出现次数
  12. int frequency(Collection c, Object o)
  13. //统计target在list中第一次出现的索引，找不到则返回-1，
  14. //类比int lastIndexOfSubList(List source, list target)
  15. int indexOfSubList(List list, List target)
  16. //用新元素替换旧元素
  17. boolean replaceAll(List list, Object oldVal, Object newVal)

Collectors

toMap

value为null的bug: NullPointerException in Collectors.toMap with null entry values

  1. Map<String, Double> rawTypes = resolver.aiNicks().stream()
  2.     .collect(Collectors.toMap(t -> t, t -> possibility(possibilities, t)));

groupingBy

关于Java使用groupingBy分组数据乱序问题

  1. personInfoList.stream().collect(
  2.     Collectors.groupingBy(
  3.         PersonInfo::getSex, LinkedHashMap::new, Collectors.toList()));

stream

Lambda结合FunctionalInterface Lib, forEach, stream()，method reference等新特性可以使代码变的更加简洁！ stream()的几个方法都是接受Predicate，Consumer等参数的

多线程课程

  1. public interface CacheExpireConfigurer {
  2.     void customize(CacheExpires cacheExpires);
  3. }
  5. @Configuration
  6. public class CacheConfiguration {
  8.     @Bean
  9.     public CacheExpireConfigurer cacheExpireConfigurer() {
  10.         return cacheExpires -> {
  12.             cacheExpires.put("Cache name", 60);
  13.         };
  14.     }
  16. }

image.png

Paralle

  • [ ] JDK8并行流 parallelStream

    1. Lists.partition(lists, BATCH_SIZE)
    2.               .parallelStream()
    3.               .flatMap()

    flatMap

    1.   private Set<Long> collectFamilyNodes(List<TblMenu> nodes, List<TblMenu> allMenus) {
    3.       return nodes.stream()
    4.               .map(node -> composeFamilyTree(node, allMenus))
    5.               .flatMap(Collection::stream)
    6.               .filter(Objects::nonNull)
    7.               .collect(Collectors.toSet());
    8.   }

    1.   public List<AssetVo> groupByLocNo(List<HyveAssetDto> hyveAssetDtos) {
    3.      List<HyveAssetItemDto> hyveAssetItems = dtos.stream()
    4.          .flatMap(dto -> dto.getItems().stream())
    5.          .collect(Collectors.toList());
    6.   }

    sum

    Summing Numbers with Java Streams