精华内容
下载资源
问答
  • /* * Java8 内置的四大核心函数式接口 * * Consumer : 消费型接口 * void accept(T t); * * Supplier : 供给型接口 * T get(); * * Function : 函数型接口 * R apply(T t); * * Predicate : 断言型接口 * boolean ...

    import java.util.ArrayList;

    import java.util.Arrays;

    import java.util.List;

    import java.util.function.Consumer;

    import java.util.function.Function;

    import java.util.function.Predicate;

    import java.util.function.Supplier;

    import org.junit.Test;

    /*

    * Java8 内置的四大核心函数式接口

    *

    * Consumer : 消费型接口

    * void accept(T t);

    *

    * Supplier : 供给型接口

    * T get();

    *

    * Function : 函数型接口

    * R apply(T t);

    *

    * Predicate : 断言型接口

    * boolean test(T t);

    *

    */

    public class TestLambda3 {

    //Predicate 断言型接口:

    @Test

    public void test4(){

    List list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");

    List strList = filterStr(list, (s) -> s.length() > 3);

    for (String str : strList) {

    System.out.println(str);

    }

    }

    //需求:将满足条件的字符串,放入集合中

    public List filterStr(List list, Predicate pre){

    List strList = new ArrayList<>();

    for (String str : list) {

    if(pre.test(str)){

    strList.add(str);

    }

    }

    return strList;

    }

    //Function 函数型接口:

    @Test

    public void test3(){

    String newStr = strHandler("\t\t\t 这里是去前后空格的 ", (str) -> str.trim());

    System.out.println(newStr);

    String subStr = strHandler("这里是截取字符串的", (str) -> str.substring(3, 8));

    System.out.println(subStr);

    }

    //需求:用于处理字符串

    public String strHandler(String str, Function fun){

    return fun.apply(str);

    }

    //Supplier 供给型接口 :

    @Test

    public void test2(){

    List numList = getNumList(10, () -> (int)(Math.random() * 100));

    for (Integer num : numList) {

    System.out.println(num);

    }

    }

    //需求:产生指定个数的整数,并放入集合中

    public List getNumList(int num, Supplier sup){

    List list = new ArrayList<>();

    for (int i = 0; i < num; i++) {

    Integer n = sup.get();

    list.add(n);

    }

    return list;

    }

    //Consumer 消费型接口 :

    @Test

    public void test1(){

    happy(10000, (m) -> System.out.println("小明喜欢购物,每次消费:" + m + "元"));

    }

    public void happy(double money, Consumer con){

    con.accept(money);

    }

    }

    展开全文
  • * Java8 内置的四大核心函数式接口 * * Consumer<T> : 消费型接口 * void accept(T t); * * Supplier<T> : 供给型接口 * T get(); * * Function, R> : 函数型接口 * R apply(T t); * * ...
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.function.Consumer;
    import java.util.function.Function;
    import java.util.function.Predicate;
    import java.util.function.Supplier;
    
    import org.junit.Test;
    
    /*
     * Java8 内置的四大核心函数式接口
     * 
     * Consumer<T> : 消费型接口
     * 		void accept(T t);
     * 
     * Supplier<T> : 供给型接口
     * 		T get(); 
     * 
     * Function<T, R> : 函数型接口
     * 		R apply(T t);
     * 
     * Predicate<T> : 断言型接口
     * 		boolean test(T t);
     * 
     */
    public class TestLambda3 {
    	
    	//Predicate<T> 断言型接口:
    	@Test
    	public void test4(){
    		List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
    		List<String> strList = filterStr(list, (s) -> s.length() > 3);
    		
    		for (String str : strList) {
    			System.out.println(str);
    		}
    	}
    	
    	//需求:将满足条件的字符串,放入集合中
    	public List<String> filterStr(List<String> list, Predicate<String> pre){
    		List<String> strList = new ArrayList<>();
    		
    		for (String str : list) {
    			if(pre.test(str)){
    				strList.add(str);
    			}
    		}
    		
    		return strList;
    	}
    	
    	//Function<T, R> 函数型接口:
    	@Test
    	public void test3(){
    		String newStr = strHandler("\t\t\t 这里是去前后空格的   ", (str) -> str.trim());
    		System.out.println(newStr);
    		
    		String subStr = strHandler("这里是截取字符串的", (str) -> str.substring(3, 8));
    		System.out.println(subStr);
    	}
    	
    	//需求:用于处理字符串
    	public String strHandler(String str, Function<String, String> fun){
    		return fun.apply(str);
    	}
    	
    	//Supplier<T> 供给型接口 :
    	@Test
    	public void test2(){
    		List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
    		
    		for (Integer num : numList) {
    			System.out.println(num);
    		}
    	}
    	
    	//需求:产生指定个数的整数,并放入集合中
    	public List<Integer> getNumList(int num, Supplier<Integer> sup){
    		List<Integer> list = new ArrayList<>();
    		
    		for (int i = 0; i < num; i++) {
    			Integer n = sup.get();
    			list.add(n);
    		}
    		
    		return list;
    	}
    	
    	//Consumer<T> 消费型接口 :
    	@Test
    	public void test1(){
    		happy(10000, (m) -> System.out.println("小明喜欢购物,每次消费:" + m + "元"));
    	} 
    	
    	public void happy(double money, Consumer<Double> con){
    		con.accept(money);
    	}
    }
    
    

    转载于:https://www.cnblogs.com/drl-blogs/p/10803413.html

    展开全文
  • Fcuntion接口是对接受一个T类型参数,返回R类型的结果的方法的抽象,通过调用apply方法执行内容。 代码示例 /** * Function<T, R> 函数型接口: */ @Test public void testLambda() { //字符串处理 ...

    Functio<T,R>接口

    Fcuntion接口是对接受一个T类型参数,返回R类型的结果的方法的抽象,通过调用apply方法执行内容。

    代码示例

     /**
         * Function<T, R> 函数型接口:
         */
        @Test
        public void testLambda() {
            //字符串处理
            String newStr = strHandler("\t\t\t 测试数据去空格   ", (str) -> str.trim());
            System.out.println(newStr);
            String subStr = strHandler("测试截取字符串", (str) -> str.substring(2, str.length()));
            System.out.println(subStr);
            String joinStr = strHandler("拼接", str -> str + "字符串");
            System.out.println(joinStr);
            //int数据处理
            Integer i1 = intHandler(10, i -> i * i);
            //求平方
            System.out.println("求平方:" + i1);
            //求和
            Integer sum = intHandler(10, i -> i + i);
            System.out.println("求和:" + sum);
        }
    
        //需求:用于处理字符串
        public String strHandler(String str, Function<String, String> fun) {
            return fun.apply(str);
        }
    
        //需求:用于处理int数据
        public Integer intHandler(Integer i, Function<Integer, Integer> fun) {
            return fun.apply(i);
        }
    

    Consumer 接口

    Consumer 接口翻译过来就是消费者,顾名思义,该接口对应的方法类型为接收一个参数,没有返回值, 可以通俗的理解成将这个参数’消费掉了’,一般来说使用Consumer接口往往伴随着一些期望状态的改变或者事件的发生,例如最典型的forEach就是使用的Consumer接口,虽然没有任何的返回值,但是却向控制台输出了语句。 Consumer 使用accept对参数执行行为

    代码示例

     //Consumer<T> 消费型接口 :
        @Test
        public void testLambda2() {
            happy(10000, m -> System.out.println("买东西消费:" + m + "元"));
        }
    
        public void happy(double money, Consumer<Double> con) {
            con.accept(money);
        }
    

    Supplier 接口

    Supplier 接口翻译过来就是提供者,和消费者相反,该接口对应的方法类型为不接受参数,但是提供一个返回值,通俗的理解为这种接口是无私的奉献者,不仅不要参数,还返回一个值,使用get()方法获得这个返回值

    代码示例

       //Supplier<T> 供给型接口 :
        @Test
        public void testLambda3() {
            //生成10个100以内的随机数
            List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));
            //打印
            numList.stream().forEach(System.out::println);
        }
    
        //需求:产生指定个数的整数,并放入集合中
        public List<Integer> getNumList(int num, Supplier<Integer> sup) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < num; i++) {
                //提供
                Integer n = sup.get();
                list.add(n);
            }
    
            return list;
        }
    

    Predicate 接口

    predicate<T,Boolean> 断言接口,该接口对应的方法为接收一个参数,返回一个Boolean类型值,多用于判断与过滤,当然你可以把他理解成特殊的Funcation<T,R>,但是为了便于区分语义,还是单独的划了一个接口,使用test()方法执行这段行为

    代码示例

     @Test
        public void testLambda4() {
            //Predicate<T> 断言型接口:
            List<String> list = Arrays.asList("Hello", "aaa", "Lambda", "bbb", "cc");
            List<String> filterStr = filterStr(list, s -> s.length() >= 3);
            //打印
            filterStr.stream().forEach(System.out::println);
        }
    
        //需求:将满足条件的字符串,放入集合中
        public List<String> filterStr(List<String> list, Predicate<String> pre) {
            //非空判断
            List<String> strList = Optional.ofNullable(list).orElseGet(ArrayList::new)
                    //创建串行流
                    .stream()
                    //过滤
                    .filter(s -> pre.test(s))
                    //返回
                    .collect(Collectors.toList());
            return strList;
        }
    
    展开全文
  • 在上一次的demo中,我们使用lambda在处理自己定义的业务时,需要自定义函数式接口,其实java8已经内置了常用的接口四大核心内置函数式接口Consumer&lt;T&gt; : 消费型接口void accept(T t);@Test public ...

    在上一次的demo中,我们使用lambda在处理自己定义的业务时,需要自定义函数式接口,其实java8已经内置了常用的接口

    四大核心内置函数式接口

    Consumer<T> : 消费型接口

    void accept(T t);

    @Test
    	public void test01(){
    		cons("=======", (x)->System.out.println(x));
    		
    	}
    	public void cons(String s,Consumer<String> con){
    		con.accept(s);
    	}

    Supplier<T> : 供给型接口

    T get(); 

    @Test
    	public void test02(){
    		supp(()->666*2);
    	}
    	public void supp(Supplier<Integer>  su) {
    		System.out.println(su.get());
    	}

    Function<T, R> : 函数型接口

    R apply(T t);

    @Test
    	public void test03(){
    		List<Integer> fun = fun(6,(x)->{
    			List<Integer> list=new ArrayList<>();
    			for (int i = 0; i < x; i++) {
    				Double random = Math.random()*100;
    				list.add(random.intValue());
    			}
    			return list;
    		});
    		
    		for (Integer integer : fun) {
    			System.out.println(integer);
    		}
    	}
    	
    	public List<Integer> fun(Integer num ,Function<Integer,List<Integer>> fun){
    		return fun.apply(num);
    	}

     Predicate<T> : 断言型接口

     boolean test(T t);

    @Test
    	public void test04(){
    		List<String> list=Arrays.asList("23456","wqew","sfsd","yfhfg");
    		List<String> pre = pre(list, (x)->{
    			String y="y";
    			return x.contains(y);
    			});
    		for (String string : pre) {
    			System.out.println(string);
    		}
    		
    		/**
    		 * 注意:这个地方我使用了上次练习中多个语句和一个语句,这里提醒下,当使用一条语句的时候不可以包含{}和return,而多条语句必须要语法规范,哪怕后面的;也不可以少
    		 * 否则eclipise会认为语法有错误(我的版本是4.5.1)
    		 */
    		pre(list, (x)->x.contains("y"));
    	}
    	
    	public List<String> pre(List<String> list,Predicate<String> s){
    		List<String> list1=new ArrayList<>();
    		for (String string : list) {
    			if(s.test(string)){
    				list1.add(string);
    			};
    		}
    		return list1;
    	}; 

    其余的内置接口如下:


    总结:老话说 纸上得来终觉浅。。。。是特别有道理的,不去动手去敲一遍,你是不会知道里面哪里有坑,更不会深入的去思考

    展开全文
  • Consumer 消费型接口 消费对象 void accept(T t); Supplier 供给型接口 生成对象 T get(); Function<R,T> 函数型接口 指定特定功能 R apply(T t); Predicate 断言型接口 进行条件判断 boolean test(T t);
  • lambda 表达式、函数接口四大内置函数接口 详解 优点 简化代码 更加容易并行计算 语法 ​ lambda表达式的标准语法()-> { } ​ -> 左侧 () 内为 参数 ​ -> 右侧 { } lambda 方法体 函数接口 定义...
  • * 四大内置函数型接口 * Consumer<T> 消费性接口 (有来无回) * void accept(T t) * BiConsumer<T,T> * void accpet(T t1,T t2) * * Predicate<T> 段言型 * boolean test(T t) * ...
  • :消费型接口 * void accept(T t) : * * Supplier <T> : 供给型接口 * T get(); * * Function<T,R> :函数型接口 * R apply(T t); * * Predicate<T> : 断言型接口 * boolean test(T t) ...
  • import org.junit.Test; import java.util.function... :消费型接口 * void accept(T t) : * * Supplier <T> : 供给型接口 * T get(); * * Function<T,R> :函数型接口 * R apply(T t); * * ...
  • import org.junit.Test; import java.util.ArrayList; import java.util.List; import java.util.Map;...import java.util.function.Consumer;...import java.util.function.... :消费型接口 * void accept(T t) : *...
  • 引入lambda表达式后,你可以在一个类中简便的定义参数和方法,替代大部分匿名内部类和功能接口,使得代码更加优雅,Lambda提供了一个参数列表和只用这些参数的功能体,也被称为闭包。 二、使用Lambda表达式要知道的...
  • * Java8 内置的四大核心函数式接口 * * Consumer<T> : 消费型接口 * void accept(T t); * * Supplier<T> : 供给型接口 * T get(); * * Function, R> : 函数型接口 * R apply(T t); * * ...
  • 函数式接口@FunctionalInterface作用:该接口标记了引用的接口是一个函数式接口(SAM:Single Abstract Interface)即接口内只能有一个抽象方法、可以有一个默认方法、多个静态方法方法可以使用lambda表达式来传入方法...
  • import org.junit.Test; import java.util.ArrayList; import java.util.Arrays; import java.util.List;...import java.util.function.Function;...import java.util.function.... :消费型接口 * void accept(T t) : ...
  • 四大接口 消费性接口 ​ Consumer void accept(T t) //消费性接口 Consumer<T> //void accept(T t) @Test public void Test() { test("我是谁?",(str1)->System.out.println(str1)); } public ...
  • {需要执行的功能,也可以叫Lambda体,对应接口的抽象方法} Lambda是简化匿名内部类可以省略一些代码,我们的代码看着更简洁,更方便阅读 Lambda的例子; /** * lambda 表达式 实现函数式接口 */ public class ...
  • 由于lambda是必须要函数式接口支持,所以每次使用它都要创建一个新的接口则非常麻烦。 在这里给大家介绍最常用的几大内置 函数式接口,可以直接使用,不用再自己写接口。 1、Consumer<T> :消费型接口 void...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 403
精华内容 161
关键字:

lambda四大接口