Java基础24 Lambda表达式及省略写法 Steam流 函数式接口

已于 2022-10-14 14:05:34 修改
阅读量656 收藏
点赞数
分类专栏： Java基础篇 文章标签： java 开发语言 后端
于 2022-02-24 09:45:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xs943/article/details/123103890
版权

一、jdk8&jdk9接口的特性

1.概念：在jdk1.8 之后 接口中不仅可以有抽象方法 还可以存在其他的成员方法
2.添加的方法
jdk8 增加默认方法与静态方法
jdk9 增加私有的方法
3.影响
接口中不仅只有抽象方法 还有普通的方法 缩短接口与抽象类之间的差别,接口是可以多继承的
所以以后的趋势 接口可能替代抽象类
4.默认方法
概述 默认方法就是使用 default关键字来进行修饰方法
语法：
访问修饰符 default 返回值类型 方法名称(参数列表) { 方法体 }
特点：
接口中默认方法是不能是直接进行调用 需要通过实例化来进行调用
接口中的默认方法 没有强制要求重写 可以进行重写
接口中的普通方法不能使用重载
接口的实现类中的其它方法可以调用接口中默认方法
调用的语法:接口的名称.super.方法的名称()
定义接口代码

public interface Inner {
public default void showInfo(){
System.out.println("哈哈");
}
}

实现类代码

public class Impl implements Inner{
@Override
public void showInfo() {
Inner.super.showInfo();
System.out.println("aaaaaa");
}
}

测试类

public class Test {
public static void main(String[] args) {
Inner in = new Impl();
in.showInfo();
}
}

5.静态的方法
1.概念：在jdk1.8 之后可以有静态的方法
2.特点：
接口中的静态方法可以直接通过接口的名称来直接进行调用 实现类不能调用接口静态方法
不同的接口中可以定义相同名字的静态方法 互不影响
3.代码

就是静态方法直接通过类名调用，接口也算特殊的类
接口1

public interface Inner {
public static void showInfo(){
System.out.println("我是接口的静态方法");
}
}

接口2

public interface Inner1 {
public static void showInfo(){
System.out.println("我是潘金莲 我有药");
}
}

实现类

public class Impl implements Inner,Inner1 {
}

测试类

public class Test {
public static void main(String[] args) {
   Inner.showInfo();
    Inner1.showInfo();
}
}
  1. jdk9
    概念：jdk9添加私有的方法
    特点：
    私有的普通方法只能是默认方法来进行调用
    私有的静态的方法 可以使用 默认方法 与静态方法调用
    代码
package day24.test;

public interface Inner4 {
   /* private void show1(){
        System.out.println("私有的方法");
    }
    jdk1.9 才可以*/
    public default void  show2(){

    }
    /*private static void show3(){
        System.out.println("私有静态方法");
    }jdk1.9 才可以*/
    public static void show4(){

    }

}

二、Lambda表达式

1.本质： 本质就是一个接口 == > 就是一个匿名的接口
2.前提条件：必须是函数式接口 也就是接口中只能有一个抽象方法 默认方法与其它方法都是可以
存在的
3.作用:简化匿名内部类(匿名接口)的写法 匿名接口 即相当于实例化接口的实现类，需重写接口的方法
4.语法：
(参数) ->{方法体}
（）==>接口中方法的参数
-> 是Lambda 表示特有的语法 指向方法体
{} ==> 就是方法体 执行的操作
5.例子

package day24.test;

public class Test03 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();

        //使用lamdba表达式
        new Thread(()->{
            System.out.println(Thread.currentThread().getName());
        }).start();
    }
}

6.自定义没有返回值接口使用lambda表达式
接口

public interface Inner {
public void showInfo();
}

测试类

package day24.test;

public class Test04 {
    public static void main(String[] args) {
       show(()->{
           System.out.println("lamba表达式测试成功");
       });
    }
    public static void show(Inner inner){
        inner.showInfo();
    }

}

7.带返回使用lambda表达式

package day24.test;

import java.util.Arrays;

public class Test05 {
    public static void main(String[] args) {
        Stundent [] stundents = new Stundent[3];
        stundents[0] = new Stundent("张三",20);
        stundents[1] =new Stundent("李四",18);
        stundents[2] =new Stundent("王五",25);
        /*Arrays.sort(stundents, new Comparator<Stundent>() {
            @Override
            public int compare(Stundent o1, Stundent o2) {
                return o1.getAge()-o2.getAge();
            }
        });*/

        Arrays.sort(stundents,(Stundent o1,Stundent o2)->{
            return o1.getAge()-o2.getAge();
        });


        System.out.println(Arrays.toString(stundents));
    }
}

9.自定义一个带参数带返回值的方法
接口

package day24.test;

public interface Inner01 {
    public int showInfo(int num1,int num2);
}

测试类

package day24.test;

public class Test06 {
    public static void main(String[] args) {
       int sum = show(10,20,(int num1,int num2)->{
           return num1+num2;
       }) ;
        System.out.println(sum);
    }
//Multiple non-overriding abstract methods found in interface day24.Inner
    public static int show (int num1,int num2,Inner01 inner01){
        return inner01.showInfo(num1,num2);
    }
}

10.Lambda表达式简化方法
第一种情况 如果括号中只有一个参数 可以省略括号 和数据类型
第二种情况 方法体只有一句话 大括号和分号可以省略
第三种情况 方法体只有一句话 就是retrun 可以省略大括号 分号 retrun

package day24.test;

public class Test07 {
    public static void main(String[] args) {
         show(5,(int num)->{
             System.out.println(num);
         });
         show(5,num -> {
             System.out.println(num);
         });
         show(5,num -> System.out.println(num));

        //Arrays.sort(students,(Student o1, Student o2)-> o1.getAge()-o2.getAge());
    }
    public static void show(int num,Inner02 inner){
        inner.showInfo(num);
    }
}

三、函数式接口

1.函数式接口 只有一个抽象方法的接口就是函数式接口 可以有默认方法 与静态方法
2.函数式接口一般会使用一个注解来进行约束
@FunctionalInterface 用于来检查是否是函数式接口
3.代码
@FunctionalInterface
public interface Inner {
public void show();
public default void show1(){
};
}
4.函数式接口两种体现形式
第一种作为方法的参数
第二种作为方法 的返回值
5.代码 作为方法的参数
接口

@FunctionalInterface
public interface Inner {
public void show();
}

测试类

public class Test {
public static void main(String[] args) {
showInfo(()-> System.out.println("哈哈哈哈"));
}
public static void showInfo(Inner in){
in.show();
}
}

6.作为返回值

package day24.type;

import java.util.Arrays;
import java.util.Comparator;

public class Test08 {
    public static void main(String[] args) {
        String [] arrays ={"aa","a","aaaaa","aacv"};
        Arrays.sort(arrays,getCon());
        System.out.println(Arrays.toString(arrays));
    }

    /*private static Comparator<String> getCon() {
        return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        };
    }*/

    private static Comparator<String> getCon() {
        return (String o1, String o2)->o1.length()-o2.length();
    }


}

四、Supplier：供给型接口

1.T get() 获取一个结果
2.例子、
函数式接口独有省略，Supplier sup 等各种类型接口形参，在使用lambda表达式可以忽略这个形参

package day24.type;

import java.util.function.Supplier;

public class Test09 {
    public static void main(String[] args) {
        //这是怎么省略的？供给型接口独有省略？函数式接口独有省略，Supplier<String> sup 等各种类型接口形参，在使用lambda表达式可以忽略这个形参
        String str = showInfo(()->"我是张三");
        System.out.println(str);
    }

    private static String showInfo(Supplier<String> sup) {
        return sup.get();
    }
}

3.求出数组中最大值

package day24.type;

import java.util.function.Supplier;

public class Test10 {
    public static void main(String[] args) {
        Integer sum = getMax(()->{
            //定义一个数组
            Integer [] nums={20,30,40,90,60};
            //定义变量来记录其最大的值
            int max=nums[0];
            for (Integer i : nums) {
                if(i>max){
                    max=i;
                }
            }
            return max;
        });
        System.out.println(sum);
    }

    private static Integer getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

五、Consumer：消费型接口

1.void accept(T t) 消费的方法 具体消费什么 由自己进行设置
2.default Consumer andThen(Consumer<? super T> after) 可以连接多个消费型接口 可
以进行多次消费
类型接口.andThen(类型接口).类型接口方法
3.案例 消费一个字符 打印其结果
就是写一个方法体，没有return的

package day24.type;

import java.util.function.Consumer;

public class Test11 {
    public static void main(String[] args) {
        showInfo("顺哥",(String s)->{
            System.out.println(s.substring(0,1));
        });
    }

    private static void showInfo(String str, Consumer<String> con) {
        con.accept(str);
    }
}

4.案例 对一个字符串进行两次消费 第一次消费 转换为大写 第二次消费转换为小写

package day24.type;

import java.util.function.Consumer;

public class Test12 {
    public static void main(String[] args) {
        shoeInfo("aBc",(String s)->{
            System.out.println(s.toUpperCase());
        },(String s)->{
            System.out.println(s.toLowerCase());
        });
    }

    private static void shoeInfo(String str, Consumer<String> con1,
                                 Consumer<String> con2) {
        con1.andThen(con2).accept(str);
    }
}

5.案例 将一个字符串的数组 String [] arrays={“张三:30”,“李四:20”,“王五:10”} ==>

package day24.type;

import java.util.function.Consumer;

public class Test13 {
    public static void main(String[] args) {
        showInfo(new String[]{"张三:30","李四:20","王五:10"},(String s)->{
            System.out.print("姓名:"+s.split(":")[0]+",");
        },(String s)->{
            System.out.print("年龄:"+s.split(":")[1]+" ");
        });
    }

    private static void showInfo(String[] arrays, Consumer<String> con1,
                                 Consumer<String> con2) {
        for (String s : arrays) {
            con1.andThen(con2).accept(s);
        }
    }
}

六 Predicate：断言型接口

1.boolean test(T t) 主要用于做判断
2.default Predicate and(Predicate<? super T> other) 用于连接两个断言型接口 and
&& 并且
3.default Predicate or(Predicate<? super T> other)用于连接两个断言型接口 or
|| 或者
4.ddefault Predicate negate() ！非
5.案例
使用断言型接口来判断一个字符串的长度是否大于5
使用断言型接口来判断一个字符串的长度是否大于5 字符串中包含a
就是写一个方法体，有return的，且return 条件判断表达式

package day24.type;

import java.util.function.Predicate;

public class Test14 {
    public static void main(String[] args) {
        boolean flag = isFlag("dfss",(String s)->{
            return s.length()>5;
        });
        System.out.println(flag);
        boolean flag1 =isFlag1("bcderff",(String s)->{
            return s.length()>5;
        },(String s)->{
            return s.contains("a");
        });
        System.out.println(flag1);

    }

    private static boolean isFlag1(String s, Predicate<String> pre1,Predicate<String> pre2) {
        return pre1.and(pre2).test(s);
    }

    private static boolean isFlag(String s, Predicate<String> pre) {
        return pre.test(s);
    }
}

6.案例

package day24.type;

import java.util.function.Predicate;

public class Test15 {
    public static void main(String[] args) {
        boolean flag= isFlag("abcdefgh",(String s)->{
            return s.length() >5;
        });
        System.out.println(flag);
    }

    private static boolean isFlag(String s, Predicate<String> pre1) {
        return pre1.negate().test(s);
    }
}

7.案例:定义一个字符数组 String[] str={“杨一”,“杨二”,“杨三”,“迪一二三”};
获取到数组 名字包含 迪 并且长度 ==4 数组 存入集合中 == > 打印输出集合
分析：
定义一个方法 返回值的是集合 参数 数组 两个断言式接口
判断是否满足这个条件 满足这个条件存入到集合
代码：

package day24.type;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class Test16 {
    public static void main(String[] args) {
        String[] str ={"杨一","杨二","杨三","迪一二三"};
        List<String> li = getList(str,(String s)->{
            return s.length()==4;
        },(String s)->{
            return s.contains("迪");
        });
        System.out.println(li);
    }

    private static List<String> getList(String [] arrays, Predicate<String> pre1,
                                        Predicate<String> pre2) {
        List<String> list = new ArrayList<String>();
        for (String s : arrays) {
            if(pre1.and(pre2).test(s)){
                list.add(s);
            }
        }
        return list;
    }
}

七、Function<T, R>：函数型接口

1.Function<T, R> 主要是用于来转换
T==> 表示被转换的类型
R==>表示转换的类型
2.方法
default Function<T,V> andThen(Function<? super R,? extends V> after)
用于连接两个函数型的接口
R apply(T t) ==> 用于来做转换
3.定义一个字符串 需要使用函数型的接口 转换为Integer类型 载将Interger类型转换字符串类型
就是写一个方法体，有return的，且return 数据

package day24.type;

import java.util.function.Function;

public class Test17 {
    public static void main(String[] args) {
        String num =show("123",(String s)->{
            return Integer.parseInt(s);
        },(Integer n)->{
            return n+" ";
        });
        System.out.println(num);
    }

    private static String show(String s, Function<String,Integer> fun1,
                               Function<Integer,String> fun2) {
        return fun1.andThen(fun2).apply(s);
    }
}

4.定义一个字符串 String str=“123 刘正武” ==>123 Function函数型接口
==>第一次是将String 转换为 String
第二次将String 转换为 int

package day24.type;

import java.util.function.Function;

public class Test18 {
    public static void main(String[] args) {
        Integer count =showInfo("123 顺哥加油",(String s)->{
            return s.split(" ")[0];
        },(String s)->{
            return Integer.parseInt(s);
        });
        System.out.println(count);
    }

    private static Integer showInfo(String s, Function<String,String> fun1,Function<String,Integer> fun2) {
        return fun1.andThen(fun2).apply(s);
    }

}

八、Stream流

1.概念: Stream 是一个接口 Stream 接口的作用就类似于流水线工厂的作用
2.作用:主要用于对数据进行过滤
与Predicate：断言型接口 类似
3.主要提供两类方法 延迟方法 终结方法
延迟方法: 调用方法之后返回值还是Stream流对象 还可以继续进行操作
终结方法: 调用方法之后返回值 不是Stream流对象 不可以再调用Strea流对象的方法
4.使用方法
在这里插入图片描述
代码


package day24.type;

import java.util.ArrayList;
import java.util.List;

public class Test19 {
    //第一个对象 向集合中添加 数据
    //把集合的姓名包含张 过滤出来
    //把名字的长度 大于=3 过滤出来
    //对集合进行遍历输出
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("张三丰");
        list1.add("张无忌");
        list1.add("大张三");
        list1.add("赵敏");
        list1.add("灭绝师太");
        list1.add("顺哥");
        //定义一个新的集合来进行存储
        List<String> list2 =new ArrayList<>();
        for (String s : list1){
            if(s.contains("张")){
                list2.add(s);
            }
        }
        //长度大于=3
        List<String> list3 = new ArrayList<>();
        for (String s1 : list2){
            if (s1.length()>=3){
                list3.add(s1);
            }
        }
        //对集合进行遍历
        for(String s: list3){
            System.out.println(s);
        }

        /*list1.stream().filter((String s)->{
            return s.contains("张");
        }).filter((String s)->{
            return s.length()>=3;
        }).forEach((String s)->{
            System.out.println(s);
        });*/
        list1.stream().filter((String s)->s.contains("张"))
                .filter((String s)->s.length()>=3).forEach(s-> System.out.println(s));


    }
}

5.获取到Stream对象
default Stream stream() == 将集合转换为Stream 的对象 集合必须是Collection的子
类
static Stream of(T… values) 将指定的元素转化为Stream流对象
代码

package day24.type;

import java.util.*;
import java.util.stream.Stream;

public class Test20 {
    public static void main(String[] args) {
        List<String> list =new ArrayList<>();
        list.add("张三");
        list.add("李四");
        Stream<String> stre = list.stream();
        stre.forEach((String s)->{
            System.out.println(s);
        });

        Stream<Integer> s1 = Stream.of(new Integer[]{20,80,90,300});
        s1.forEach((Integer n)-> System.out.println(n));

        //map集合可以转换Stream对象 不能直接转换Stream 间接的进行转换
        //将键和值分别转为单独的集合，然后就集合使用原理
        Map<String,String> map = new HashMap<>();
        map.put("admin","123456");
        map.put("username","23456");
        Set<String> s = map.keySet();
        //获取所有的值x
        Collection<String> con = map.values();
        s.stream();
        con.stream();


    }
}

6.方法的使用

package day24.type;

import java.util.stream.Stream;

public class Test21 {
    public static void main(String[] args) {
        // Stream<T> filter(Predicate<? super T> predicate)
        //void forEach(Consumer<? super T> action)
        Stream.of(new Integer[]{3,20,40,60,80,90})
                .filter((Integer n)-> {return  n>80;}).forEach(n-> System.out.println(n));
        // <R> Stream<R> map(Function<? super T,? extends R> mapper)
        Stream.of(new String [] {"11","22","33","44","55"}).map((String n)->{
            return  Integer.parseInt(n);
        }).forEach((Integer n)->{
            System.out.println(n+" ");
        });
        System.out.println("");

        //long count()
        System.out.println(Stream.of(new String[]{"11","22","33"}).count());

        //Stream<T> skip(long n)
        Stream.of(new String[]{"11","22","33","44","55"}).skip(3)
                .forEach(s-> System.out.println(s));
        //static <T> Stream<T> concat(Stream<? extends T> a,Stream<? extends T>b)
        // Stream.of(new Integer[]{3,20,40,60,80,90}).concat()

        System.out.println("=======");
        Stream<Integer> str1 = Stream.of(new Integer[]{3,20,40,60,80,90});
        Stream<Integer> str2 = Stream.of(new Integer[]{100,101,102,103,104,105});
        Stream.concat(str1,str2).forEach(n-> System.out.println(n));
    }
}

案例

package day24.work;

public class Person {
    private String name;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

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

Stream筛选只要三个用limit(3) 不要前三个要后面所有的skip(3) 转类型 map(（原来的数据类型 形参名）->{ retrun 将原来数据类型转为其他类型的代码语句}) 例 map((String n)->{return new Person(n); 极简省略 map(n->new Person(n));
list 类型筛选用subList(i,j) 包头不包尾 同String 的subString用法

package day24.work;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Work {
    public static void main(String[] args) {
        List<String> list1 =new ArrayList<>();
        List<String> list2 =new ArrayList<>();
        list1.add("宫本武藏");
        list1.add("苏一二");
        list1.add("宋一明");
        list1.add("石头人");
        list1.add("时一二");
        list1.add("李耳");
        list1.add("庄子");
        list1.add("洪七公");
        list2.add("帕瓦一二");
        list2.add("张三丰");
        list2.add("赵薇薇");
        list2.add("张一二");
        list2.add("波尔至济南铁一二");
        list2.add("张一二");
        list2.add("张翠花");
        Stream<String> stre1 = list1.stream().filter((String s) -> s.length() == 3).limit(3);
        /*.forEach(s -> System.out.println(s));*/
        Stream<String> stre2 = list2.stream().filter((String s) -> s.contains("张")).skip(2);
        /*.forEach(s -> System.out.println(s));*/
        /*Stream.concat(stre1,stre2).map((String s)->{return new Person(s);})
                .forEach((Person p)-> System.out.println(p));*/
        List<Person> personList = new ArrayList<>();
        Stream.concat(stre1,stre2).map((String n)->{
            return new Person(n);
        }).forEach((Person p)->{
            personList.add(p);
        });
        System.out.println(personList);
        //至臻极简版
        list1.stream().filter(s-> s.length() == 3).limit(3)
        .forEach(s -> System.out.println(s));
        list2.stream().filter(s-> s.contains("张")).skip(2)
        .forEach(s -> System.out.println(s));
        list1.stream().filter(s-> s.length() == 3).limit(3).map(s -> new Person(s))
        .forEach(s -> System.out.println(s));



    }
}
长河落日猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于java.util.stream包的详细说明
老卡的博客
06-30 2341
该包下的类用来支持元素流上的函数式操作，比如集合上的Map-Reduce操作。 如： int sum = widgets.stream() .filter(b -> b.getColor() == RED) .mapToInt(b -> b.getWeight()) .sum(); 这个例子，我们用一个Widget的集合变量widgets作为流的数据源，然后在这个流上执行filter-map-reduce...
Java的Lambda表达式和函数接口
Dch19990825的博客
06-13 482
Java的Lambda表达式和函数接口 下面主要将四个方面，并会给出具体的例子 函数接口 lambda表达式 使用Lambda表达式作为函数接口参数 使用方法引用或构造器作为函数接口参数 1.函数接口 函数式接口(Functional Interface)就是一个有且仅有一个抽象方法的接口。 函数式接口可以被隐式转换为 lambda 表达式。 Lambda 表达式和方法引用（实际上也可认为是L...
这么简单，还不会使用java8 stream流的map()方法吗？
热门推荐
Candyz7的博客
12-03 1万+
在日常的开发工作中经常碰到要处理list中数据的问题，比如从数据库中查出了很多学生，由于一些原因需要在内存中找出这些学生中的所有姓名，或者把名为“王五”的语文成绩暂时修改为“100”，这些问题怎么处理呐，之前我们想到的是遍历每个元素，然后取出来放到另外一个集合中，在java8中对集合可以进行流式操作使上面的处理更简洁。今天来看下map()方法的使用。stram流式处理中有map方法，先看下其定义，该方法在java.util.stream.Stream类中，可以看到map()方法接收一个函数式接口参数，入参有
java.util.stream.Stream详解
沐雨橙风ιε的博客
03-15 1075
java.util.stream.Stream详解
java.util.stream 简介
崔显龙的博客
03-09 1143
java.util.stream 是 Java 8 引入的新内容，提供以函数式的风格对流数据进行操作。 简单示例： public static void fileStream(Collection<File> files) { Predicate<File> predicate = new Predicate<File>() { @Overr...
【java学习】java8新特性：stream、Lambda函数、接口的默认方法和类方法、函数式接口、Optional、DateTime
午后阳光
10-30 2160
1，概念java.util.stream是java8新特性。 java.util.stream与java.io包里的 InputStream 和 OutputStream 是完全不同的概念。 Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bul............
Java Lambda表达式和函数式接口实例分析
08-25
Java Lambda表达式和函数式接口实例分析 Java Lambda表达式和函数式接口是Java 8中引入的一种新特性，它允许开发者使用函数式编程风格来编写代码，从而提高代码的简洁性和可读性。本文将对Java Lambda表达式和函数...
Java8简单了解Lambda表达式与函数式接口
08-28
Java8中的Lambda表达式和函数式接口 Java8中引入了Lambda表达式和函数式接口，这两大新特性给Java开发者带来了极大的便捷和灵活性。Lambda表达式是一种特殊的匿名函数，可以用来简化代码，使其变得更加简洁和易读。...
【Java基础笔记】Lambda表达式和函数式接口.docx
10-25
【Java基础笔记】Lambda表达式和函数式接口.docx
Java函数式编程(一)：你好，Lambda表达式
09-04
函数式编程还引入了函数式接口，如`java.util.function.Function`、`java.util.function.Consumer`等，它们为Lambda表达式提供了类型安全的载体。例如，`Function`接口接受一个参数并返回一个结果，可以用于数据转换...
Java——Lambda&Stream表达式
xinin919的博客
08-31 564
1、Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码，使用它写出更灵活、简洁的代码。2、Lambda表达式的结构：①、Lambda 表达式可以具有零个、一个或多个参数。②、可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。如：(int a,int b)与 (a,b)相同。③、参数用小括号括起来，用逗号分隔。如： (a, b) 或 (int a, int b) 或 (String a, int b, float c)。④、空括号用于表示一组空的参数。...
Java 8 - java.util.stream - Stream接口
学无止境
05-17 820
确切地说，Stream接口定义了对数据进行流式操作的方法，并提供了中间操作和终端操作，用于处理、转换和聚合数据流。
java.util.stream 库简介
Z645817的博客
11-14 331
Java Stream简介 　　Java SE 8 中主要的新语言特性是拉姆达表达式。可以将拉姆达表达式想作一种匿名方法；像方法一样，拉姆达表达式具有带类型的参数、主体和返回类型。但真正的亮点不是拉姆达表达式本身，而是它们所实现的功能。拉姆达表达式使得将行为表达为数据变得很容易，从而使开发具有更强表达能力、更强大的库成为可能。 　　Java SE 8 中引入的一个这样的库是 java.util...
java.util.stream是哪个包,Java8 流式 API（`java.util.stream`）
weixin_34553861的博客
03-21 290
熟悉 ES6 的开发者，肯定对数组的一些方法不是很陌生：map、filter 等。在对一组对象进行统一操作时，利用这些方法写出来的代码比常规的迭代代码更加的简练。在 C♯ 中，有 LINQ 来实现。那么在 Java 中有这样的操作吗？答案是有的，Java8 中引入了大量新特性，其中一个就是 Java 的流式 API。在 Java 8 中，流(Stream)与迭代器类似，都是用来对集合内的元素进行某...
java——集合篇——java.util.stream.Stream
血师注
09-26 1053
简单了解为什么需要 Stream Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专...
java中的steam流
白小白的小白的博客
05-29 2349
  当需要对多个元素进行操作(特别是多步操作)的时候，考虑到性能及便利性，我们应该首先拼好一个"模型"步骤方案，然后再按照方案去执行它   这张图展示了过滤 映射 跳过 计数等多步操作，这是一种集合元素的处理方案，而方案就是一种"函数模型"，图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个模型流，而最右侧的数字3是最终结果。   这里的filter map skip都是在对函数模型进行操作，集合元素并没有真正被处理，只有当终结方法count执行的时候，整个模型才会按照指定策略执
java.util.stream_java.util.stream.Stream 接口中的常用方法
weixin_39776298的博客
02-21 703
流模型的操作很丰富，下面介绍一些常用的API。这些方法可以被分成两种：延迟方法返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。(除了终结方法外，其余方 法均为延迟方法。)终结方法返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调 用。在这里介绍的终结方法包括 count 和 forEach 方法。逐一处理：forEa...
什么是Java中的Lambda表达式和函数式接口？它们有何作用？.
最新发布
07-14
在Java 8中引入了Lambda表达式和函数式接口。 Lambda表达式是一种简洁的语法，用于表示可传递的匿名函数。它可以用于替代使用匿名内部类的方式来实现接口的抽象方法。Lambda表达式的基本语法是：(参数列表) -> {...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值