都9102年了，你还用for循环操作集合吗

// 对苹果按颜色汇总并绩数量

map<string, long > applecount = apples.stream()

  .collect(groupingby(apple::getcolor, counting()));

// 过滤掉颜色为黑色的苹果，并汇总好苹果的总金额

double sum = apples.stream()

  .filter(i-> "black" .equals(i.getcolor()))

  .collect(tolist);

// 普通函数

public void run(string s){

  system.out.print(s+ "哈哈" );

}

// 我不要名字啦！！！

(s)->system.out.print(s+ "哈哈" )

// 实现runnable中的run方法，替代匿名内部类。

runnable r = ()->system.out.print( "哈哈" );

// 作为参数传递。

new thread(()-> system.out.println( "haha" )).start();

arraylist<apple> list = new arraylist<>();

list.foreach(i-> system.out.println(i.getweight()));

// 简化策略模式

public static list<apple> filterapples(list<apple> inventory,applepredicate p){

  list<apple> apples = new arraylist<>();

  for (apple apple : inventory){

  if (p.test(apple)){

  apples.add(apple);

  }

  }

  return apples;

}

public class bigapple implement applepredicate{

  @override

  public boolean test(apple a){

  if (a.getweight> 10 ){

  return a

  }

  }

}

// 这是个简单的策略模式，根据用户的需要，创建不同的接口applepredicate实现类,调用时传入不同的实现类就可以，但问题是如果需求过多，创建的实现类也会很多，过于臃肿不方便管理。

xx.filterapple(inventory, new bigapple);

// 使用lambda表达式，不在需要创建bigapple类

xx.filterapple(inventory,i->(i.getweight> 10 ));

//入参s,返回void

(s)->system.out.println(s);

//入参空，返回void

()->system.out.print( "haha" );

//入参i,返回i+1

i->i+ 1

//后面写代码块

apple->{ if (apple.getweiht> 5 ) return "big" ;

  else return "small" ;

  }

list< double > collect = list.stream()

  // 过滤掉黑色的苹果

  .filter(i -> "black" .equals(i.getcolor()))

  // 让苹果按照重量个价格排序

  .sorted(comparator测试数据paring(apple::getweight)

  .thencomparing(i->i.getprice()))

  // 筛选掉重复的数据

  .distinct()

  // 只要苹果的价格

  .map(apple::getprice)

  // 只留下前两条数据

  .limit( 2 )

  // 以集合的形式返回

  .collect(tolist());

// 循环打印列表中元素

list.foreach(i->system.out.print(i));

list<string> strings = arrays.aslist( "hello" , "world" );

list<string> collect1 = strings.stream()

  // string映射成string[]

  .map(i -> i.split( "" ))

  // arrays::stream 数据数组，返回一个流string[]->stream<string>

  // flatmap各数组并不分别映射成一个流，而是映射成流的内容 stream<string>->stream

  .flatmap(arrays::stream)

  .collect(tolist());

system.out.println(collect);

----->输出 [h, e, l, l, o, w, o, r, l, d]

list<integer> integers = arrays.aslist( 12 , 3 , 45 , 3 , 2 ,- 1 );

// 有初始值的叠加操作

integer reduce = integers.stream().reduce( 3 , (i, j) -> i + j);

integer reduce2 = integers.stream().reduce( 5 , (x, y) -> x < y ? x : y);

// 无初始值的叠加操作

optional<integer> reduce1 = integers.stream().reduce((i, j) -> i + j);

// 无初始值的最大值

optional<integer> reduce4 = integers.stream().reduce(integer::min);

// 无初始值的最大值

optional<integer> reduce5 = integers.stream().reduce(integer::max);

// 求和

optional<integer> reduce6 = integers.stream().reduce(integer::sum);

// 数值流求平均值

optionaldouble average = apples.stream()

  .maptodouble(apple::getprice)

  .average();

// 数值流求和

optionaldouble average = apples.stream()

  .maptodouble(apple::getprice)

  .sum();

// 数值流求最大值，没有则返回2

double v = apples.stream()

  .maptodouble(apple::getprice)

  .max().orelse( 2 );

// 生成随机数

intstream s = intstream.rangeclosed( 1 , 100 );

stream<string> s = stream.of( "java" , "python" );

int [] i = { 2 , 3 , 4 , 5 };

stream< int > = arrays.stream(i);

stream<string> s = files.lines(paths.get( "data.txt" ),charset.defaultcharset());

// 迭代

stream.iterate( 0 ,n->n+ 2 )

  .limit( 10 )

  .foreach(system.out::println);

// 生成,需要传递实现supplier<t>类型的lambda提供的新值

stream.generate(math.random)

  .limit( 5 )

  .foreach(system.out::println);