Java学习 第三十一章 Stream流 / 方法引用

最新推荐文章于 2024-01-24 07:00:00 发布
最新推荐文章于 2024-01-24 07:00:00 发布
阅读量177 收藏
点赞数
分类专栏： Java 学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40027172/article/details/106956000
版权

第三十一章

一、Stream流

1.1 使用传统的方式遍历集合，对集合中的数据进行过滤

/*
    使用传统的方式，遍历集合，对集合数据进行遍历
 */
public class Demo01List {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张三丰");
        list.add("张三");

        //遍历集合，存储张开头的元素到集合中
        List<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")){
                list1.add(s);
            }
        }
        //遍历集合，存储名字长度为3的
        List<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if (s.length() >= 3){
                list2.add(s);
            }
        }
        //循环打印
        for (String s : list2) {
            System.out.println(s);//张无忌 张三丰
        }

      

    }

}

1.2 使用传统的方式遍历集合，对集合中的数据进行过滤


/*
    使用Stream流方式遍历，过滤
    Stream流是JDK1.8之后出现的
 */
public class Demo01Stream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张三丰");
        list.add("张三");

        //遍历集合，存储张开头的元素到集合中
        //遍历集合，存储名字长度为3的
        //循环打印
        list.stream()
                .filter(name->name.startsWith("张"))
                .filter(name->name.length()==3)
                .forEach(name-> System.out.println(name));
        /*
        打印结果
        张无忌
        张三丰
         */
        
    }

}

1.3 流式思想概述

在这里插入图片描述
在这里插入图片描述

1.4 两种获取Stream流的方式

/*
    java.util.stream.Stream<T> 是java8新加入的最常用的流接口。
    获取一个流非常简单，有以下几种常用的方式：
        所有的Collection集合都可以通过stream默认方法获取流。
         default Stream<E> stream()
         Stream 接口的静态方法of可以获取数组对应的流
           static <T> Stream<T> of (T...values)
           参数是一个可变参数，那么我们就可以传递一个数组
 */
public class Demo02GetStream {
    public static void main(String[] args) {
        //把集合转换为Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        Map<String,String> map = new HashMap<>();
        //获取键，存储到一个set集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();
        //获取值，存储到一个Collection集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        //获取键值对(键值与映射的关系 entrySet)
        Set<Map.Entry<String,String>> entries = map.entrySet();
        Stream<Map.Entry<String,String>> stream5 = entries.stream();

        //把数组转换为Stream流
        Stream<Integer> stream6 = Stream.of(1,2,3,4,5);
        //可变参数可以传递数组
        Integer[] arr ={1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);

        String[]  arr2 ={"a","bb","ccc"};
        Stream<String> stream8 = Stream.of(arr2);

    }
}

1.8 Stream流中的常用方法—forEach（终结方法）

在这里插入图片描述

/*
    Stream流中的常用方法——forEach
    void forEach(Consumer<? super T> action);
    该方法接收一个Consumer接口函数，会将每一个流元素交给该函数处理。
    Consumer是一个消费型的函数式接口，可以传递Lambda表达式，消费数据

    简单记:"
        forEach方法，用来遍历流中的数据
        是一个终结方法，遍历之后就不能继续调用Stream流中的其他方法
 */
public class Demo03SteamForEach {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("张三","李四","王五","赵六");
        //使用Stream流中的方法forEach对Stream流中的数据进行遍历
       /* stream.forEach((String name)->{
            System.out.println(name);
        });*/
        stream.forEach( name-> System.out.println(name));


    }
}

1.9 Stream流中的常用方法—filter

/*
    Stream流中的常用方法filter：用于对Stream流中的数据进行过滤
    Stream<T> filter(Predicate<? super ?> predicate);
    filter方法的参数是一个函数式接口，可传递Lambda表达式
    Predicate中的抽象方法：boolean test(T t)
 */
public class Demo04Streamfilter {
    public static void main(String[] args) {
        //创建一个Stream流
        Stream<String> stream = Stream.of("张三丰","张翠山","赵敏","周芷若");
        //对Stream流中的元素进行过滤，只要姓张的人
        Stream<String> stream2 =stream.filter((String name)->{
            return name.startsWith("张");
        });

        //遍历Stream2流
        stream2.forEach(name-> System.out.println(name));

        /*
        Stream 流属于管道流，只能被消费一次
        第一个Stream流调用完毕方法，数据就会流转到下一个Stream上
        而这时第一个Stream流已经使用完毕，就会关闭了
        所以第一个Stream流就不能再调用方法了
         */
        //遍历Stream流
        stream.forEach(name-> System.out.println(name));
        //IllegalStateException: stream has already been operated upon or closed


    }
}

1.10 Stream流中的特点-只能使用一次

Stream 流属于管道流，只能被消费一次

   /* 
        第一个Stream流调用完毕方法，数据就会流转到下一个Stream上
        而这时第一个Stream流已经使用完毕，就会关闭了
        所以第一个Stream流就不能再调用方法了
         */
        //遍历Stream流
        stream.forEach(name-> System.out.println(name));
        //IllegalStateException: stream has already been operated upon or closed

1.11 Stream流中的常用方法—map(映射)

如果需要将流中的元素映射到另一个流中，可以使用map方法：

<R> Stream<R> map(Function<? super T,? extends R> mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流
Function中的抽象方法：
    R apply(T t)；

public class Demo05Stream_map {
    public static void main(String[] args) {
        //获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //使用map方法，把字符串类型的整数转换（映射）为Integer类型的整数
        Stream<Integer> stream2 = stream.map((String s)->{
            return  Integer.parseInt(s);
        });

        //遍历Stream2流
        stream2.forEach(i-> System.out.println(i));

    }
}

1.11 Stream流中的常用方法—count（终结方法）

import java.util.ArrayList;
import java.util.stream.Stream;
/*
    Stream流中的方法——count：用于统计Stream流中的元素个数
    long count();
    count方法是一个中介方法，返回值是一个long类型的整数
    所以不能再继续调用Stream流中的其他方法了
 */
public class Demo06Count {
    public static void main(String[] args) {
        //获取一个Stram流
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);//6
    }
}

1.12 Stream流中的常用方法—limit

/*
 Stream流中的方法——limit：用于截取流中的元素
 limit方法可以对流进行截取,只取用前n个.方法签名：
 Stream<T> limit(long maxSize);
  参数是一个long 类型，如果集合长度大于参数则进行截取，否则不进行操作
  limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法

 */
public class Demo07Limit {
    public static void main(String[] args) {


    //获取一个Stream流
    String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼"};
    Stream<String> stream = Stream.of(arr);

    //使用limit对Stream流中的元素进行截取，只要前三个元素
    Stream<String> stream2 = stream.limit(3);
    //遍历stream2流

     stream2.forEach(str-> System.out.println(str));//美羊羊喜羊羊懒羊羊
        
        

    }
}

1.13 Stream流中的常用方法—skip

/*
  Stream流中的方法——skip：用于跳过元素
  如果流的当前长度大于n，则跳过前n个否则就会得到一个长度为0的空流
 */

import java.util.stream.Stream;

public class Demo08Skip {
    public static void main(String[] args) {

        //获取一个Stream流
        String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼"};
        Stream<String> stream = Stream.of(arr);

        //使用skip跳过Stream流中的前三个元素
        Stream<String> stream2 = stream.skip(3);
        //遍历stream2流

        stream2.forEach(str-> System.out.println(str));//灰太狼  红太狼
      



    }
}

1.14 Stream流中的常用方法—concat（组合方法）

/*
    Stream.concat( stream1 ,stream2) 将两个流合并到一起  
 */
public class Demo09Concat {
    public static void main(String[] args) {
        //创建两个Stream流
        Stream<String> stream1 = Stream.of("张三丰","张翠山","赵敏","周芷若");
        String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼"};
        Stream<String> stream2 = Stream.of(arr);
        //把以上两个Stream流合并到一起
        Stream<String> concat = Stream.concat(stream1,stream2);
        //遍历concat流
        concat.forEach((name-> System.out.println(name)));



    }
}

1.15 练习：集合元素处理（传统方式）

在这里插入图片描述


/*

题目：
现在有两个Arraylist集合存储队伍当中的多个成员姓名,要求使用传统的for循环(或增强for循环)
依次进行以下若干操作步骤:
    1.第一个队伍只要名字为3个字的成员姓名;存储到一一个新集合中。
    2.第一个队伍筛选之后只要前3个人;存储到-一个新集合中。
    3.第二个队伍只要姓张的成员姓名;存储到一一个新集合中。
    4.第二个队伍筛选之后不要前2个人;存储到一一个新集合中。
    5.将两个队伍合并为一一个队伍;存储到一一个新集合中。
    6.根据姓名创建Person对象;存储到一个新集合中。
    7.打印整个队伍的Person对象信息。
 */
public class Demo01Test {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石终与");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        // 1.第一个队伍只要名字为3个字的成员姓名;存储到一一个新集合中。
        ArrayList<String> one1 = new ArrayList<>();
        for (String name : one) {
            if (name.length()==3){
                one1.add(name);
            }

        }
        //   2.第一个队伍筛选之后只要前3个人;存储到-一个新集合中。
        ArrayList<String> one2 = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            one2.add(one1.get(i)); //i=0 ,1,2
        }


        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");

        // 3.第二个队伍只要姓张的成员姓名;存储到一一个新集合中。
        ArrayList<String> two1 = new ArrayList<>();
        for (String name : two) {
            if (name.startsWith("张")){
                two1.add(name);
            }
        }
        //4.第二个队伍筛选之后不要前2个人;存储到一一个新集合中。
        ArrayList<String> two2 = new ArrayList<>();
        for (int i =2;i<two1.size();i++){
            two2.add(two1.get(i));//i不包含0 1
        }

        //5.将两个队伍合并为一一个队伍;存储到一一个新集合中。
        ArrayList<String> all = new ArrayList<>();
        //addAll添加一个集合
        all.addAll(one2);
        all.addAll(two2);

        // 6.根据姓名创建Person对象;存储到一个新集合中。
        ArrayList<Person> list = new ArrayList<>();
        for (String name : all) {
            list.add(new Person(name));
        }
        // 7.打印整个队伍的Person对象信息。
        for (Person person : list) {
            System.out.println(person);

        }

    }

}


public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

1.16 练习：集合元素处理（Stream流方式）

/*
 1.第一个队伍只要名字为3个字的成员姓名;存储到一一个新集合中。
    2.第一个队伍筛选之后只要前3个人;存储到-一个新集合中。
    3.第二个队伍只要姓张的成员姓名;存储到一一个新集合中。
    4.第二个队伍筛选之后不要前2个人;存储到一一个新集合中。
    5.将两个队伍合并为一一个队伍;存储到一一个新集合中。
    6.根据姓名创建Person对象;存储到一个新集合中。
    7.打印整个队伍的Person对象信息。
 */
public class Demo02Stream {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石终与");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        // 1.第一个队伍只要名字为3个字的成员姓名;存储到一一个新集合中。
        //2.第一个队伍筛选之后只要前3个人;存储到-一个新集合中。
        Stream<String> onestream = one.stream().filter(name->name.length()==3).limit(3);

        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");

        // 3.第二个队伍只要姓张的成员姓名;存储到一一个新集合中。
        //  4.第二个队伍筛选之后不要前2个人;存储到一一个新集合中。
       Stream <String> twoStream=  two.stream().filter(name->name.startsWith("张")).skip(2);
        // 5.将两个队伍合并为一一个队伍;存储到一一个新集合中。
        //    6.根据姓名创建Person对象;存储到一个新集合中。
        //    7.打印整个队伍的Person对象信息。
        Stream.concat(onestream,twoStream).map(name->new Person(name)).forEach(p-> System.out.println(p));
    }
}

二、方法引用

2.1 方法引用基本介绍

在这里插入图片描述

public class Demo01Printable {
    //定义一个方法，参数传递printable接口，对字符串进行打印
    public  static void printString(Printable p){
        p.print("HelloWorld");

    }

    public static void main(String[] args) {
        //调用printString方法，方法的参数Printable是一个函数式接口，所以可以传递Lambda
        printString((s)->{
            System.out.println(s);
        });
        /*
           Lambda表达式的目的,打印参数传递的字符串
    把参数s,传递给了System. out対象,凋用out对象中的方法println对字符串迸行了输出
    注意:
    1.System. out对象已经存在的
    2.println方法也是已经存在的
    所以我们可以使用方法引用来代化Lambda表达式
    可以使用System. out方法直接引用println方法
         */
        printString(System.out::println);
    }

}


/*
    定义一个打印的函数式接口
 */
@FunctionalInterface
public interface Printable {
    //打印字符串的方法
    void print(String s);
}

2.2 方法引用-通过对象名引用成员方法

主方法

/*
    通过对象名引用成员方法
    使用前提是对象名是已经存在的，成员方法也是已经存在的
    就可以使用对象名来引用成员方法
 */
public class Demo02ObjectMethodReference {
    //定义一个方法，方法的参数传递Printable接口
    public  static void printString(Printable p){
        p.print("hello");
    }

    public static void main(String[] args) {
        //调用printString方法，方法的参数是一个函数式接口，所以可以传递Lambda表达式
        printString((s)->{
            //创建MethodRerObject对象
            MethodRerObject obj = new MethodRerObject();
            //调用 MethodRerObject对象中的成员方法printUpperCaseString，大写输出字符串
            obj.printUpperCaseString(s);

        });
        /*
            使用方法引用优化
            对象已经存在了MethodRerObject
            成员方法也是已经存在的printUpperCaseString
            所以我们可以使用对象名引用成员方法
         */

        MethodRerObject obj = new MethodRerObject();
        printString(obj::printUpperCaseString);
    }

}

函数式接口

/*
    定义一个打印的函数式接口
 */
@FunctionalInterface
public interface Printable {
    //打印字符串的方法
    void print(String s);
}

生产对象的类

public class MethodRerObject {
    //定义一个成员方法，传递字符串，把字符串按照大写输出
    public void printUpperCaseString(String str){
        System.out.println(str.toUpperCase());
    }
}

2.3 方法引用-通过类名引用静态成员方法

/*
    通过类名引用静态成员方法
    类已经存在，静态成员方法也存在
 */
public class Static {
    //定义一个方法，方法的参数传递要计算整数的绝对值，和函数式接口Calcable
    public static int method(int number,Calcable c){
        return  c.calsAbs(number);
    }

    public static void main(String[] args) {
      int number=  method(-10,(n)->{
            //绝对值计算
            return Math.abs(n);
        });
        System.out.println(number);//10
        /*
            方法引用优化
            Math类存在 abs 静态方法存在
         */
       int number2=  method(-10,Math::abs);
        System.out.println(number2);//10
    }
}

2.4 方法引用-通过类名引用静态成员方法

/*
    通过类名引用静态成员方法
    类已经存在，静态成员方法也存在
 */
public class Static {
    //定义一个方法，方法的参数传递要计算整数的绝对值，和函数式接口Calcable
    public static int method(int number,Calcable c){
        return  c.calsAbs(number);
    }

    public static void main(String[] args) {
      int number=  method(-10,(n)->{
            //绝对值计算
            return Math.abs(n);
        });
        System.out.println(number);//10
        /*
            方法引用优化
            Math类存在 abs 静态方法存在
         */
       int number2=  method(-10,Math::abs);
        System.out.println(number2);//10
    }
}


@FunctionalInterface
public interface Calcable {
    //定义一个抽象方法，传递一个整数，对整数进行绝对值计算并返回
    int calsAbs(int number);

}

2.5 方法引用-通过super引用父类的成员方法

/*
定义父类
 */
public class Human {
    public void sayHello(){
        System.out.println("Hello,我是Human");
    }
}


/*
    定义见面的函数式接口
 */
@FunctionalInterface
public interface Greetable {
    //定义一个见面的方法
    void greet();
}


/*
定义子类
 */
public class Man extends Human{
    @Override
    public void sayHello() {
        System.out.println("我是Man");
    }
    //定义一个方法，参传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }
    public void show(){
        //调用method方法，方法的参数Greetable是一个函数式接口，所以可以传递Lambda
    /*    method(()->{
            //创建父类Human对象
            Human h = new Human();
            //调用父类对象
            h.sayHello();
        });*/
        //因为有子父类关系，所以存在一个关键字super代表父类，
        // 所以我们可以直接使用super调用父类的成员方法
     /*   method(()->{
            super.sayHello();
        });*/
        /*
            使用super引用父类的成员方法super是已经存在的
            父类的成员方法sayHello也是已经存在的
            所以我们可以直接用super引用父类的成员方法
         */
        method(super::sayHello);

    }

    public static void main(String[] args) {
        new Man().show();
    }
}

2.5 方法引用-通过this引用本类的成员方法

/*
    通过this引用本类的成员方法
 */
public class Husband {
    //定义一个买房子的方法
    public void buyHouse(){
        System.out.println("北京买房");
    }
    //定义一个结婚的方法
    public void marry(Richable r){
        r.buy();
    }
    //定义一个非常高兴的方法
    public void soHappy(){
        //调用结婚的方法，方法的参数Richable是一个函数式接口，传递Lambda表达式
    /*    marry(()->{
            //使用this.成员方法调用本类买房子的方法
            this.buyHouse();
        });*/
    /* 使用方法引用优化Lambda表达式
        this是已经存在的，本类成员的方法buyHouse也是存在的
        所以我们可以直接使用this引用本类的成员方法buyHouse

     */
    marry(this::buyHouse);

    }
    public static void main(String[] args){
        new Husband().soHappy();

    }

}


@FunctionalInterface
public interface Richable {
    //定义一个方法
    void buy();

}

2.6 方法引用—类的构造器（构造方法）引用

/*
    类的构造器（构造方法）引用
 */
public class Demo {
    //定义一个方法，参数传递姓名和PersonBuilder接口，方法中通过姓名创建Person对象
    public static void printName(String name ,PersonBuilder pb){
        Person person = pb.builderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        //调用printName方法，方法的参数PersonBuilder接口是一个函数式接口，可以传递Lambda
        printName("迪丽热巴",(String name)->{
            return new Person(name);
        });
        /*
         使用方法引用优化Lambda
         构造方法new Person(String name)已知
         创建对象已知
         就可以使用Person引用new 创建对象
         */
        printName("古力娜扎",Person::new);//使用Person类的带参构造方法，传递姓名创建对象

    }

}


/*
    定义一个创建Person对象的函数式接口
 */
@FunctionalInterface
public interface PersonBuilder {
    //定义一个方法，根据传递的姓名，创建Person对象返回
    Person builderPerson(String name);


}


public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2.6 方法引用—数组构造器引用


/*
    数组的构造器引用
 */
public class Demo {
    /*定义一个方法
        方法的参数传递创建数组的长度和ArrayBuilder接口
        方法内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
     */
    public static int[] createArray(int length,ArrayBuilder ab){
        return  ab.builderArray(length);
    }

    public static void main(String[] args) {
        //调用create方法，传递数组的长度和Lambda表达式
        int arr1[] = createArray(10,(len)->{
            //根据数组的长度创建并返回
            return  new int[len];

        });
        System.out.println(arr1.length);
        /*
             使用方法引用优化Lambda
             已知创建的就是int[]类型的数组
             数组长度已知
             就可以使用方法引用
             int[]引用new，根据参数传递的长度来创建数组

         */
        int[] array2 = createArray(10,int[]::new);
        System.out.println(Arrays.toString(array2));
        System.out.println(array2.length);//10

    }
}


/*
    定义一个创建数组的函数式接口
 */
@FunctionalInterface
public interface ArrayBuilder {
    //定义一个创建int类型数组的方法，参数传递数组的长度，返回创建好的int类型数组
    int[] builderArray(int length);
}
Z知行T
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA学习笔记2020/4/27——Stream流、方法引用
01-20
第一章 Stream流 说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.1 ...
Java-IO流/Stream流总结
07-12
Java-IO流/Stream流总结，内容一针见血，没有废话，言简意赅 内容：IO流及其分类、分类比较、转换流、缓存流、IO流异常处理、Stream流、Properties教程等。 适合人群：有编程基础及Java基础伙伴 适用场景：Java中的...
Java8 StreamAPI的forEach方法与Iterable 接口的forEach方法对比（及peek方法）
bachbrahms的博客
06-18 1646
最近在听一个课程的时候，发现里面有一处需要遍历一个集合，对元素进行某种操作（比如set某个属性），该讲师用的是map()，在map方法里返回一个更新后的元素。而对于此功能，自己首先想到的是forEach()方法，因为在我之前的概念里，forEach()方法才是用来遍历操作的，而map是用来将一个类型的集合映射为另一个类型的集合（当然，映射为同一个类型也无可厚非）。于是自己详细测试了forEach方法，发现这里面还是有些门道的！下面详说： List<Student> students
053.maximum-subarray
m0_67403240的博客
03-14 976
Find the contiguous subarray within an array (containing at least one number) which has the largest sum. For example, given the array [-2,1,-3,4,-1,2,1,-5,4], the contiguous subarray [4,-1,2,1] has the largest sum = 6. click to show more practice. More pra
疯狂的程序员-第三十一章
java技术讨论精华
11-23 100
听周总这么说，绝影吓了一跳，不光他吓了一跳，BOSS Liu和张厂长也吓了一跳。在他们印象中，周总脸上总是带着平静地表情，即使偶尔批评起人来，也还是带着平静地表情。这时候，绝影突然想起念大学的时候，本来和燕儿在校外租了房子悠闲地过着小日子，没想到有一天公安局会突然来敲他的门，想到公安局肯定是来查自己非法同居来了，吓得要死。想在来看，周总一定是来清算平时不按时到公司，作风懒散的事情，果然是“出来混，...
Java8新特性 - Stream - 03 - Stream的forEach()方法详解
northcastle的博客
03-12 4212
1.方法介绍 【方法签名】void forEach(Consumer<? super T> action); 【方法属性】终结方法 【方法参数】函数式接口 Consumer,所以可以直接传入一个Lambda表达式 【方法作用】遍历每一个元素 2.案例代码 2.1 代码 package com.northcastle.I_stream; import java.util.ArrayList; import java.util.stream.Stream; public class St
JAVA Stream流的forEach遍历
热门推荐
七七的博客
02-04 3万+
Stream流的forEach： 如果希望在流当中进行元素的遍历操作，可以使用forEach方法： forEach(Lambda)表达式，对每一个元素都要进行操作。 参数Lambda表达式必须是一个能够消费的一个参数，而且不产生数据结果的Lambda 例如： Lambda: s -> System.out.println(s); 方法引用： System::println print...
java的Stream和方法引用
12-22
Stream和方法引用 1. Stream流 1.1. Stream流引入 Stream流完全不是I/O流，按照流水线处理方式来考虑代码中的思想。 JDK1.8 之后，我们拥有了Lambda表达式，让代码的中心偏向解决实际问题，直到重点，可以提高效率。...
Java Stream 流实现合并操作示例
08-19
主要介绍了Java Stream 流实现合并操作,结合实例形式详细分析了Java Stream 流实现合并操作原理与相关注意事项,需要的朋友可以参考下
通过实例了解Java 8创建Stream流的5种方法
08-25
主要介绍了通过实例了解Java 8创建Stream流的5种方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java stream 去重_Java8的Stream简单实用功能
weixin_39665302的博客
11-26 2153
Java8发布了这么多年了，但是平时却很少用到Stream，简直有点暴殄天物，总结一点简单实用的示例。经典示例对象集合转属性集合:Set ids = stream.map(u -> u.getId()).collect(Collectors.toSet());对象集合转map:Map userMap = stream.collect(Collectors.toMap(User::getId,...
Java 基础 Stream流中的常用方法forEach
毛毛虫会长大
04-07 1万+
package demo7; import java.util.stream.Stream; /* * Stream流中的常用方法_forEach * void forEach(Consumer<? super T>) action; * 该方法接受一个Consumenr接口函数，会将每一个流元素交给函数进行处理 * Consumer接口是一个消费型的函数式接口，可以传递Lam...
详细分析Java中的list.foreach()和list.stream().foreach()
最新发布
码农研究僧的博客
01-24 5133
1. `forEach()` 是List接口的一部分，用于对列表中的每个元素执行给定的操作。与Stream API的 forEach 不同，list的 forEach 不支持并行处理，因此它在处理大量数据时可能不如Stream API高效。 适用于简单的迭代和操作，不需要复杂的流处理。 2. `stream().forEach()` 是Stream API的一部分，用于对流中的每个元素执行给定的操作。使用Stream API的 forEach 允许进行更多的操作，例如过滤、映射等
Java8 Stream 流机制和 Lambda 表达式
hmyqwe的博客
04-08 315
一、Stream 流介绍与使用场景 Stream 流介绍 java8 中的stream 与InputStream和OutputStream是完全不同的概念, stream 是用于对集合迭代器的增强，使之完成能够完成更高效的聚合操作（过滤、排序、统计分组）或者大批量数据操作。 stream 与 Lambda 表达式结合后编码效率大大提高，可读性更强。 举例如下： // 获取所有红色苹果的总重量 appleStore.stream().filter(a -> "red".equals(a.getCol
Java集合遍历方式（for循环与stream()&forEach()）比较
weixin_40903413的博客
12-23 7167
以上这些，我们可以做个总结了：+ 对于非方法引用 Lambda 表达式，编译器都会生成对应的 desugaring method;+ desugaring method 参数列表是接口方法参数列表加上变量捕获列表+ 变量捕获由虚拟机提供，是闭包访问变量的基础；
Java中for、foreach、stream区别和性能比较
刘皇叔说Java的博客
11-17 6133
如果数据量在10万的时候，stream效率最高，其次是foreach,最后是for。另外需要注意的是如果数据达到100万的话，parallelStream异步并行处理效率最高，高于foreach和for。stream().forEach 和 forEach 方法都可以使用在集合类上，但是有一些区别。在效率方面，stream().forEach、forEach 和 parallelStream 之间存在一些差异。stream().forEach() 和 forEach() 在使用方式和行为上有一些区别。
152-Stream流中的常用方法-forEach
shwjakak的博客
11-10 5588
1.Stream流中的常用方法分为两类 延迟方法：返回值类型仍然是Stream接口自身类型的方法】 终结方法：
java8的stream流处理使用例子
qq_21207803的博客
07-21 6545
java8的stream流处理使用例子。
Java8 Stream新特性详解及实战
程序新视界
10-09 7879
Java8 Stream新特性详解及实战 背景介绍 在阅读Spring Boot源代码时，发现Java 8的新特性已经被广泛使用，如果再不学习Java8的新特性并灵活应用，你可能真的要out了。为此，针对Java8的新特性，会更新一系列的文章，欢迎大家持续关注。 首先，我们来看一下Spring Boot源代码ConfigFileApplicationListener类中的一段代码： private...
java之stream流常用方法
01-12
以下是Java中Stream流的常用方法： 1. filter()方法：根据指定的条件过滤流中的元素。 ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); List<Integer> evenNumbers = numbers.stream() .filter(n ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值