Stream/Optional

1. orElse和orElseGet的区别 orElse传的是一个对象，orElseGet传的是一个函数，orElse的参数即使optional.isPresent为true也会执行

Difference between Optional.orElse() and Optional.orElseGet()

The or prefix misleads developers (including myself when I asked the problem) into thinking that it is a short-circuiting operation, because that is what we are used to in boolean conditions. However, it is not, it is just a method name that has or in its prefix, so its arguments will be evaluated, irrespective of whether Optional is carrying a value or not.

Array转list

int[]转list

int[] nums = {0, -1,0, -1,0, -1,99};
List<Integer> a =  Arrays.stream(nums).boxed().collect(Collectors.toList());

❌ 不能用Arrays::asList，会映射成List<int[]>

int[] a = {-1, 0, 1, 2, -1, -4};
List<int[]> aList = Arrays.asList(a); // 这里aList只包含一个元素，该元素是int[]类型。

int[][]转list

自己写的 找找有没有更简单的写法

int[][] num={ {2}, {3,4}, {6,5,7}, {4, 1, 8, 3} };
List<List<Integer>> resList = Arrays.stream(num).map(li -> IntStream.of(li).boxed().collect(Collectors.toList())).collect(Collectors.toList());

输出二维数组

Arrays.stream(num).map(Arrays::toString).forEach(System.out::println);

Integer[]转list

Arrays.asList

Arrays.asList内部实现是return new ArrayList<>(a); 这个ArrayList是 Arrays类内部定义的 private的静态内部类java.util.Arrays.ArrayList，不是java.util.ArrayList。所以只能用List接，不能用ArrayList，会报错。

并且这个list只实现了set方法，add元素时会抛出java.lang.UnsupportedOperationException异常。

Integer[] intArray = {1, 2, 3, 4, 5, 6, 7, 8};
List<Integer> listOfIntegers1 = Arrays.asList(intArray);
List<Integer> listOfIntegers2 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);

✅ 转成正常ArrayList

Integer[] intArray = {1, 2, 3, 4, 5, 6, 7, 8};
List<Integer> listOfIntegers = new ArrayList<>(Arrays.asList(intArray));

✅ stream

List<Integer> listOfIntegers = Arrays.stream(intArray).collect(Collectors.toList());

Integer[][] 转 list

//二维数组
Integer[][] num={ {2}, {3,4}, {6,5,7}, {4, 1, 8, 3} }; //声明为int的话，stream转会报错

List<List<Integer>> triangle = Arrays.stream(num)
        .map(Arrays::asList)
        .collect(Collectors.toList());

---------

guava新建List

// guava:
List<Integer> listOfIntegers2 = Lists.newArrayList(0, 1, 2, 3);

list转hashset

直接 new HashSet<>(words)

https://stackoverflow.com/questions/36000097/big-o-what-is-the-time-complexity-for-this-algorithm

判断有没有重复

new HashSet<>(words).size() == words.size()

toSet retainAll返回true表示有交集，注意retainAll会改变原集合

//判断是否与已有数据重复
Set<Integer> repeatId = Sets.newHashSet();
Set<Integer> goodsIds = seBo.getXXList().stream().map(Activity::getXXCode).collect(Collectors.toSet());
repeatId.addAll(goodsIds);
repeatId.retainAll(dbId);

创建二维数组

可以直接new int[2][3]。。。以前用stream写了个寂寞。

int[][] dp = new int[2][3];
如果是new int[2][]，还需要每行重新new，否则NPE。

// m行n列
int[][] dp = Stream.generate(() -> new int[n]).limit(m).toArray(int[][]::new);
int[][] dp1 = IntStream.range(0, m).mapToObj(index -> new int[n]).toArray(int[][]::new);

复制二维数组

copy a 2d array in java

int[][] data = {{1, 2}, {3, 4}};
int[][] dataCopy = Arrays.stream(data)
          .map((int[] row) -> row.clone())
          .toArray((int length) -> new int[length][]);

For one-liner - collapse all lambdas to method references Arrays.stream(data).map(int[]::clone).toArray(int[][]::new); But please note that for huge arrays native System.arraycopy should be (probably?) faster, unless you parallel() your stream.

创建一个一样大小的二维数组

int[][] height = {
        {1,4,3,1,3,2},
        {3,2,1,3,2,4},
        {2,3,3,2,3,1}
};
int[][] dataCopy = Arrays.stream(height).map((int[] row) -> new int[row.length]).toArray(int[][]::new);

// 感觉写复杂了，直接
int m = heights.length;
int n = heights[0].length;
boolean[][] visited = new boolean[m][n];

输出二维数组

Arrays.stream(num).map(Arrays::toString).forEach(System.out::println);

把边转成树 ([][]转List<Set>)

int[][] edges = { {0, 3}, {1, 3}, {2, 3}, {4, 3}, {5, 4} };
int n = 6;

//初始化tree
List<Set<Integer>> tree = Stream.generate(HashSet<Integer>::new).limit(n).collect(Collectors.toList());

//将edges转化成List<HashSet<Integer>>
Arrays.stream(edges).forEach(e -> {
    tree.get(e[0]).add(e[1]);
    tree.get(e[1]).add(e[0]);
});

找出所有叶子 (stream迭代时获得下标)

List<Set<Integer>> tree;
int[] leaf = IntStream.range(0, tree.size()).filter(i -> tree.get(i).size() == 1).toArray();

Is there a concise way to iterate over a stream with indices in Java 8?

https://stackoverflow.com/questions/18552005/is-there-a-concise-way-to-iterate-over-a-stream-with-indices-in-java-8

The cleanest way is to start from a stream of indices:

String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};
IntStream.range(0, names.length)
         .filter(i -> names[i].length() <= i)
         .mapToObj(i -> names[i])
         .collect(Collectors.toList());

The resulting list contains “Erik” only.

One alternative which looks more familiar when you are used to for loops would be to maintain an ad hoc counter using a mutable object, for example an AtomicInteger:

String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};
AtomicInteger index = new AtomicInteger();
List<String> list = Arrays.stream(names)
                          .filter(n -> n.length() <= index.incrementAndGet())
                          .collect(Collectors.toList());

Note that using the latter method on a parallel stream could break as the items would not necesarily be processed “in order”.

给[]和list填充相同元素

Stream.generate 初始化List<Object>

无参构造函数

list初始化

List<Person> persons = Stream.generate(Person::new)
                             .limit(60)
                             .collect(Collectors.toList());

List<Integer>[]初始化

// 转换成数组
// 不能用 (ArrayList<Integer>[])Stream.generate(ArrayList<Integer>::new).limit(numCourses).toArray(); 
// 会提示不能把Object转换成ArrayList
List<Integer>[] graph = Stream.generate(ArrayList<Integer>::new).limit(6).toArray(ArrayList[]::new);

有参构造函数

List<List<Integer>>初始化

List<List<Integer>> res2 = Stream.generate(() -> new ArrayList<Integer>(33))
        .limit(6).collect(Collectors.toList()); // 外层size 6, 内层capacity 33

List<List<Integer>> res1 = IntStream.range(0, 6)
        .mapToObj(index -> new ArrayList<Integer>(5)).collect(Collectors.toList());
        // 外层size 6, 内层capacity 5

基本类型及其包装类型

Arrays.fill 和 Collections.nCopies，最好都只用来初始化基本类型，如果初始化Object，数组的所有元素都指向同一个对象。

数组填充，填充基本类型，不要用这个填充Object，会导致一个对象改动其他都改了，和Collections.nCopies一个道理
int[] a = new int[3];
Arrays.fill(a, 3);

源码：
public static void fill(int[] a, int val) {
    for (int i = 0, len = a.length; i < len; i++)
        a[i] = val;
}

产生0-9的平方的一维数组
int[] square = IntStream.range(0, 10).map(i -> i * i).toArray();

list填充
// https://stackoverflow.com/questions/5600668/how-can-i-initialize-an-arraylist-with-all-zeroes-in-java
//不要用nCopies这个方法产生非(基本类型+对应包装类型)，用generate的方法
List<Integer> list = new ArrayList<Integer>(Collections.nCopies(60, 0));

Stream

简洁又快速地处理集合——Java8 Stream（下）

1. toMap

Collectors.toMap(key, value, key重复时对应的(旧value, 新value) -> 选一个值或者算一个值返回)

Map<Long, Long> rIdMap = cList.stream().collect(Collectors.toMap(Activity::getXXId, Activity::getAAAId, (o, n) -> n));

如果value要一个固定的String值，可以把第二个函数改成 r->""

2. toList

.map(func).toList去某一个属性构成list，这个函数也可以用lamda表达式来自己算值

List<Long> idList = boList.stream().map(XXBo::getXXId).collect(Collectors.toList());

3. flatmap

flatmap Stream flatMap() in Java with examples

List<Integer> PrimeNumbers = Arrays.asList(5, 7, 11,13);   
List<Integer> OddNumbers = Arrays.asList(1, 3, 5);
List<Integer> EvenNumbers = Arrays.asList(2, 4, 6, 8);
List<List<Integer>> listOfListofInts = Arrays.asList(PrimeNumbers, OddNumbers, EvenNumbers); 
List<Integer> listofInts  = listOfListofInts.stream() .flatMap(list -> list.stream()).collect(Collectors.toList());//list -> list.stream()变成Collection::stream 
// The Structure before flattening is : [[5, 7, 11, 13], [1, 3, 5], [2, 4, 6, 8]]
// The Structure after flattening is : [5, 7, 11, 13, 1, 3, 5, 2, 4, 6, 8]

4. findAny orElse isPresent

if(!itemList.stream().filter(d -> d.getId().equals(itemHistory.getOriginId())).findAny().isPresent())

5. reduce

curGoods += goods.stream().map(g -> g.getCsuCode().toString()).reduce((pre, next) -> pre + "、" + next).orElse("");

eBo.getXXList().stream()
                .map(SeBo::getXXPrice).reduce(BigDecimal.ZERO, BigDecimal::add);

6. skip limit

List<Goods> subList = sGoodsList.stream().skip((pageNo-1) * pageSize).limit(pageSize).collect(Collectors.toList());

7. Stream.iterate

Java8新特性学习-函数式编程(Stream/Function/Optional/Consumer)

Stream.iterate(1, n -> n + 1).limit(10).forEach(System.out::println);

Java IntStream iterate vs generate when to use what?

Note how their signatures are different:

• generate takes a IntSupplier, which means that you are supposed to generate ints without being given anything. Example usages include creating a constant stream of the same integer, creating a stream of random integers. Notice how each element in the stream do not depend on the previous element.

• iterate takes a seed and a IntUnaryOperator, which means that you are supposed to generate each element based on the previous element. This is useful for creating a inductively defined sequence, for example. In this case, each element is supposed to depend on the previous one.

8. sort

排序

JDK 8 之 Stream sorted() 示例 以及评论

Collections.sort() in Java with Examples

Arrays.sort() in Java with examples

* 对于List排序

// 1. stream().sorted
List<SeVo> a = voList.stream().sorted(Comparator.comparing(SeVo::getSortNum)).collect(Collectors.toList());

List<Integer> a = Lists.newArrayList(1 ,3, 8, 4);
a.stream().sorted((o1, o2) -> o1 - o2).collect(Collectors.toList());//输出 [1, 3, 4, 8]

int[] nums = {1,3,-1,-3,5,3,6,7};
Deque<Integer> dq = IntStream.of(nums).boxed().limit(3).sorted()
                .collect(Collectors.toCollection(ArrayDeque::new)); //默认从小到大？ [-1, 1, 3]

// 2. list.sort    
result.getList().sort(Comparator.comparing(SeVo::getSortNum));

// 3. Collections.sort() //没用过

* 对于Array排序

int[][] courses = { {5,15},{3,19},{6,7},{2,10},{5,16},{8,14},{10,11},{2,19} };

// 1. Arrays.stream(courses).sorted
Arrays.stream(courses).sorted(Comparator.comparing(c -> c[1]))

// 2. Arrays.sort
Arrays.sort(courses, Comparator.comparingInt(a -> a[1])); //按第2个元素排序
Arrays.sort(courses,(a,b)->a[1]-b[1]);

9. mapToObj, mapToInt map(Stream VS IntStream)

Java Stream difference between map and mapToObj

Stream 包含 IntStream, LongStream, DoubleStream 等

Stream<T> 不能使用primitive type，只能使用Integer这样的包装类型，而IntStream就是基本数据类型int的Stream

Stream<Integer> stream = Stream.of(1, 2, 3); //Will compile fine
IntStream intStream = IntStream.of(4, 5, 6); //Will compile fine

Stream<Integer> s = IntStream.of(4, 5, 6); //Does not compile
Stream<Integer> s = IntStream.of(4, 5, 6).mapToObj(e -> e); //mapToObj method is needed
Stream<Integer> s = IntStream.of(4, 5, 6).boxed(); //mapToObj method is needed
IntStream is = Stream.of(4, 5, 6).mapToInt(e -> e); //mapToInt method is needed


int[] nums = {1, 2, 3};
//这里要使用IntStream，如果使用Stream.of(nums)返回的是Stream<int[]>类型。
List<Integer> kList = IntStream.of(nums).boxed().limit(k).sorted().collect(Collectors.toList());

IntStream不转换成Integer的话不能直接collect，只能toArray

int[] num = IntStream.range(0, 10).toArray();

10. groupingBy

统计String里各个字符个数， t.chars()返回的是IntStream，不用mapToObj的话会报错

String t = "ABCCC";
Map<Character, Integer> tMap = t.chars().mapToObj(i -> (char) i)
                .collect(Collectors.toMap(i -> i,  i -> 1, Integer::sum));
                //{A=1, B=1, C=3}

Map<Character, Integer> tMap = t.chars().mapToObj(i -> (char) i)
                .collect(Collectors.groupingBy(Function.identity(), Collectors.summingInt(x -> 1)));
        // collectors.counting()返回的是Long，这里不能替换Collectors.summingInt(x -> 1)

为什么`groupingBy`里`Function.identity()`换成`Function::identity`会报错，但是`toMap`里却是`::`这种格式的？

11.summaryStatistics 统计

https://mp.weixin.qq.com/s/84TSGjui1pT4cL1o8vNsTw

IntSummaryStatistics 用于收集统计信息(如count、min、max、sum和average)的状态对象。

示例:得到最大、最小、之和以及平均数。

 List<Integer> numbers = Arrays.asList(1, 5, 7, 3, 9);
 IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
  
 System.out.println("列表中最大的数 : " + stats.getMax());
 System.out.println("列表中最小的数 : " + stats.getMin());
 System.out.println("所有数之和 : " + stats.getSum());
 System.out.println("平均数 : " + stats.getAverage());
 
 // 列表中最大的数 : 9
 // 列表中最小的数 : 1
 // 所有数之和 : 25
 // 平均数 : 5.0