有关ES和集合的一些方法

java8 stream().map().collect()的Collectors.toList()、Collectors.toMap()、Collectors.groupingBy()的用法

一、Collectors.toList()

1、现在有个集合：

List<User> users = getUserList( );

现在需要将这些user的id提取出来，这个很简单，for循环

List<Long> idList = new ArraryList<Long>();

for( int i = 0; i < user.size(); i++）{

idList.add(users.get(i).getId());

}

然而Java8有个更简单的方法，一行代码搞定

List<Long> idList = users.stream.map(User::getId).collect(Collectors.toList());

二、Collecttors.toMap()

Collect.toMap(), 一般用于将一个List转换为Map,常见方法:

list.stream().collect(Collectors.toMap(Function keyMapper, Funciton valueMapper))

可以接收2个、3个、4个参数，但是我们一般只用2个的或者3个的就已经足够。这里我也就只讲2个和3个参数的方法。

第一个参数，用于指定key的Function;

第二个参数，用于指定value的的Function；

第三个参数，若在转换中，出现多个key，如何进行合并的Function。

1、两个参数的用法

现在有个user对象：

@Getter

@Setter

 public class User{

     private Long id;

     private String name;

     private Integer age;

   public User(Long id, String name, Integer age）{

   this.id = id;

   this.name = name;

   this.age = age;

  }

}

然后进行以下操作：

List<User> userList = new ArrayList<>();

userList.add(new User(1,"张三",18));

userList.add(new User(2,"李四",19));

userList.add(new User(3,"王五",18));

//将userList转化为key为id,value为User对象的Map

Map<Long, User> map = userList.stream().collect(Collectors.toMap(User::getId,p->p));

Map<Long, User> map = userList.stream().collect(Collectors.toMap(User::getId,p->p));这一步就是将userList转换为key为id，value为User对象的map.

User::getId       User对象的getId方法

p->p    就是进来是什么，最终就是什么，这里就是进来的User对象，出去的也就是User对象

而这时map里模拟的值是：

{

1：User(1,“张三",18）

2： User(2,"李四",19）

3： User(3,"王五”,18）

}

还可以换一下：

Map<Long,String> map = userList.stream().collect(Collectors.toMap(User:: getId, User ::getName));

这个获取的就是key为id, value为name的map了。

2、三个参数的用法

还是沿用上面的例子，如果这个时候你想获取的key是age,value是name的map呢？如果你还是沿用上面的方法，就会出问题了，原因是两个age是18的数据，也就是存在重复的key，会直接报错，如果不想报的话，就可以利用第三个参数了。

Map<Long, String> map = userList.stream().collect(Collectors.toMap(User::getAge, User::getName,（a,b)->b));

(a,b)->b的意思就是，如果存在重复的，永远取后面一个

这时,map里的值就是：

{

18：“王五”

19：“李四”

}

三、Collectors.groupingBy()

还是沿用上面的例子，当你想获取key是age的map,又不想被覆盖重复项数据，这个时候就可以用Collectors.groupingBy了。

Map<Integer, List<User>> map = userList.stream().collect(Collectors.groupingBy(User::getAge));

可以看到，这次的返回值变成了Map<Integer,List>了，也就是说，变成了key是age,value是User对象的集合了。这时，map里的值就变成了:

{

18：[User(1,"张三",18），User(3,"王五",18）]

19：[User(2, "李四”，19）]

}

ES聚合查询

1、桶聚合Bucket Aggregations

它执行的是对文档分组的操作（与sql中的group by类似), 把满足相关特性的文档分到一个桶里，输出的结果往往是一个个包含多个文档的桶。

它有一个关键字（field, script)，以及一些桶分组的判断条件。执行聚合时，文档会判断每个分组条件，如果满足条件，该文档就会被分为该组。

它不进行权值计算，他们对文档根据聚合请求中提供的判断条件（比如:{"from":0,"to":100})来进行分组（桶分).桶聚合还会额外返回每一个桶内文档的个数。

它可以包含子聚合———subaggregations,子聚合操作将会应用到由父聚合产生的每一个桶上。

它根据聚合条件，可以只定义输出一个桶，也可以输出多个桶（multi-bucket）;还可以根据聚合条件动态确定桶个数（比如：terms aggregation).

Terms Aggregation

Terms Aggregation,词聚合，基于某个field，该field内的每一个词单元为一个桶，并计算每个桶内文档个数。默认返回顺序是按照文档个数多少排序。它属于multi-bucket.当不返回所有buckets的情况，文档个数可能不准确。

POST /bank/_search?size=0
{
    "aggs" : {
        "age_terms" : {
            "terms" : {
              "field" : "age",
              "size" : 10,                              //size用来定义需要返回多个 buckets（防止太多），默认会全部返回。
              "order" : { "_count" : "asc" },  //根据文档计数排序，根据分组值排序（{ "_key" : "asc" }）
              "min_doc_count": 10,            //只返回文档个数不小于该值的 buckets
              "include" : ".*sport.*",            //包含过滤
              "exclude" : "water_.*",          //排除过滤
              "missing": "N/A"
            }
        }
    }
}

POST /bank/_search?size=0
{
  "aggs": {
    "age_terms": {
      "terms": {
        "field": "age",
        "size": 5,
        "shard_size": 20, //指定每个分片返回多少个分组，默认值（索引只有一个分片：= size，多分片：= size * 1.5 + 10）
        "show_term_doc_count_error": true      //每个分组上显示偏差值
      }
    }
  }
}
{//返回
    ...
  "aggregations": {
    "age_terms": {
      "doc_count_error_upper_bound": 0, //文档计数的最大偏差值
      "sum_other_doc_count": 463,           //未返回的其他项的文档数
      "buckets": [                //默认情况下返回按文档计数从高到低的前10个分组
        {
          "key": 31,              //年龄为31的文档有61个
          "doc_count": 61
        },
        {
          "key": 39,            //年龄为39的文档有60个
          "doc_count": 60
        },
        {
          "key": 34,
          "doc_count": 49
        }
      ]
    }
  }
}
Filter Aggregation

Filter Aggregation, 过滤聚合，基于一个条件，来对文档进行过滤的聚合。

POST /bank/_search?size=0
{
  "aggs": {
    "age_terms": {
      "filter": {"match":{"gender":"F"}},
      "aggs": {
        "avg_age": {
          "avg": {
            "field": "age"
          }
        }
      }
    }
  }
}
{//返回
    ...
  "aggregations": {
    "age_terms": {
      "doc_count": 493,
      "avg_age": {
        "value": 30.3184584178499
      }
    }
  }
}
Filters Aggregation

Filters Aggregation, 多过滤聚合。基于多个过滤条件，来对文档进行过滤的聚合，每个过滤都包含满足它的文档（多个bucket中可能重复），先过滤再聚合，属于multi-bucket.

GET logs/_search
{
  "size": 0,
  "aggs": {
    "messages": {
      "filters": { // 配置过滤条件，支持 HASH 或 数组格式
        "filters": {
          "errors": {
            "match": {
              "body": "error"
            }
          },
          "warnings": {
            "match": {
              "body": "warning"
            }
          }
        }
      }
    }
  }
}
{//返回
    ...
  "aggregations": {
    "messages": {
      "buckets": {
        "errors": {
          "doc_count": 1
        },
        "warnings": {
          "doc_count": 2
        }
      }
    }
  }
}
Range Aggregation 范围分组聚合，基于某个值（可以是field或script），以字段范围来桶分聚合，范围聚合包括from 值，不包括to值（区间前闭后开),属于multi-bucket.

POST /bank/_search?size=0
{
  "aggs": {
    "age_range": {
      "range": {
        "field": "age",
        "ranges": [ //配置区间
          {
            "to": 25
          },
          {
            "from": 25,
            "to": 35
          },
          {
            "from": 35
          }
        ]
      },
      "aggs": {
        "bmax": {
          "max": {
            "field": "balance"
          }
        }
      }
    }
  }
}
{//返回
    ...
  "aggregations": {
    "age_range": {
      "buckets": [
        {
          "key": "*-25.0",
          "to": 25,
          "doc_count": 225,
          "bmax": {
            "value": 49587
          }
        },
        {
          "key": "25.0-35.0",
          "from": 25,
          "to": 35,
          "doc_count": 485,
          "bmax": {
            "value": 49795
          }
        },
        {
          "key": "35.0-*",
          "from": 35,
          "doc_count": 290,
          "bmax": {
            "value": 49989
          }
        }
      ]
    }
  }
}