java中函数式接口基础知识总结

最新推荐文章于 2024-04-11 09:42:39 发布
最新推荐文章于 2024-04-11 09:42:39 发布
阅读量591 收藏 1
点赞数
分类专栏： java中函数式接口 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45935974/article/details/107072616
版权

函数式接口

函数式接口在java中指的就是；有且仅有一个抽象方法的接口；
函数式接口，适用于函数式编程场景的接口。而java中Lambda就是函数式编程的体现之一，只有确保接口中有且仅有一个抽象方法，java中的Lambda表达式才能顺利的进行推导。
为了确保一个接口中只有一个抽象方法，java8中专门为函数式接口引入了一个新得注解；
@FunctionalInterface注解；该注解用于一个接口的定义上
一旦使用了这个注解，编译器就会强制的检查该接口是否有且仅有一个抽象方法，否则就会报错。
（如果没有使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来并无差异）

代码演示（接口）

@FunctionalInterface
public interface MyFunctionalInterface {
    void method();

}

代码演示（测试）

public class Demotext {
    //定义一个方法，参数使用函数式接口MyFunctionalInterface
    public static void show(MyFunctionalInterface myinter){
        myinter.method();
    }
 public static void main(String[] args) {
 //调用show方法，方法的参数是一个接口，所以我们可以传递接口的匿名内部类
        show(new MyFunctionalInterface() {
            @Override
            public void method() {
                System.out.println("我是一个函数式接口匿名内部类，我输出了一个2");
            }
        });

        //调用show方法，方法的参数是一个函数式接口，我们可以使用lambda表达式
        show(() -> {
            System.out.println("我是一个函数式接口lambda表达式，我输出了一个3");
        });
        //（简化）调用show方法，方法的参数是一个函数式接口，我们可以使用lambda表达式
        show(() ->System.out.println("我是一个函数式接口lambda表达式（简化），我输出了一个4"));

    }
}

函数式编程中Lambda的延迟问题以及代码的优化
如果我写了一个普通的日志案例；
（接口）

public interface LoggerInterface {
    String showLogdemo();
}

（案例）

public class Demo01Logger {
    public static void showLog(int lever ,String message){
        if(lever == 1){
            System.out.println(message);
        }
    }

    public static void main(String[] args) {
        String msg1 = "abc";
        String  msg2 ="cvb";
        String msg3 ="ads";

        showLog(1,msg2+msg1+msg3);
    }
}

这样子写的话，也可以实现我想要实现的功能，但是在我们的实际开发中，追求的是高效率，高性能，上面的案例中，存在一个很大的问题；

那就是在调用showlog方法的时候，他传递的第二个参数是一个拼接后的字符串，他的执行顺序是先把字符串拼接好，在调用showlog方法，如果showlog方法中传递的日志等级不是1的话，那么就存在一个性能浪费的问题。

那么该怎么解决这个问题，是我们现在应该思考的。
优化方案；
Lambda表达式有一个特点，那就是延迟执行
代码改造；


public class Demo01Logger02 {
    public static void showlog(int lever ,LoggerInterface msg){
        if(lever ==1){
            System.out.println(msg.showLogdemo());
        }
    }

    public static void main(String[] args) {
        String msg1 = "abc";
        String  msg2 ="cvb";
        String msg3 ="ads";
       
       
        showlog(1,()->{
            return msg1+msg2+msg3;
        });
    }
}

这样一来，我们便解决了刚刚的问题；
使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中，只有满足条件时才会调用接口LoggerInterface中的方法，才会进行字符串拼接，如果条件不满足，那么LoggerInterface接口中的方法也不会执行，所以不会存在性能的浪费。

还可以使用Lambda作为参数和返回值；
说的简单些，使用Lambda表达式作为方法的参数，其实就是使用函数式接口作为方法的参数。
案例实现

public class Demo01Runnable {
    public static void startThread(Runnable run){
 //   调用Thread中的run方法，在调用start方法，开启一个多线程
        new Thread(run).start();
    }

    public static void main(String[] args) {
    //调用startThread方法,方法的参数是一个接口,那么我们可以传递这个接口的匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了");
            }
        });

        //调用startThread方法,方法的参数是一个函数式接口,所以可以传递Lambda表达式
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了");
        });
        //优化Lambda表达式
        startThread(()->System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了"));
    }
}

java.util.Runnable接口就是一个函数式接口，定义一个StartThread方法使用该接口作为参数，那么就可以使用Lambda进行传参操作；

还可以使用Lambda作为返回值
案例一；
按照以前的写法如果我们想对一组数组进行排序，需要定义一个方法，方法的返回值类型使用函数式接口Comparator，由于方法的返回值是一个接口，我们可以直接返回这个接口的匿名内部类，从而在return中定义我们的排序规则。在主方法中，在进行一次调用
代码实现；

public static Comparator<String> getComparator(){
//方法的返回值是一个接口，直接返回此接口的匿名内部类
     return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串的降序排序
                return o2.length()-o1.length();
            }
        };
         }
 public static void main(String[] args) {
        //创建一个字符串数组
        String[] arr = {"aaa","b","cccccc","dddddddddddd"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));//[aaa, b, cccccc, dddddddddddd]
        //调用Arrays中的sort方法,对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));//[dddddddddddd, cccccc, aaa, b]
    }

}

案例二；
使用Lambda表达式，优化上面的代码

方法的返回值是一个函数式接口，所以我们可以返回一个Lambda表达式
代码实现

 public static Comparator<String> getComparator(){
  /*return (String o1, String o2)->{
            return o2.length()-o1.length();
        };*/
//优化
 return (o1, o2)->o2.length()-o1.length();
    }
    public static void main(String[] args) {
        //创建一个字符串数组
        String[] arr = {"aaa","b","cccccc","dddddddddddd"};
        //输出排序前的数组
        System.out.println(Arrays.toString(arr));//[aaa, b, cccccc, dddddddddddd]
        //调用Arrays中的sort方法,对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组
        System.out.println(Arrays.toString(arr));//[dddddddddddd, cccccc, aaa, b]
    }

}

可以明显的看到代码量已经减少。

其他的一些常用的函数式接口（主要在function包中提供）

第一个（Supplier接口）官方定义；用来获取一个泛型参数指定类型的对象数据。
其实就是获取数据（包含一个get方法）
代码实现

//泛型中定义的是String类型，那么获取的数据也应该是String类型
 public static String getString(Supplier<String> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        //调用getString方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式
        String s = getString(()->{
            //生产一个字符串,并返回
            return "小帅哥";
        });
        System.out.println(s);

        //优化Lambda表达式
        String s2 = getString(()->"小美女");
        System.out.println(s2);
    }
}

注意：

Supplier<T>接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据

第二个：Consumer接口，这个接口是消费一个数据，与刚刚的Supplier接口正好相反（包含一个）
泛型执行什么类型,就可以使用accept方法消费什么类型的数据，至于具体怎么消费(使用),需要自定义(输出,计算…)
代码实现；

 public static void method(String name, Consumer<String> con){
        con.accept(name);
    }
      public static void main(String[] args) {
      //调用method方法，传递字符串姓名，由于后面的参数是一个函数式接口，所以可以使用Lambda表达式
       method("赵丽颖",(String name)->{
       //链式编程，把字符串进行反转输出
      String reName = new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }
}

默认andThen方法
在Consumer接口中，有一个默认方法，他可以把两个或两个以上Consumer类型的操作进行组合。

 public static void method(String s, Consumer<String> con1 ,Consumer<String> con2){
     con1.andThen(con2).accept(s);
       }
   public static void main(String[] args) {
   ethod("Hello",
                (t)->{
                    //消费方式:把字符串转换为大写输出
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    //消费方式:把字符串转换为小写输出
                    System.out.println(t.toLowerCase());
                });
    }
}

注意：
java.util.Objects的requireNoneNull静态方法将会在参数为null时主动抛出NullPointerException异常，这样就省去了重复编写if语句和抛出空指针异常的麻烦。

案例；格式化打印信息；

public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){
        //遍历字符串数组
        for (String message : arr) {
            //使用andThen方法连接两个Consumer接口,消费字符串
            con1.andThen(con2).accept(message);
        }
    }

    public static void main(String[] args) {
        //定义一个字符串类型的数组
        String[] arr = { "小红,女", "小兰,女", "小明,男" };
        printInfo(arr,
                (message)->{
            //消费方式：对message进行切割,获取姓名,按照指定的格式输出
            String name = message.split(",")[0];
            System.out.print("姓名: "+name);
        },
                (message)->{
            //消费方式:对message进行切割,获取年龄,按照指定的格式输出
            String age = message.split(",")[1];
            System.out.println("。性别: "+age+"。");
        });


    }

}

第三个：predicate接口；
当我们需要对某种类型的数据进行判断时，从而得到一个Boolean类型的结果，这时就可以使用java.util.function.Predicate 接口
此接口有几个常用的方法；
（1），抽象方法test----->boolean test(T t).用于条件判断的场景；
（2），默认方法and------>对照条件判断，存在与或非三种常见的逻辑关系，此and也可以实现“并且”的效果；
（3），默认方法or--------->实现逻辑关系中的“或”
（4），默认方法negate------------>实现逻辑关系中的“非”
以下一一实现；
（1），test方法
boolean test(T t);用来对指定数据类型数据进行判断的方法
结果;
符合条件；返回true
不符合条件：返回false

案例实现；（步骤）
（1），定义一个方法，传递String类型的字符串
（2），传递一个Predicate接口，泛型使用String
（3），使用predicate中的方法test对字符串进行判断，并把判断的结果返回
看代码；

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

    public static void main(String[] args) {
        String s = "abcdef";

        //调用checkString方法对字符串进行校验,参数传递字符串和Lambda表达式
        /*boolean b = checkString(s,(String str)->{
            //对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回
            return str.length()>5;
        });*/

        //优化Lambda表达式
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);
    }
}

（2）and方法；表示并且的关系，也可以用于连续两个判断条件
案例实现（步骤）
（1），定义一个方法，方法的参数，传递一个字符串
（2），传递两个Predicate接口
其中一个接口用于判断字符串的长度是否大于3
一个用于判断字符串中是否包含a
两个条件必须同时满足才可以返回true

 public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        //等价于return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);
    }

    public static void main(String[] args) {
        String s = "abcdef";
        //调用checkString方法,参数传递字符串和两个Lambda表达式
        boolean b = checkString(s,
                (String str)->{
            //判断字符串的长度是否大于3
            return str.length()>3;
        },
                (String str)->{
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}

（3）or方法；表示或者的关系，也可以用于连接另个判断条件
案例实现（步骤）
（1），定义一个方法，方法的参数，传递一个字符串
（2），传递两个Predicate接口
一个用于判断字符串的长度是否大于3
一个判断字符串是否包含a
满足一个条件就返回true

看代码；

 public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        //等价于return pre1.test(s) && pre2.test(s);
        return pre1.or(pre2).test(s);
    }

    public static void main(String[] args) {
        String s = "abcdef";
        //调用checkString方法,参数传递字符串和两个Lambda表达式
        boolean b = checkString(s,
                (String str)->{
            //判断字符串的长度是否大于3
            return str.length()>3;
        },
                (String str)->{
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}

(4),negate方法；取反的意思“！”
案例实现（步骤）
（1），定义一个方法，方法的参数，传递一个字符串
（2），使用Predicate接口判断字符串的长度是否大于3
如果不大于3就返回true

看代码

  public static boolean checkString(String s, Predicate<String> pre){
        return  pre.negate().test(s);
    }

    public static void main(String[] args) {
        String s = "ab";
        boolean b = checkString(s,(String str)->{
            return str.length()>3;
        });
        System.out.println(b);
    }
}

案例应用；（集合信息的筛选）
条件（必须为女生，姓名必须是四个字）

import java.util.ArrayList;
 import java.util.List; 
 import java.util.function.Predicate; 
 public class DemoPredicate { 
 public static void main(String[] args) { 
 String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
  List<String> list = filter(array,
   s ‐> "女".equals(s.split(",")[1]), 
   s ‐> s.split(",")[0].length() == 4);
    System.out.println(list);
     }
     private static List<String> filter(String[] array, Predicate<String> one, Predicate<String> two) { 
     List<String> list = new ArrayList<>(); 
     for (String info : array) {
      if (one.and(two).test(info)) {
       list.add(info);
        }
         }
         return list; 
         } 
         }

（4），Function接口；
java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。
抽象方法apply
Function接口中最主要的抽象方法；R apply（T t），根据类型T的参数湖区类型R的结果
案例；
将String类型转换为Integer类型；

  public static void change(String s, Function<String,Integer> fun){
        //Integer in = fun.apply(s);
        int in = fun.apply(s);//自动拆箱 Integer->int
        System.out.println(in);
    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s = "1234";
        //调用change方法,传递字符串类型的整数,和Lambda表达式
        change(s,
        (String str)->{
            //把字符串类型的整数,转换为Integer类型的整数返回
            return Integer.parseInt(str);
        });
        //优化Lambda
        change(s,str->Integer.parseInt(str));
    }
}

Function中的默认方法，用来进行组合操作：andThen
和 Consumer 中的 andThen 差不多

案例实现；

 public static void change(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s = "123";
        //调用change方法,传递字符串和两个Lambda表达式
        change(s,(String str)->{
            //把字符串转换为整数+10
            return Integer.parseInt(str)+10;
        },(Integer i)->{
            //把整数转换为字符串
            return i+"";
        });

        //优化Lambda表达式
        change(s,str->Integer.parseInt(str)+10,i->i+"");
    }
}

练习；自定义函数模型的拼接；
分析:
1. 将字符串截取数字年龄部分，得到字符串；
Function<String,String> “赵丽颖,20”->“20”
2. 将上一步的字符串转换成为int类型的数字；
Function<String,Integer> “20”->20
3. 将上一步的int数字累加100，得到结果int数字。
Function<Integer,Integer> 20->120

代码实现；

   public static int change(String s, Function<String,String> fun1,
                             Function<String,Integer> fun2,Function<Integer,Integer> fun3){
        //使用andThen方法把三个转换组合到一起
        return fun1.andThen(fun2).andThen(fun3).apply(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String str = "赵丽颖,20";
        //调用change方法,参数传递字符串和3个Lambda表达式
        int num = change(str,(String s)->{
            //"赵丽颖,20"->"20"
           return s.split(",")[1];
        },(String s)->{
            //"20"->20
            return Integer.parseInt(s);
        },(Integer i)->{
            //20->120
            return i+100;
        });
        System.out.println(num);
    }
}

还有其他的一些函数式接口，上面的都是一些较为常用的。
后续，还会有一些Stream流与方法的引用，这些内容敬请期待。
再此声明：以上全部内容，均属于个人笔记，目的只是为了方便记忆与回顾，无其他商业用途。如需转载，请注明出处。

weixin_阿飞
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java之函数式接口(FunctionalInterface)
我的博客
12-03 5119
Java之函数式接口 FunctionalInterface
动力节点_Java基础视频教程167_函数式接口注解
12-03
动力节点的Java课程适合绝对零基础的观看，教程中讲解了Java开发环境搭建、Java的基础语法、Java的面向对象。每一个知识点都讲解的非常细腻，由浅入深。适合非计算机专业，想转行做Java开发的朋友，或者想让Java基础...
Java 函数式接口
sokenna的博客
08-14 5853
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
【Java 基础篇】Java函数式接口详解
繁依Fanyi的博客
09-23 615
函数式接口是指仅包含一个抽象方法的接口。在Java中，函数式接口用注解来标识，这个注解不是强制性的，但建议使用它来确保接口符合函数式接口的定义。函数式接口的关键特点是可以被Lambda表达式所实现。Lambda表达式是一种紧凑的语法，用于创建匿名函数，从而更容易地传递函数行为作为参数。函数式接口与Lambda表达式结合使用，可以实现更简洁和可读性强的代码。在这个示例中，Calculator是一个函数式接口，因为它只包含一个抽象方法calculate。
Java之函数式接口
最新发布
ZhangASen的博客
04-11 1661
有且仅有一个抽象方法的接口。Java中的函数式编程体现就是Lambda表达式。所以函数式接口即可以适用于Lambda使用的接口。如何检测一个接口是不是函数式接口？放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败。”);i.show();注意：自定义函数式接口时，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。
Java中的四大函数式接口（重要、需要掌握）
m0_70545163的博客
07-09 1708
摘要：本文讲述了Java中的四大函数式接口，包括消费型、函数型、断言型和供给型这四种类型，根据常用的操作来理解四大函数式接口。
深入理解Java函数式接口
m0_50033700的博客
08-15 507
本文介绍了函数式编程在Java中的作用和重要性。首先解释了函数式接口的定义和特点，以及与Lambda表达式的关系。然后列举了Java中常用的函数式接口，包括Predicate、Function、Consumer和Supplier，并介绍了它们的用途和示例代码。最后，强调了函数式编程在Java中的应用价值和重要性。
详解JAVA8 函数式接口
08-18
在本文中，我们将详细介绍JAVA8 函数式接口的相关知识点，包括四大核心函数式接口和其他函数式接口，并提供了相应的代码示例。 四大核心函数式接口： 1. Consumer接口：消费型接口，无返回值。它的主要用途是对...
java知识点总结思维导图(xmind)
11-12
这份"java知识点总结思维导图(xmind)"是为帮助学习者系统性地理解和掌握Java核心技术而精心整理的资料。思维导图作为一种有效的学习工具，能够帮助我们更好地组织和记忆信息，提高学习效率。 首先，让我们从基础...
Java基础知识-day12【函数式接口、方法引用】修改后文档.pdf
10-26
java学习课件，供参考学习使用
《Java函数式编程》_高清华.zip
07-07
10. **学习资源**：要深入学习Java函数式编程，《Java函数式编程》_高清华这本书可能是很好的起点，它可能涵盖了Lambda表达式的使用、Stream API的实践以及如何在实际项目中应用函数式编程思维等内容。 通过理解和...
Java：函数式(Functional)接口
淼淼不暴躁!
08-11 1480
只包含一个抽象方法（Single Abstract Method，简称SAM）的接口，称为函数式接口。当然该接口可以包含其他非抽象方法。你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。我们可以在一个接口上使用注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。在包下定义了Java 8 的丰富的函数式接口。
Java基础篇--函数式接口
weixin_61500949的博客
05-27 4303
一、函数式接口概述： 1.函数式接口：有且仅有一个抽象方法的接口，java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口有且仅有一个抽象方法，java中的Lambda才能顺利的进行推导 二、如何检测一个接口是不是函数式接口呢？ 1.@FunctionalInterface 2.放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败 @FunctionalInterface public interfaceSum
常用的函数式接口
m0_46598535的博客
06-21 151
常用的函数式接口总结 Function函数式接口 package java.util.function; @FunctionalInterface public interface Function<T, R> { R apply(T t); } package com.kuang.function; import java.util.function.Function; /** * Function 函数型接口, 有一个输入参数，有一个输出 * 只要是 函数型接口 可以 用 lam
C++ 学习轨迹之面向接口和抽象类
weixin_44447309的博客
09-29 195
一.面向接口的含义 1.所谓接口就是指一系列的函数的集合，这些函数提供了一系列功能，然后通过继承的方式分配给需要的类对象，而这些类对象拥有这些功能。 2.面向对象即将数据和算法即数据处理方法封装在一起，所有对象的都是通过类来描述，但是不是所有类都具有描述对象的功能，比如抽象类。 3.在接口中，所有方法都是抽象的，接口是抽象的变体。 二.面向接口的实现 1.java 中有interface关键字实现接口，而C++ 只能通过虚函数或者纯虚函数的方式来实现接口，然后子类继承这个接口类并定义虚函数的功能即可 2.最
函数式接口小结
Luyihx的博客
03-14 363
函数式接口 函数式接口 1.1 概述 如果说一个接口内有且只有一个方法，而且该方法是一个缺省属性为public abstract方法，该接口可以称之为是一个函数式接口。 1.2 @FunctionalInterface 使用 类似于 @Override 开启代码重写格式严格检查 /** * 使用@FunctionalInterface检查函数式接口格式问题 * 要求当前接口中有且只有...
java8的内置函数式接口总结
wthfeng的专栏
10-02 3372
java8引入了函数式的编程，在提高代码简洁和可读性的同时也 增强了程序并发执行的能力。这篇文章我们主要关注java8的函数式接口，以及其内置的若干函数式接口。
Java-函数式接口
qq_39182939的博客
01-31 213
函数式接口简介 接口中只有一个抽象(abstact,一般省略不写)方法的接口； @FunctionalInterface:检查一个接口是否为函数式接口； 简化编程模型，在新版本的框架底层大量应用！ 四大函数式接口 Function函数型接口 import java.util.function.Function; /** * Function 函数型接口, 有一个输入参数，有一个输出 */ public class Demo01 { public static void main(Str
java中四大函数式接口
m0_62520968的博客
04-29 2885
函数式接口： 只有一个方法的接口 格式 @FunctionalInterface public interface Runnable { public abstract void run(); } // 泛型、枚举、反射 // lambda表达式、链式编程、函数式接口、Stream流式计算 // 超级多FunctionalInterface // 简化编程模型，在新版本的框架底层大量应用！ // foreach(消费者类的函数式接口) 1、Function 函数式接口

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值