Optional的使用详解

1、Optional介绍

  •  Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
  • Optional 是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。
  • Optional 类的引入很好的解决空指针异常。

2、构建Optional

构建一个Optional对象;方法有:empty( )、of( )、ofNullable( )

 //返回一个描述给定值的Optional ,如果不为null ,则返回一个空的Optional 。
        //参数:值–描述的可能为null值
        //类型参数:<T> –值的类型
        //返回值:一个Optional与如果指定值是非当前值null ,否则一个空Optional
        Optional.ofNullable("");

        //返回一个Optional描述给定的非null值。
        //参数:value –要描述的值,必须为非null
        //类型参数:<T> –值的类型
        //返回值:存在值的Optional
        Optional.of("");

        //返回一个空的Optional实例。 此Optional没有值。
        //类型参数:<T> –不存在的值的类型
        //返回值:一个空的Optional
        //api注意:尽管这样做可能很诱人,但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。
        // 不能保证它是一个单例。
        // 而是使用isPresent()
        Optional.empty();

3、Optional API 及源码注解

package java.util;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
一个可能包含也可能不包含非null值的容器对象。 如果存在值,则isPresent()返回true 。 如果不存在任何值,则该对象被视为空,并且isPresent()返回false 。
提供了其他取决于所包含值是否存在的方法,例如orElse() (如果不存在值,则返回默认值)和ifPresent() (如果存在值,则执行操作)。
这是一个基于值的类; 在Optional实例上使用标识敏感的操作(包括引用等于( == ),标识哈希码或同步)可能会产生不可预测的结果,应避免使用
 */
public final class Optional<T> {
    /**
     * empty()通用实例
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * 如果不为空,则为该值;否则为false。 如果为null,则表示不存在任何值
     */
    private final T value;

    /**
        构造一个空实例。
        impl注意:
        通常,每个VM仅应存在一个空实例EMPTY 
     */
    private Optional() {
        this.value = null;
    }

    /**
        返回一个空的Optional实例。 此Optional没有值。
        类型参数:<T> –不存在的值的类型
        返回值:一个空的Optional
        api注意:
        尽管这样做可能很诱人,但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。 不能保证它是一个单例。 而是使用isPresent() 
     */
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    /**
        使用描述的值构造一个实例。
        参数:值–要描述的非null值
        抛出:NullPointerException如果值为null
     */
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    /**
        返回一个Optional描述给定的非null值。
        参数:value –要描述的值,必须为非null
        类型参数:<T> –值的类型
        返回值:存在值的Optiona
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    /**
        返回一个描述给定值的Optional ,如果不为null ,则返回一个空的Optional 。
        参数:值–描述的可能为null值
        类型参数:<T> –值的类型
        返回值:一个Optional与如果指定值是非当前值null ,否则一个空Optional
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    /**
        如果存在值,则返回该值,否则抛出NoSuchElementException 。
        返回值:此Optional描述的非null值
        抛出:NoSuchElementException如果不存在任何值
        api注意:此方法的首选替代方法是orElseThrow() 。
     */
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
        如果存在值,则返回true ,否则返回false 。

        返回值:如果存在值,则为true ,否则为false
     */
    public boolean isPresent() {
        return value != null;
    }

    /**
        如果不存在值,则返回true ,否则返回false 。

        返回值:如果不存在值,则为true ,否则为false
     */
    public boolean isEmpty() {
        return value == null;
    }

    /**
        如果存在值,则使用该值执行给定的操作,否则不执行任何操作。
        参数:动作–要执行的动作(如果存在值)
     */
    public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }

    /**
        如果存在值,则使用该值执行给定的操作,否则执行给定的基于空的操作。
        参数:动作–要执行的动作(如果存在值)emptyAction –要执行的基于空的操作(如果不存在任何值)
        抛出:NullPointerException如果存在一个值并且给定的操作为null ,或者不存在任何值并且给定的基于空的操作为null 
     	@since 9
     */
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

    /**
        如果存在一个值,并且该值与给定的谓词匹配,则返回描述该值的Optional ,否则返回一个空的Optional 。

        参数:谓词–应用于值的谓词(如果存在)
        返回值:一个Optional描述此的值Optional ,如果一个值存在并且该值给定的谓词相匹配,否则一个空Optional
        抛出:NullPointerException如果谓词为null
     */
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }

    /**
        如果存在值,则返回一个Optional描述(就像by ofNullable ),将给定映射函数应用于该值的结果,否则返回一个空的Optional 。
        如果映射函数返回null结果,则此方法返回空的Optional 
     */
    public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }

    /**
         如果存在一个值,则返回将给定Optional -bearing映射函数应用于该值的结果,否则返回一个空的Optional 。
        此方法类似于map(Function) ,但是映射函数是其结果已经是Optional函数,如果调用该函数,则flatMap不会将其包装在其他Optional 。

        参数:mapper –应用于值的映射函数(如果存在)
        类型参数:<U> –映射函数返回的Optional值的类型
        返回值:施加的结果Optional荷瘤映射函数此的值Optional ,如果一个值存在,否则一个空Optional
        抛出:NullPointerException如果映射函数为null或返回null结果

     */
    public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional<U> r = (Optional<U>) mapper.apply(value);
            return Objects.requireNonNull(r);
        }
    }

    /**
        如果值存在时,返回一个Optional描述的值,否则将返回一个Optional产生通过供给功能。

        参数:供应商–产生要返回的Optional的供应功能
        返回值:返回一个Optional描述此的值Optional ,如果一个值存在,否则Optional所生产的供应功能。
        抛出:NullPointerException如果提供的函数为null或产生null结果
     * @since 9
     */
    public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);
        if (isPresent()) {
            return this;
        } else {
            @SuppressWarnings("unchecked")
            Optional<T> r = (Optional<T>) supplier.get();
            return Objects.requireNonNull(r);
        }
    }

    /**
        如果存在值,则返回仅包含该值的顺序Stream ,否则返回空Stream 。

        返回值:作为Stream的可选值
     * @since 9
     */
    public Stream<T> stream() {
        if (!isPresent()) {
            return Stream.empty();
        } else {
            return Stream.of(value);
        }
    }

    /**
        如果存在值,则返回该值,否则返回other 。

        参数:其他–要返回的值(如果不存在任何值)。 可以为null 。
        返回值:值(如果存在),否则other
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

    /**
        如果存在值,则返回该值,否则返回由供应函数产生的结果。

        参数:供应商–产生要返回的值的供应函数
        返回值:值(如果存在),否则提供功能产生的结果
     */
    public T orElseGet(Supplier<? extends T> supplier) {
        return value != null ? value : supplier.get();
    }

    /**
     * If a value is present, returns the value, otherwise throws
     * {@code NoSuchElementException}.
     *
     * @return the non-{@code null} value described by this {@code Optional}
     * @throws NoSuchElementException if no value is present
     * @since 10
     */
    public T orElseThrow() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
        如果存在值,则返回该值,否则抛出由异常提供函数产生的异常。

        参数:exceptionSupplier –产生要抛出的异常的提供函数
        类型参数:<X> –引发的异常类型
        返回值:值(如果存在)
        抛出:X –如果不存在任何值NullPointerException如果不存在任何值并且异常提供函数为null
        api注意:带有空参数列表的对异常构造函数的方法引用可用作提供者
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }
}

4、测试使用

4.1、构建

//返回一个描述给定值的Optional ,如果不为null ,则返回一个空的Optional 。
//参数:值–描述的可能为null值
//类型参数:<T> –值的类型
//返回值:一个Optional与如果指定值是非当前值null ,否则一个空Optional
Optional s1 = Optional.ofNullable(null);

// 构建一个value不可以为null的optional对象,如果of()的入参为null会报空指针异常;
Optional<MyUser> s2 = Optional.of(new MyUser("阿辉2","123456"));

// 构建一个value可以为null的optional对象;
Optional<MyUser> s3 = Optional.ofNullable(null);

System.out.println(s1);
System.out.println(s2);
System.out.println(s3);

/* 输出
 * Optional.empty
 * Optional[MyUser{id='阿辉2', username='123456'}]
 * Optional.empty
 **/

4.2、判断类

 Optional<MyUser> myUser1 = Optional.empty();
        Optional<MyUser> myUser2 = Optional.of(new MyUser("阿飞", "123456"));

        // filter传入一个lambda,lambda返回值为boolean;true:不做任何改变,false:返回一个空的optional;
        Optional<MyUser> myUser3 = myUser2.filter(user -> "错误的密码".equals(user.getUsername()));

        // isPresent就是判断value是不是null;我们在调用get之前,一定要先调用isPresent,因为直接如果value是null,直接调用get会报异常;
        if (myUser1.isPresent()) {
            MyUser value = myUser1.get();
            System.out.println("optional value:" + value);
        } else {
            System.out.println("optional value==null");
        }
        // ifPresent传入一段lambda,当value!=null时,执行里面的逻辑;当当value==null时,啥都不干;
        myUser2.ifPresent(value -> System.out.println("optional value:" + value));


        System.out.println(myUser3);

        // 输入如下:
        //optional value==null
        //optional value:MyUser{id='阿飞', username='123456'}
        //Optional.empty

4.3、获取类(常用)

  Optional<MyUser> userInfoEmptyOpt = Optional.empty();
        Optional<MyUser> userInfoOpt = Optional.of(new MyUser("阿飞","123456"));

        
        // 1、直接获取,注意如果value==null,会报NoSuchElementException异常
        MyUser userInfo1 = userInfoOpt.get();
        
        // 2、orElse可以传入一个UserInfo类型的对象作为默认值;
        //    当value!=null时,返回value值;当value==null时,返回默认值作为代替;
        MyUser userInfo2 = userInfoEmptyOpt.orElse(new MyUser("阿飞1","123456"));
        
        // 3、orElseGet和orElse不同的是orElseGet可以传入一段lambda表达式;
        // 当value!=null时,返回value值;
        // 当value==null时,使用该lambda返回的对象作为默认值;
        MyUser userInfo3 = userInfoEmptyOpt.orElseGet(() -> new MyUser("阿飞2","123456"));
        
        // 4、orElseThrow可以传入一段lambda表达式,lambda返回一个Exception;当value!=null时,返回value值;当value==null时,抛出该异常;
        MyUser userInfo4 = userInfoOpt.orElseThrow(NullPointerException::new);

        System.out.println(userInfo1);
        System.out.println(userInfo2);
        System.out.println(userInfo3);
        System.out.println(userInfo4);

        // 输出如下:
        // UserInfo(username=阿飞, password=123456)
        // UserInfo(username=阿飞1, password=123456)
        // UserInfo(username=阿飞2, password=123456)
        // UserInfo(username=阿飞, password=123456)

4.4、转换类

 Optional<MyUser> userInfoOpt = Optional.of(new MyUser("阿飞","123456"));

        // 原来value的类型是UserInfo,经过map转换为Optional<String>
        Optional<String> username = userInfoOpt.map(MyUser::getId);

        // 当map的入参也是一个Optional时,经过map转化后会形成Optional<Optional<String>>这种嵌套结构;但flatMap可以把这种嵌套结构打平;
        Optional<Optional<String>> unFlatMap = userInfoOpt.map(user -> Optional.of(user.getId()));
        Optional<String> flatMap = userInfoOpt.flatMap(user -> Optional.of(user.getId()));

        System.out.println(username);
        System.out.println(unFlatMap);
        System.out.println(flatMap);

        // 输出如下:
        // Optional[阿飞]
        // Optional[Optional[阿飞]]
        // Optional[阿飞]

4.5、测试API使用

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.junit.Test;

import java.math.BigDecimal;
import java.util.Optional;

/**
 * @version 1.0
 * @author: crush
 * @date: 2021-04-12 20:51
 */
public class OptionalStudy {

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    static class Employee {
        private Long id;
        private String name;
        private Boolean leader;
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    static class Leader {
        private Long employeeId;
        private BigDecimal bonus;
    }

    /**
     * 找到ID为1的员工,如果有奖金就打印出来,没有就打印没有奖金;
     * @throws
     */
    @Test
    public void tst() {
        Optional<Leader> leader = Optional.ofNullable(getEmployeeById(1L)
                        .filter(Employee::getLeader)
                        .map(Employee::getId)
                        .flatMap(this::getLeaderByEmployeeId)
                        .orElse(null));
        if (leader.isPresent()) {
            Optional.of(leader.map(Leader::getBonus).map(bonus -> String.format("员工ID为1的leader奖金为:%s", bonus)).orElse("员工ID为1的leader也没有奖金")).ifPresent(System.out::println);
        } else {
            System.out.println("员工ID为1的leader未找到,他可能只是一个基层员工,不配拥有奖金");
        }
    }

    private Optional<Employee> getEmployeeById(Long id) {
        //return Optional.of(new Employee(1L, "大老板", Boolean.TRUE));
        return Optional.of(new Employee(1L, "大老板", Boolean.FALSE));
    }

    private Optional<Leader> getLeaderByEmployeeId(Long employeeId) {
        //return employeeId == 1L ? Optional.of(new Leader(1L, BigDecimal.valueOf(1000000000))) : Optional.empty();
        return employeeId == 1L ? Optional.of(new Leader(1L, null)) : Optional.empty();
    }
}

平时:

项目里的实例:

return Optional.ofNullable(iNewsMapper.selectNewsWithNewsCategoryById(id))
        .orElseThrow(() -> new BaseException(DataSourceResponseEnum.SELECT_ERROR));

ofNullable:

返回一个描述给定值的Optional ,如果不为null ,则返回一个空的Optional 。

orElseThrow

如果存在值,则返回该值,否则抛出由异常提供函数产生的异常。

以前的写法是:

if(iNewsMapper.selectNewsWithNewsCategoryById(id)==null){
    throw new BaseException(DataSourceResponseEnum.SELECT_ERROR);
}
else{
    return iNewsMapper.selectNewsWithNewsCategoryById(id);
}

这种写法是比较丑陋的,为了避免上述丑陋的写法,让丑陋的设计变得优雅。JAVA8提供了Optional类来优化这种写法。

例二:

  Optional<News> news = Optional.ofNullable(iNewsMapper.selectNewsWithNewsCategoryById(id));

        news.ifPresent(item -> {
            item.setLastId(this.selectLastNewsId(id));
            item.setNextId(this.selectNextNewsId(id));
            taskExecutor.execute(() -> this.addReadCount(id, ip));
        });
        return news.orElseThrow(() -> new BaseException(DataSourceResponseEnum.SELECT_ERROR));

博主自己第一次知道Optional,这次看项目的时候,正好遇上了就去好好的康了一番。

我的建议是:喜欢就用,不喜欢就不用。

用的话看起来是会显的更为优雅些,但是缺点也很明显,逻辑性没那么明显了。

到此这篇关于java新特性之Optional的详细解析的文章就介绍到这了,更多相关java中optional类详解内容请搜索程序员的世界以前的文章或继续浏览下面的相关文章希望大家以后多多支持程序员的世界!

java中Optional的使用详细解析的更多相关文章

  1. Java中Jackson快速入门

    Java生态圈中有很多处理JSON和XML格式化的类库,Jackson是其中比较著名的一个。虽然JDK自带了XML处理类库,但是相对来说比较低级,使用本文介绍的Jackson等高级类库处理起来会方便很多。引入类库由于Jackson相关类库按照功能分为几个相对独立的,所以需要同时引入多个类库,为了方便......

  2. 带你快速了解Java中类和对象的关系

    本文重点解读Java里的类和对象的关系1、首先介绍两个概念类:类是对现实生活中一类具有共同属性和行为事务的抽象,确定对象将会拥有的属性和行为。对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。概念比较抽象,我......

  3. 全面解析java final关键字

    根据上下文环境,Java 的关键字 final 的含义有些微的不同,但通常它指的是“这是不能被改变的”。防止改变有两个原因:设计或效率。因为这两个原因相差很远,所以有可能误用关键字 final。以下几节讨论了可能使用 final 的三个地方:数据、方法和类。1)final 数据对于编译时常量这种情况......

  4. java mybatis框架配置详解

    一个框架的使用,必然离不开其中的组件支持。我们在下载完mybatis框架后,因为大部分的内部结构还没有启动,就要手动的对其进行配置。在之前有提到,mybatis框架的作用就有数据库方面的,所以本篇文章带来了数据库和sql方面的配置方法,大家一起往下面看看具体操作。1.配置数据库创建mybatis的配......

  5. 如何讲清楚 Java 面向对象的问题与知识?(类与对象,封装,继承,多态,接口,内部类...)

    如何讲清楚 Java 面向对象的问题与知识?(类与对象,封装,继承,多态,接口,内部类...)写在最前面这个项目是从20年末就立好的 flag,经过几年的学习,回过头再去看很多知识点又有新的理解。所以趁着找实习的准备,结合以前的学习储备,创建一个主要针对应届生和初学者的 Java 开源知识项目,专注......

  6. java DelayQueue的原理浅析

    在对DelayQueue延迟功能的使用上,很多人不能后完全理解延迟的一些功能使用,这里我们深入来挖掘一下DelayQueue的原理。下面将从构造方法、接口、继承体系三个方面进行分析,需要注意的是,相较于其它的阻塞队列,DelayQueue因为延迟的功能多了接口的使用,一起来看具体内容。1.构造方法p......

  7. Java 并发工具类 CountDownLatch、CyclicBarrier、Semaphore、Exchanger

    本文部分摘自《Java 并发编程的艺术》CountDownLatchCountDownLatch 允许一个或多个线程等待其他线程完成操作。假设现有一个需求:我们需要解析一个 Excel 里多个 sheet 的数据,此时可以考虑使用多线程,每个线程解析一个 sheet 的数据,等到所有的 sheet ......

  8. java mybatis中使用大于小于等于的正确方法

    在mybatis中sql是写在xml映射文件中的,如果sql中有一些特殊字符的话,在解析xml文件的时候就会被转义,如若不希望被转义,那该怎么办呢?方法一:使用特殊转义字符例如,>=开始日期 并且<=结束日期> > 大于号 < < 小于......

  9. Java实现顺序表的增删查改功能

    创建顺序表在java语言中要实现顺序表,首先创建一个类,因为顺序表本身就像数组,所以我们这里定义一个int类型的数组和usedata为有效数据,构造方法里先申请可以存放10个数据的空间。public class MyArraylist1 {public int[] elem;//存储数据的有效个数p......

  10. Java中的深浅拷贝问题,你清楚吗?

    一、前言拷贝这个词想必大家都很熟悉,在工作中经常需要拷贝一份文件作为副本。拷贝的好处也很明显,相较于新建来说,可以节省很大的工作量。在Java中,同样存在拷贝这个概念,拷贝的意义也是可以节省创建对象的开销。Object类中有一个方法clone(),具体方法如下:protected native Ob......

随机推荐

  1. Java并发包源码学习系列:阻塞队列实现之SynchronousQueue源码解析

    目录SynchronousQueue概述 使用案例 类图结构 put与take方法 void put(E e) E take() Transfer 公平模式TransferQueue QNode transfer awaitFulfill tryCancel clean TransferQueue总......

  2. 如何在C#中使用只读的 Collections

    集合 表示一组可用于获取和存储的对象,在 C# 中提供了两种类型的集合。普通集合泛型集合前者存在于 System.Collections 命名空间下,属类型不安全的,后者存在于 System.Collections.Generic 命名空间下,属类型安全的。不可变对象 定义为一旦创建就不可变更的对象......

  3. python使用scapy模块实现ARP扫描的过程

    前言上篇文章主要写了利用scapy实现ping扫描,这篇文章主要是利用scapy模块实现内网ARP扫描实现过程上篇文章中介绍了通过scapy来伪造包,那么ARP包的伪造过程这里不再详述,说一工具的简单整体流程1.首先,实现单个IP的ARP包的发送和接收2.其次,实现多进程同时多个ARP包的发送和接收......

  4. Android实现摇一摇简单功能

    说起摇一摇大家可能就会想到微信的摇一摇功能。后来很多APP也跟着上了摇一摇的相关功能。这里我们就介绍一下摇一摇怎么做。步骤1:声明一个SensorManager对象步骤2:重写Activity的onResume方法,在该方法中注册传感器监听事件,并指定待监听的传感器类型。步骤3:重写Activity......

  5. PHP中PDO关闭连接的方法问题

    在之前我们手写 mysql 的连接操作时,一般都会使用 mysql_close() 来进行关闭数据库连接的操作。不过在现代化的开发中,一般使用框架都会让我们忽视了底层的这些封装,而且大部分框架都已经默认是使用 PDO 来进行数据库的操作,那么,大家知道 PDO 是如何关闭数据的连接的吗?官方说明要想......

  6. 讲讲Java8的Optional类

    前言Java 8中引入了 Optional 类来解决 NullPointerException 与繁琐的 null 检查,该类首次出现在 Guava。Java 8 才成为类库中的一部分。入门Optional 是一个封装值的类,用于保存类型为 T 的值;本质上,Optional 就是一个容器。举例来说......

  7. 如何使用Python进行PDF图片识别OCR

    使用场景 使用图片识别可以快速提取图片中的信息,方便高效。 Python并不能直接对PDF进行识别,所以如果是识别PDF的话,需要先将PDF转化为图片,然后再进行识别。 必备工具 Python 可以安装3.7及以上版本 tesseract-ocr......

  8. Java泛型

    你要做一个不动声色的大人了。不准情绪化,不准偷偷想念,不准回头看。去过自己另外的生活。你要听话,不是所有的鱼都会生活在同一片海里。 ——村上春树 《舞!舞!舞!》Q:什么是泛型?Ja......

  9. Python使用Protobuf&&如何赋值&&如何正反序列化

    此文主要是总结,python使用protobuf的过程,如何序列化和反序列化,对不同类型的字段如何进行赋值。前言使用protobuf主要是两个步骤,序列化和反序列化。关于Proto有哪些数据类型,然后如何编写,此处就不赘述了,百度一下有很多。此文主要是总结,python使用protobuf的过程,如......

  10. 基于C#的百度图片批量下载工具

    using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.IO; using Sys......