Java8特性梳理

已于 2024-04-08 10:14:16 修改
阅读量472 收藏
点赞数 2
分类专栏： Java基础 文章标签： java
于 2021-06-27 15:13:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guaituo0129/article/details/118272220
版权

概述

java8包含了很多新特性，这里我们简述几个常用的。

  • Lambda表达式
  • 方法引用
  • Stream API
  • 日期时间类
  • Optional类
  • 接口默认方法
  • JavaScript引擎

1.Lambda表达式

官方解释：Lambda 表达式，是一个匿名函数，即没有函数名的函数。

1.1Lambda的用处

其实我更愿意把它理解为函数式接口的实现。

函数式接口(@FuctionalInterface)：只有一个方法的接口

1.1.1 简单示例

举个例子，假如我们现在有一个接口：

@FunctionalInterface
public interface Arithmetic {
    int add(int a, int b);
}

如果我们想使用这个接口，那么需要先定义一个实现类，再创建实现类的实例。代码如下：

实现类：

public class ArithmeticImpl implements Arithmetic{
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

具体调用：

public class MainDemo {
    @Test
    public void test(){
        Arithmetic arithmetic = new ArithmeticImpl();
        int result = arithmetic.add(1, 2);
        System.out.println(result);
    }
}

但如果使用lambda表达式的话，则可以直接免去定义实现类这步，直接使用lambda表达式作为接口实现。代码如下：

public class MainDemo {
    @Test
    public void test2(){
        Arithmetic arithmetic = (a, b) -> a + b;
        int result = arithmetic.add(1, 2);
        System.out.println(result);
    }

}

1.1.2 再来个Lambda范例

如果上面没看出来差别，我们再举个更常见的例子：创建线程。

方式一：定义Runnable实现类

1.定义Runnable实现类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("MyRunnable运行啦");
    }
}

2.创建Thread并运行

public class ThreadTest {
    @Test
    public void test1(){
        Runnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

方式二：匿名实现类

直接创建匿名实现类。比起上面省去了定义实现类这步。

public class ThreadTest {
    @Test
    public void test2(){
        Runnable runnableImpl = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名实现类 运行啦");
            }
        };
        Thread thread = new Thread(runnableImpl);
        thread.start();
    }
}

方式三：lambda表达式

那针对方式二，是不是可以更简单呢。

答案当然是可以啦，因为Runnable是一个函数式接口，只有一个方法嘛，所以我们可以连这个方法名都省去，只要有方法体就行。

所以我们可以直接用lambda表达式，作为它的实现类。

public class ThreadTest {
    @Test
    public void test3(){
        Runnable lambda = () -> System.out.println("lambda实现类 运行啦");
        Thread thread = new Thread(lambda);
        thread.start();
    }
}

通过上面两个例子，我们可以了解到lambda表达式可使用的地方。

即：凡是需要函数式接口实现类的地方，都可以用lamba表达式作为实现类。

（除此之外，可能还有其他地方可用lamba表达式，但恕我知识有限，暂时还不太清楚）

1.2 lambda表达式结构体

知道了它的用处，也更要知道它的写法。lambda既然是匿名类函数，那肯定也是有方法声明和方法体，结构如下：

(...) -> {...}

主要分为三部分：

1.         ()     参数部分

声明参数列表。接口中已声明参数类型个数，此处无需声明参数类型，仅需标明参数名。

2.        ->    箭头符号

区分参数部分和方法体部分。

3.        {}     方法体部分

就是正常方法体，和普通方法体一样写就行。

需要特殊说明的地方简单介绍下，举几个例子大家就明白了

参数部分说明：

1.如果参数列表为空的话，参数部分为空即可

() -> {System.out.println("hello")}

2.参数列表只有一个的时候，括号()可省略

(a) -> {System.out.println("hello " + a)}
a -> {System.out.println("hello " + a)}

3.多个参数的话，挨个声明变量名即可

(a,b,c) -> {
    System.out.println("hello " + a);
    System.out.println("hello " + b);
    System.out.println("hello " + c);
}

箭头部分：

箭头部分固定格式，不可缺少，不可改动。

方法体部分：

1.正常结构：

(a) -> {
    System.out.println("hello " + c);
}

2.如果方法体中只有一行代码，{}括号可以省略

a -> System.out.println("hello " + a);

3.如果方法有返参，正常使用return关键字即可

(a,b,c) -> {
    System.out.println("hello " + a);
    System.out.println("hello " + b);
    System.out.println("hello " + c);
    return a + b + c;
}

4.如果方法只有一行且有反参，{} 可省略，return 关键字可省略。

(a,b,c) -> a + b + c;

1.3 java.util.function包

JDK 1.8 API包含了很多内建的函数式接口，简单枚举如下：

nametypedescription
ConsumerConsumer< T >接收T对象，不返回值
PredicatePredicate< T >接收T对象并返回boolean
FunctionFunction< T, R >接收T对象，返回R对象
SupplierSupplier< T >提供T对象（例如工厂），不接收值
UnaryOperatorUnaryOperator接收T对象，返回T对象
BinaryOperatorBinaryOperator接收两个T对象，返回T对象

好多时候需要使用上述接口的一些实现类，那这些地方就可以直接使用lamba表达式啦。

比如我们后面要说的Stream类，就大量依赖这些接口，所有我们才经常说Stream要配合lambda表达式一起使用。

public interface Stream<T> extends BaseStream<T, Stream<T>> {

    Stream<T> filter(Predicate<? super T> predicate);

    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

    IntStream mapToInt(ToIntFunction<? super T> mapper);
   
    LongStream mapToLong(ToLongFunction<? super T> mapper);

    ...
}

2.方法引用

方法引用通过方法的名字来指向一个方法，可以使语言的构造更紧凑简洁，减少冗余代码。

方法引用使用一对冒号 ::  表示调用某个方法，通常格式为下面两种

ClassName::MethodName
ObjectName::MethodName

直接讲定义不太好理解，我们直接看个demo。还是上面那个Arithmetic接口。

@FunctionalInterface
public interface Arithmetic {
    int add(int a, int b);
}

我们用lamba表达式来实现这接口

public class ReferDemo {
    @Test
    public void test1(){
        Arithmetic arithmetic = (a, b) -> a + b;
        System.out.println(arithmetic.add(1,2));
    }
}

上面代码已经很简便了，但还可以再简便一些吗？当然可以， a+b 这个方法体可以直接用Integer.sum()接口替换。替换后结果代码如下：

    Arithmetic arithmetic = (a, b) -> Integer.sum(a,b);

看到这种格式，就到了使用方法引用的时候了，直接使用方法引用再次替换上述代码：

public class ReferDemo {
    @Test
    public void test2(){
        Arithmetic arithmetic = Integer::sum;
        System.out.println(arithmetic.add(1,2));
    }
}

看到这里我们可以总结下方法引用是什么了：

如果lambda表达式中，仅是调用了某个类或对象的方法，且表达式的入参与方法的入参一致，那这个lambda表达式就可以直接简写为方法引用。

3.Stream API

终于到了Java8 的重头戏，Stream类是我们日常工作中处理数据集合类最常用的工具类。

Stream API的特点是：

  • Stream API提供了一套新的流式处理的抽象序列；
  • Stream API支持函数式编程和链式操作；
  • Stream可以表示无限序列，并且大多数情况下是惰性求值的。

（说实话上述概念我不懂，我只会用...）

3.1使用简述

使用Stream处理集合使用时具体分为三个步骤：

一个流式过程中，可以包含多个处理操作，以及一个终结操作。

1.生成流

toStream()        生成流

toParallel()       生成并行流 （数据量不是很大的话，转换流的成本会比并行节省的时间成本高）

2.处理

处理过滤stream中的数据，但不生成最终结果。

filter()                过滤某些数据，将符合条件的元素提取到新的流中的操作

map()                将每个元素转换成其他对象，生成新的流

sort()                将元素按规则排序，生成新的流

...

3.终结/汇总

针对前面过程中处理过的数据进行呢汇总，生成最终结果。

forEach()        遍历每一个元素进行操作

collect()           汇总数据，转成集合

max()               获取最大值

count()             获取数量

anyMatch()       是否存在元素满足条件

...

3.3 常见使用

我们下面的案例都会使用个Person类，这类事先定义好。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    private String name;
    private int age;
}

1.遍历

void forEach(Consumer<? super T> action);

先生成流，再对每一个元素进行打印输出。

注意看哦，我们这里还有了上面说过的方法引用

public class StreamDemo {
    List<Person> personList;
    @Before
    public void init(){
        personList = new ArrayList<>();
        personList.add(new Person("xiang",22));
        personList.add(new Person("ming",15));
    }
    @Test
    public void test1(){
        personList.stream().forEach(System.out::println);
    }
}

2.过滤

Stream filter(Predicate<? super T> predicate);

只有满足条件的数据才会传递下去生成新的流。即年龄大于18的人员才会被打印出来。

public class StreamDemo {
    List<Person> personList;

    @Before
    public void init() {
        personList = new ArrayList<>();
        personList.add(new Person("xiang", 22));
        personList.add(new Person("ming", 15));
    }

    @Test
    public void test2() {
        //过滤，获取年龄大于18的人员
        personList.stream()
                .filter(s -> s.getAge() > 18)
                .forEach(System.out::println);
    }
}

3.转换

 Stream map(Function<? super T, ? extends R> mapper);

将流中的元素转换为其他类型的元素。

这里将Person类型的对象转换为String类型的名字了。

public class StreamDemo {
    List<Person> personList;

    @Before
    public void init() {
        personList = new ArrayList<>();
        personList.add(new Person("xiang", 22));
        personList.add(new Person("ming", 15));
    }

    @Test
    public void test3() {
        //转换，Person 转为 String
        personList.stream()
                .map(s->s.getName() + "," + s.getAge())
                .forEach(System.out::println);
    }
}

4.排序 + 转换

既然是流式处理，那么在写法上，其实也是可以流式传递的。

下面就是一个先排序，再转换的一个案例。

public class StreamDemo {
    List<Person> personList;

    @Before
    public void init() {
        personList = new ArrayList<>();
        personList.add(new Person("xiang", 22));
        personList.add(new Person("ming", 15));
    }

    @Test
    public void test4() {
        //过滤，获取年龄大于18的人员
        personList.stream()
                .sorted(Comparator.comparing(Person::getAge))
                .map(s->s.getName() + "," + s.getAge())
                .forEach(System.out::println);
    }
}

5.转为List

此处显示了一个将Person转换为String，最终收集为一个List的操作。

public class StreamDemo {
    List<Person> personList;

    @Before
    public void init() {
        personList = new ArrayList<>();
        personList.add(new Person("xiang", 22));
        personList.add(new Person("ming", 15));
    }

    @Test
    public void test5() {
        List<String> descList = personList.stream()
                .map(s -> s.getName() + "," + s.getAge())
                .collect(Collectors.toList());
        System.out.println(descList);
    }
}

6.转为Map

这里将一个list转为了一个map：

name作为key，Person对象作为value。

public class StreamDemo {
    List<Person> personList;

    @Before
    public void init() {
        personList = new ArrayList<>();
        personList.add(new Person("xiang", 22));
        personList.add(new Person("ming", 15));
        personList.add(new Person("xiao", 15));
    }

    @Test
    public void test6() {
        Map<String, Object> objectMap = personList.stream().collect(Collectors.toMap(Person::getName, s -> s));
        System.out.println(objectMap);
    }
}

7.按年龄分组

 这里将list的元素按年龄分组:

age作为key，List作为value

public class StreamDemo {
    List<Person> personList;

    @Before
    public void init() {
        personList = new ArrayList<>();
        personList.add(new Person("xiang", 22));
        personList.add(new Person("ming", 15));
        personList.add(new Person("xiao", 15));
    }

    @Test
    public void test7() {
        Map<Integer, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getAge));
        System.out.println(group);
    }
}

8.获取年龄总和

public class StreamDemo {
    List<Person> personList;

    @Before
    public void init() {
        personList = new ArrayList<>();
        personList.add(new Person("xiang", 22));
        personList.add(new Person("ming", 15));
        personList.add(new Person("xiao", 15));
    }

    @Test
    public void test8() {
        int ageSum = personList.stream().mapToInt(Person::getAge).sum();
        System.out.println(ageSum);
    }
}

诸如此类的操作，后续大家挨个试下就会觉得Stream超级好用了。

4.日期时间类

因为之前的Date时间类，无论是计算还是格式化，都不是很好用。所以java8中推出了java.time包。其中的LocalDate、LocalDateTime等时间类无论是效率还是使用上都以前提升很多。

4.1 日期、时间的加减

public class TimeTest {
    @Test
    public void test1(){
        LocalDate today = LocalDate.now();
        LocalDate yesterday = today.minusDays(1);
        LocalDate lastMonthDay = today.minusMonths(1);

        System.out.println(today);
        System.out.println(yesterday);
        System.out.println(lastMonthDay);
    }

    @Test
    public void test2(){
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime tomorrow = now.plusDays(1);
        LocalDateTime nextMonthDay = now.plusMonths(1);

        System.out.println(now);
        System.out.println(tomorrow);
        System.out.println(nextMonthDay);
    }
}

输出：

4.2 日期时间的格式化

public class TimeTest {
    @Test
    public void test3(){
        //定义格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        
        //字符串转日期
        LocalDate localDate = LocalDate.parse("2021-01-01", formatter);
        System.out.println(localDate);

        //日期转字符串
        LocalDate today = LocalDate.now();
        String todayStr = today.format(formatter);
        System.out.println(todayStr);
    }
}

5.Optional类

在java8之前，我们针对某个对象可能要做一些判空处理，而Optional类则是帮我减少这类判空处理的代码逻辑。

它提供了一些诸如isPresent() 、orElse()等好用的方法。

Optional在使用时，可依据具体场景使用。

public class OptionalDemo {
    List<Person> personList;

    @Before
    public void init() {
        personList = new ArrayList<>();
        personList.add(new Person("ming", 15));
        personList.add(new Person("xiao", 15));
    }

    @Test
    public void test1(){
        Optional<Person> first = personList.stream().filter(s->"xiang".equals(s.getName())).findFirst();
        //如果first.get()为空的话，提供一个默认值对象
        Person xiang = first.orElse(new Person("xiang",25));
        System.out.println(xiang);
    }
}

6.接口默认方法

6.1 接口默认实现

接口可以有默认实现了，实现类可以直接使用它的默认实现。

接口：

public interface Arithmetic {
    default int add(int a, int b){
        return a +b;
    }
}

实现类：

public class ArithmeticImpl implements Arithmetic{
}

Test：

public class InterfaceTest {
    @Test
    public void test1(){
        Arithmetic arithmetic = new ArithmeticImpl();
        System.out.println(arithmetic.add(1,2));
    }
}

输出：

6.2接口静态方法

接口还可以拥有静态方法了，外部调用时就像调用类的静态方法一样使用

接口：

public interface Arithmetic {
    static String hello(String name){
        return "hello " + name;
    }
}

Test：

public class InterfaceTest {
    @Test
    public void test2(){
        System.out.println(Arithmetic.hello("xiang"));
    }
}

7.JavaScript引擎

java8提供了一个能够解析js脚本的引擎，可以运行js代码

public class JSDemo {
    /**
     * var fun1 = function(name) {
     *     print('Hello ' + name);
     *     return "Hi!";
     * }
     *
     * var fun2 = function (object) {
     *     print(Object.prototype.toString.call(object));
     * };
     */
    @Test
    public void test1() throws ScriptException, NoSuchMethodException {
        //js脚本
        String script ="var fun1 = function(name) {\n" +
                "    print('Hello ' + name);\n" +
                "    return \"Hi!\";\n" +
                "}\n" +
                "\n" +
                "var fun2 = function (object) {\n" +
                "    print(Object.prototype.toString.call(object));\n" +
                "};";

        //声明js引擎
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
        //处理js脚本
        engine.eval(script);

        //调用js方法
        Invocable invocable = (Invocable) engine;
        Object result = invocable.invokeFunction("fun1", "Nashorn");
        System.out.println(result);
        System.out.println(result.getClass());
    }
}

输出结果：

8.写在最后

无论怎么简便，不过都是语法糖而已，编译后的字节码还是没什么变化。

但只要能简化美化我们代码的语法，都应该去尝试写写。

毕竟代码是要给人看的，代码优雅些，更利于团队和谐嘛！

希昂的学习日记
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java 8 教程（基础篇）
qq_35414977的博客
01-28 1587
集合——有时称为容器——是一个对象，它将多个元素组合成一个单元。集合用于存储、检索、操作和通信聚合数据。集合框架表示和操作集合的统一体系结构。组成接口表示集合的抽象数据类型。接口允许对集合进行独立于其表示细节的操作。在面向对象语言中，接口通常形成层次结构。实现是集合接口的具体实现。本质上，它们是可重用的数据结构。算法这些方法在实现集合接口的对象上执行有用的计算，比如搜索和排序。这些算法被认为是多态的:也就是说，相同的方法可以用于适当的集合接口的许多不同实现。本质上，算法是可重用的功能。
java8的下载与安装(网上教程的安装方法)
热门推荐
code猫大叔
12-10 13万+
1 首先是进入java的下载页面 Java Downloads | Oraclehttps://www.oracle.com/java/technologies/downloads/ 然后下拉，选java8 点击java8之后，会出现 这时我们选择windows（当然，以你的系统环境而定） 然后 基本上就可以下载了， 为什么是基本上，因为，需要你注册一个账户，注册完，就可以下载了 //----------------------------------------- ..
java8新特性总结
CUITAO2305532402的博客
06-11 2850
Java中的Lambda表达式是JDK8中的一种新特性，它允许我们将一段代码（这段代码可以理解为一个接口的实现）当成参数传递给某个方法，然后进行业务处理，这种方式更像是一种函数式编程风格，可以让代码结构更简洁，开发效率更高。比较让人容易迷乱的是lambda的几个简化写法。后面会一一细说。lambda的学习点也就两个，一个是把一点代码作为参数传递，一个是它的简化写法。
Java8 的十大新特性
最新发布
qq_64037280的博客
06-09 685
Lambda表达式本质上是一个匿名方法，即可以把函数作为一个方法的参数（函数作为参数传递进方法）或是把代码视为数据。其构成部分包括：使用逗号分隔的参数列表、箭头符号、函数体三部分组成。在遇到函数逻辑较为复杂时可以通过大括号将其包括。Lambda表达式可以引用类的成员遍历与局部变量（非final变量会转为final）。Lambda可能会返回一个值。返回值的类型也是由编译器推测出来的。
Java8特性大全
Mr. David 专栏
07-05 1552
为了方便对收集操作的理解，方便读者掌握收集操作，将收集分为普通收集和高级收集。方法引用是对特殊 Lambda 表达式的一种简化写法，当 Lambda 体中只调用一个方法，此方法满足函数式接口规范，此时可以使用::方法引用语法。从语法表现力角度来讲，方法引用 > Lambda表达式 > 匿名内部类，方法引用是高阶版的 Lambda 表达式，语言表达更为简洁，强烈推荐使用。传统的Collectors类中的排序支持 List 实现类中的一部分排序，使用 stream 排序，能够覆盖所有的 List 实现类。
Java 8中的一些主要特性及其详细使用方法
hackerlee
07-13 822
Java 8引入了全新的日期和时间 API，位于 java.time 包下，提供了更好的日期、时间处理和操作的方式。Java 8 中的这些新特性使得 Java 编程更加灵活、高效和易读，提供了更好的工具和功能来应对不同的开发需求。Java 8 中的这些新特性使得 Java 编程更加强大和便利，提供了更多的语言特性和工具来提升开发效率和代码质量。Java 8 允许接口中定义默认方法，即在接口中可以提供方法的默认实现。这样做的目的是为了在接口的演化过程中能够向已有的实现提供新的方法，而不会破坏实现的兼容性。
Java8新特性知识梳理
11-24
Java 8 是一个重要的Java版本，它引入了许多新特性，极大地提升了开发效率和代码的可读性。其中，最引人注目的特性之一就是引入了流（Stream）API，这使得处理集合数据更加高效和简洁，支持声明式编程风格。 流API...
java知识梳理.docx
03-06
【Java知识梳理】 Java是一种广泛使用的编程语言，其特点包括： 1. **简单易学**：Java语法简洁，易于理解，适合初学者。 2. **丰富的类库**：Java拥有庞大的标准类库，涵盖各种功能，如I/O、网络、数据库连接等。 ...
java_knowledge:对JAVA一些代码知识梳理
03-29
Java是一种面向对象的语言，它的三大特性是封装、继承和多态。封装是将数据和操作数据的方法绑定在一起，形成一个独立的对象。继承允许一个类（子类）继承另一个类（父类）的属性和方法，这样可以实现代码复用。多态...
Java知识框架梳理，常见的面试题整理和一些工作过程中的实践
06-29
面向对象是Java的核心特性，包括类、对象的创建与销毁、封装、继承、多态等概念。深入理解类的构造器、访问修饰符、final关键字、抽象类和接口的运用，以及如何实现多态性，是提高编程能力的关键。 三、集合框架 ...
Java-20210417.rar
04-17
【Java知识梳理】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（后被Oracle公司收购）于1995年发布。它以其“一次编写，到处运行”的特性闻名，这意味着编写好的Java代码可以在任何支持Java的平台...
【MyBatis-Plus】第一章 快速入门
313YPHU3的博客
08-23 412
【MyBatis-Plus】第一章 快速入门
一文掌握Lambda表达式(上)
技术分享
06-26 492
本文主要对流与操作做了一个总体的介绍，后续将详细介绍流的收集与汇聚
函数式接口
qq_53529114的博客
03-04 225
函数式接口 1.概述 1.1 定义 函数式接口：有且仅有一个抽象方法的接口 Java中的函数式接口体现就是Lambda表达式，所以函数式接口就是可以使用Lambda表达式的接口 只有确保接口中有且仅有一个抽象方法，Java中Lambda表达式才能顺利进行推导 1.2 使用 如何检测一个接口是否为函数式接口？ @FunctionalInterface 放在定义接口的上方：如果接口是函数式接口，编译通过；如果不是，编译失败 注意： 我们自己定义函数式接口的时候，@FunctionalInterface是可
Java 8 新特性
m0_52581288的博客
08-05 1398
Java 8 新特性快速入门，有这一篇就够了
java8新特性（简述十大新特性）
ywl470812087的博客
12-23 3394
你真的开始用JDK8了吗？如果你没有用上一些新特性，请别说自己使用了Java8。Java 8可谓是自Java 5以来最具革命性的版本了，她在语言、编译器、类库、开发工具以及Java虚拟机等方面都带来了不少新特性。我们来一一回顾一下这些特性。
lambad表达式（3） 利用Stream对数据类型进行转换
qq_42773076的博客
09-23 5859
1、Stream.map 其作用接收一个泛型T，返回泛型R，map函数的定义，返回的流，表示的泛型是R对象，这个表示，调用这个函数后，可以改变返回的类型。 map方法的源码如下： /** *这个接口，接收一个泛型T，返回泛型R，map函数的定义，返回的流，表示的泛型是R对象，这个表示，调用这个函数后，可以改变返回的类型 */ <R> Stream<R> map(Function<? super T, ? extends R> mapper);
Java-8新特性
日拱一卒
12-07 940
Java8新特性总结
JAVA8新特性学习笔记
程铭程铭你快成名的博客
08-15 4494
用JAVA8也好久了，在这里记录几个比较常见也是自己常用的新特性，与大家进行分享。 Lambda表达式 Stream API Date API Optional API 接口的默认方法和静态方法 Lambda表达式 它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理。最简单的Lambda表达式可由逗号分隔的参数列表、-&amp;amp;amp;amp;gt;符号和语句块组成。 Lambda语法如下 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值