java/c++中有关lambda表达式的书写及stream流的操作的基本总节

package com.acm;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.stream.Collectors;
import java.util.stream.Stream;


/**
 *问题：lambda表达式   匿名函数对象---->本身是个类
 *定义：lambda表达式是一个匿名函数
 *使用的条件：首先函数对应的参数必须是个抽象类并且这个抽象类中只有一个函数(只有这样才不会对调用相同参数个数的函数造成无法识别的情况)
 *使用的方法:(参数)->匿名函数的实现体，当参数的个数只有一个时，()可以省去不写
 *注意事项：1、参数不用写类型；2、匿名函数的实现体可以是一个类中的方法
 *当类中的方法为静态方法，调用的形式应该为该方法对应的:类名.该方法名或者通过引用的形式:类名::方法名；
 *没有参数可以不写,一个参数时引用Math::abs可代替Math.abs(n)；
 *如list.forEach(System.out::println);与ss.forEach(item->System.out.println(item));的写法等价
 */

 /**
 *  随便补充下c++的lambda表达式的写法
int main()
{
    int num=500;
    //auto x=[num]{cout<<num;};  //x相当于函数名,[num]用来捕获外部的变量
    //auto y=[](int x,int y)->int{cout<<x+y;};//或者写成这样[](int x,int y)->int{return 100;};加个返回值类型
    auto z=[](int x,int y){cout<<x+y<<endl;};    //不加箭头---------->最推荐使用的一种
    //捕获外部变量----->[=]表示以值的方式捕获和[&]表示以引用的方式捕获
     auto k=[=](){return num;};      //只有一个()表示无参数的--------->可以不写
     auto h=[=]{return num+45;};      //只有一个()表示无参数的--------->可以不写
     auto d=[&](int y){return num;};
     auto s=[=](int b)mutable{cout<<++num+1<<endl;};   //()mutable表示通过值捕获的外部变量可以被修改------->参数必须加上
     //因此好的习惯是有参无参都写上()
    cout<<h()<<endl;
}
 */

/**
 * Arrays数组工具类--------->里面定义了很多有关数组操作的静态方法
 * collection集合工具类------------>单列集合的根接口
 * Map------------------------>双列集合的根接口
 * Stream------------->使用函数式接口在集合类上进行复杂操作的工具
 * java8中的stream中的map与flatMap的区别
 * flatMap与map的区别在于flatMap：
 * map的作用在于把一个流映射到另一个流中去----->另一个流就是指map之后系统会自动生成一个temp(临时)流
 * flatMap的作用在于把两个流合并成一个流
 * 将一个流中每个值都转成一个个流，然后再将这些流扁平化成为一个流
 */
class streamTest
{
    String str="zhang";
    private List<Integer>list=new ArrayList<Integer>(5);
    private String[] strs= {"java8","is","easy","to","use"};//map的作用相当于把strs中的每个string变成string[]里面的string元素就是
    //之前的sring中的字符，java8变成一个string[],is变成一个string[]等等，而flatMap的作用就是把这些string[]变成一个string[]
    //里面的string元素依旧是之前的string中的单个字符，相当于把之前不相干的几家人变成一家人一样，而map相当于一家人中每个人结婚又单独
    //成了一个家，flatMap则把这些家合在一起了--------------->*****
    public boolean ex2()
    {    
        //String[] src=str.split("");  //src.split(",");作用是将src中的元素按照，去进行分割--->也就是说如果src中有,则这个符号前后的字符会被分割成两个String
        //for(String dd:strs)
            //System.out.println(dd);
        //Arrays.stream(strs).map(str->str.split("")).flatMap(str->Arrays.stream(str)).forEach(System.out::print);
        List<String>ll=Arrays.stream(strs).map(str->str.split("")).flatMap(str->Arrays.stream(str)).collect(Collectors.toList());
        System.out.println(ll.get(0));
        //上述的操作的作用是将strs数组中的每一个String的每个字符都分割成一个String
        list.add(15);
        list.add(14);
        list.add(13);
        List<String>ss=new ArrayList<String>();
        //list=list.stream().limit(2).collect(Collectors.toList());   //只取前两个，与skip不同，skip是跳过前n，limit是只取前n个
        //ss=list.stream().map(item->Integer.toString(item)).collect(Collectors.toList());//通过map可将这个流中的元素映射到另一个流中
        //期间可以改变元素的类型，大小写等的问题
        //list=list.stream().skip(1).collect(Collectors.toList()); //跳过前n个元素
        //list=list.stream().filter(item->item.equals(15)).collect(Collectors.toList());//对list集合进行过滤只要值等于15的
        //再将流中的元素收集到一个集合中去collect(Collectors.toList());
        //Collections.fill(list, 100);  //将集合中的元素重新全部赋值为100,如果集合中没有元素则不做任何的处理
        //System.out.println(Collections.binarySearch(list, 1));   //通过二分查找找到指定元素在集合中的下标，找不到则返回-1
        //Collections.sort(list, (item1,item2)->item2-item1);   //通过lambda表达式去重新构造比较函数
        //Collections.sort(list);          //将集合中的元素进行排序
        //Collections.reverse(list);     //将集合中的元素进行翻转
        //list.forEach(System.out::println);
        //ss.forEach(item->System.out.println(item));
        //distinc.forEach(item->System.out.println(item));
        return true;
    }
}

class Solution
{
    private List<Integer>list=new ArrayList<Integer>();
    private Map<Integer,Character>map=new HashMap<Integer,Character>();
    private Integer arr[]= {1,2,3,4,5,6,7};
    
    public boolean ex1()
    {
        map.put(1,‘a‘);
        map.put(2,‘b‘);
        map.put(3,‘c‘);
        map.put(4,‘d‘);
        String str="sd";
        str.startsWith("x");     //找出str中以‘x‘开头的string字符串
        str.toUpperCase();       //String中的静态方法   //两者都可以成为过滤器lambda表达式的参数
        list=Arrays.asList(arr);
        Stream<Integer>stream=list.stream();
        stream.forEach(item->System.out.println(item+3));           //stream聚合流的遍历方法
        map.forEach((a,b)->System.out.println(a+":"+b));            //lambda表达式的遍历方法
        List<Map.Entry<Integer, Character>>ss=new ArrayList<Map.Entry<Integer,Character>>(map.entrySet());
        Queue<Map.Entry<Integer,Character>>queue=new PriorityQueue<Map.Entry<Integer,Character>>((a,b)->b.getValue()-a.getValue());//lambda表达式的写法
        Queue<Map.Entry<Integer, Character>>qq=new PriorityQueue<Map.Entry<Integer,Character>>(new Comparator<Map.Entry<Integer,Character>>(){

            @Override
            public int compare(Entry<Integer, Character> arg0, Entry<Integer, Character> arg1) {
                // TODO Auto-generated method stub
                return arg1.getValue()-arg0.getValue();
            }            
        });                    //普通的比较函数的写法
        queue.add(ss.get(0));   //
        ss.forEach(a->System.out.println(a.getKey()+":"+a.getValue()));   //普通的遍历方法
        return true;
    }
        
}


public class Main {

    public static void main(String[] args) {
       //Solution space=new Solution();
       //space.ex1();
        streamTest ss=new streamTest();
        ss.ex2();
    }
}