第十节 Java工具包-Collections 流--lambada表达式
collection为核心的接口，包含了多种不同类型的集合以及多种不同数据结构的实现的类
list set queue都是在collection接口下的所以都有.add()方法
package cn.nefu.com;
import java.util.List;
import java.util.ArrayList;
import java.util.AbstractMap;
public class S47 {
public static void main(String[] args)
{
List list=new ArrayList();//泛型限制了集合中元素的类型
list.add("aaa");//有序
list.add("bbb");
list.add("ccc");
for(int i=0;i 
list中的元素是有序的 list集合自己就做好了排序 list还可以包含重复元素，因为它 带有标号（操作系统自带的）
list是接口 所以不能实例化出对象(new) 要去帮助文档中去找基本实现的类 有很多 比较常见的如ArrayList(实现类)
list集合怎么取出元素，完成迭代？
1.利用list.size()方法
2.利用for each语句 第一节课也讲过哦
其实for each语句就相当于类的封装了，便于使用 表示从list集合中取出元素，直到集合里面没有元素为止
注意：集合list当中可以放任何类型的元素，整型啊 double 字符串都可以 我们为了便于迭代时取出元素还为了让集合中的元素有约束所以引入了泛型的概念
当试图向集合中添加不匹配的类型对象时 编译错误
因为集合中不关心元素的具体类型，所以引出泛型
当声明元素类型为基本数据类型而不是引用数据类型时 编译出错
int double 这些是基本数据类型 要对所有基本数据类型进行封装 Integer Double---就是E
为什么要把它进行封装呢？因为它提供了一些好用的方法 提供双精度浮点数的一些方法
int Integer.parseInt();
字符转成字符串 字符串转字符怎么转要会
集合list怎么去遍历 怎么去找
集合 怎么放怎么取 ？ 迭代
迭代器功能 迭代器遍历
map引用对象-------它是接口 要用实现的类去new put get
map集合遍历 去找这个里面有多少个键值
keyset 获得键值 for each 之后根据每一个键值输出每一个键值所对应的值
public class S47 {
public static void main(String[] args)
{
Iterator iterater=list.iterator();//迭代器 模拟集合一次往下查询//获取迭代器
while(iterator.hasNext())
{
System.out.println(iterator.next());
}
Map map=new HashMap();
map.put("200000",233)//自己指定键值 键值区别开value可以重复
}
}
jdk1.8之后遍历----函数式编程 函数
函数式编程算是java中的另类了
Lambada表达式-----Lambada允许把函数作为一个方法的参数（函数作为参数传到方法中）
lambada表达式不是单独存在的 它要和函数式接口/函数式编程结合在一起
(arg1, arg2) -> expression（函数体语句）
(arg1, arg2) -> {body}//无函数名 只使用
java.util.stream.Stream
对流的使用要用到lambada表达式
我们的流中就采用了函数式接口
package com.example21.collectionstream;
public class Apple {
public enum Color{
RED, GREEN
}
private int id;
private Color color;
private int weight;
public Apple(int id, Color color, int weight) {
this.id = id;
this.color = color;
this.weight = weight;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Color getColor() {
return color;
}
public void setColor(Color color) {
this.color = color;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
}
package cn.nefu.com.zn;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamTest {
private static final List APPLES = create();//常量大写，我们定义一个常量，里面是list类型，定义一个apple的筐，要装苹果
//所有的常量要不在构造方法的时候初始化，要不在定义的时候初始化//调用了创建方法，说明筐里要装什么东西
private static List create() {//创建方法返回的集合的引用
Apple a = new Apple(1, Apple.Color.RED, 200);
Apple a2 = new Apple(2, Apple.Color.GREEN, 250);
Apple a3 = new Apple(3, Apple.Color.RED, 260);
Apple a4 = new Apple(4, Apple.Color.GREEN, 230);
List apples = new ArrayList<>();
apples.add(a);
apples.add(a2);
apples.add(a3);
apples.add(a4);
return apples;//苹果放到集合中，筐里装了四个苹果了，两个红的，两个绿的
}
public static void main(String[] args) {
//forEach();
/*filter(Apple.Color.RED)
.forEach(a -> System.out.println(a.getId()));*/
//map();
sorted();
// sortedReversed();
// collect();
//collectGroupingBy2();
}
/**
* foreach循环
* forEach()方法，简写//对集合遍历
*/
private static void forEach() {
for (Apple a : APPLES) {//for each 去筐里取apple的对象 ，集合中每一个元素都是苹果
System.out.println(a.getWeight());//对集合进行依次遍历
}
APPLES.forEach((Apple apple)-> {System.out.println(apple.getWeight());});//foreach一创建 这里面的形参就是在集合里取走的元素
}//我们学习了lambada表达式之后 可以使用集合给我们提供的foreach()方法 这个方法里装什么？装的lambada表达式（函数接口） 对集合中的元素进行什么处理
/**
* 原实现。返回指定颜色的全部苹果
*/
private static List getRedApples(Apple.Color c) {//要么是红色，要么是绿色，去筐里找指定的颜色，还得把颜色给返回来
List reds = new ArrayList<>();//new 一个list
for (Apple a : APPLES) {
if (a.getColor().equals(c)) {//==号是引用空间的比较
reds.add(a);//这个筐去装红色的苹果
}
}
return reds;
}/*
/**
* 基于stream的过滤
* 修改方法返回值，方法链
* 比较源/新集合
*
* @param c
*/
private static List filter(Apple.Color c) {//所有集合
return APPLES.stream()//返回集合流
.filter(a -> a.getColor() == c)//不影响原集合 新的集合流
.collect(Collectors.toList());//集合流变成集合
}
/**
* 过滤指定颜色，且大于等于指定重量的苹果。2次过滤
*
* @param c
* @param weight
*/
private static void filter(Apple.Color c, int weight) {
APPLES.stream()
.filter(a -> a.getColor() == c)
.filter(a -> a.getWeight() >= weight)
.collect(Collectors.toList())//组合 集成一下 把流变成集合 流中的元素聚合成集合
.forEach(a -> System.out.println(a.getId()));
}
/**
* 将重量映射为新集合，遍历打印
* 简写
*/
private static void map() {
APPLES.stream()//获取集合流
.map(Apple::getWeight)//从这个流中获得新的集合----新的集合，里面放的苹果的重量
.collect(Collectors.toList())
.forEach(System.out::println);//运行某一个类调用方法
.forEach(apple->System.out.println())
}
/**
* 以重量顺序排序
*/
private static void sorted() {//升序
APPLES.stream()
.sorted(Comparator.comparing(Apple::getWeight))
.collect(Collectors.toList())
.forEach(a -> System.out.println(a.getWeight()));
}
/**
* 以ID逆序排序
*/
private static void sortedReversed() {
APPLES.stream()//提供了对集合的一大堆操作
.sorted(Comparator.comparing(Apple::getId).reversed())
.collect(Collectors.toList())
.forEach(a -> System.out.println(a.getId()));
}
/**
* 获取颜色，分别按list/set聚合
*/
private static void collect() {
APPLES.stream()
.map(Apple::getColor)
.collect(Collectors.toSet())
.forEach(System.out::println);
}
/**
* Map操作。基于颜色分组
*/
private static void collectGroupingBy() {
Map> map = APPLES.stream()
.collect(Collectors.groupingBy(Apple::getColor));
}
/**
* 以ID为键，苹果对象为值。自定义键值对
* forEach遍历
*/
private static void collectGroupingBy2() {
APPLES.stream()
.collect(Collectors.toMap(Apple::getId, a -> a))
.forEach((k, v) -> {
System.out.println(k + "/" + v.getColor());
});
}
/**
* 函数中，只能操作函数体外的常量
*/
private static void finalValue() {
int count = 0;
APPLES.forEach(a -> {
System.out.println(count);
});
}
/**
* 2组过滤相同
*/
private static void getFilter() {
Apple a1 = new Apple(1, Apple.Color.RED, 200);
Apple a2 = new Apple(5, Apple.Color.GREEN, 240);
List newApples = List.of(a1, a2);
List oldApples = APPLES;
List apples = new ArrayList<>();
for (Apple a : newApples) {
for (Apple oa : oldApples) {
if (a.getId() == oa.getId()) {
apples.add(a);
}
}
}
apples.forEach(a -> System.out.println(a.getId()));
System.out.println("--------------");
List apples2 = newApples.stream()
.filter(a -> oldApples.stream()
.anyMatch(oa -> oa.getId() == a.getId()))
.collect(Collectors.toList());
apples2.forEach(a -> System.out.println(a.getId()));
}
}
利用foreach方法 lambada表达式 配合 形参赋值
函数调用四次 形参名字随便
集合中都有这个方法 取值放函数形参里 形参输出 经常用 触发函数四次
集合流 不管存储 操作集合元素通道 筛选工作和获取流
利用流的方式去选苹果 苹果选颜色 按照函数规则去遍历