3.1_27 JavaSE-JDK8新特性 P3 【Optional容器类】处理null值

已于 2022-04-28 17:32:25 修改
阅读量764 收藏
点赞数
文章标签： 容器 jdk1.8
于 2022-01-14 12:17:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43529621/article/details/122329198
版权

相关链接

目录

数据准备

通过案例，使用Optional对模拟数据进行一系列处理，熟悉Optional各常用方法

1. pom.xml 配置文件  参考笔记 -> 六、lombok插件

    <dependencies>
       <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
    </dependencies>

2. Employee 实体类

package com.groupies.jdk8.day03.po;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction 员工类
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private Integer id;
    private String name;
    private Integer age;
    private Double salary;
}

3. OptionalService 服务类，提供初始化数据方法

package com.groupies.jdk8.day03.service;

import com.groupies.jdk8.day03.po.Employee;
import org.springframework.stereotype.Service;

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

@Service
public class OptionalService {
    /**
     * @return 初始化数据
     */
    public static List<Optional<Employee>> getEmployee() {
        //员工列表
        Employee employee3 = new Employee(null, "张三", 20, 6666.66D);
        Employee employee4 = new Employee(4, "赵四", 26, 3000D);
        Employee employee5 = new Employee(5, "王五", 55, 6000D);

        ArrayList<Optional<Employee>> list = new ArrayList<>();
        list.add(Optional.of(employee3));
        list.add(Optional.of(employee4));
        list.add(Optional.of(employee5));
        return list;
    }
}

1 概述

  Optional<T> 类（java.util.Optional）是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

  常用方法：

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 1 | Optional.of | 创建 Optional 类
静态方法，创建一个 Optional 实例 | T value |Optional<T>
| 2 | Optional.empty | 创建 Optional 类
静态方法，创建一个 Optional 空实例 | - |Optional<T>
| 3 | Optional.ofNullable | 创建 Optional 类
静态方法
1. 入参 T 为null， 创建 Optional 空实例
2. 入参 T 不为null，创建 Optional 实例 | T| Optional<T>
| 4 | get | 获取对象
对于 Optional<T> 对象，通过get方法可以得到 T
其中 T 不能为空，否则会抛出异常 java.util.NoSuchElementException | - | T
| 5 | isPresent | 是否为空
1. 调用对象为null， 返回 false
2. 调用对象不为null，返回 true | - | boolean
| 6 | ifPresent | 安全消费值
1. 调用对象为null， 什么都不做
2. 调用对象不为null，通过Consumer接口（消费型接口）对其进行消费 | Consumer<? extends T> | void
| 7 | orElse | 获取对象/指定值
1. 调用对象为null， 返回 T
2. 调用对象不为null，返回 调用对象

注意： 无论optional是否有值，orElse都会被执行| T| T 或
Object
| 8 | orElseGet | 获取对象/指定值
1. 调用对象为null， 返回 Supplier提供的返回值
2. 调用对象不为null，返回 调用对象

注意： 只有optional为空时，orElseGet才会被执行| Supplier<? extends T> | T 或
Supplier提供的返回值
| 9 | orElseThrow | 获取对象/指定值
1. 调用对象为null， 抛出 X 异常
2. 调用对象不为null，返回 调用对象

注意： 只有optional为空时，orElseThrow才会被执行| Supplier<? extends X> throws X|<X extends Throwable> T
| 10 | filter | 过滤
1. Predicate结果为true， 返回调用对象
2. Predicate结果为false，返回Optional.empty()| Predicate<? super T>|Optional<T> 或
Optional.empty();
| 11 | map | 转换
1. 调用对象为null， 返回 Optional.empty()
2. 调用对象不为null，通过Function接口（函数型接口）对其进行处理，返回 Optional<任意值> | Function<? super T, ? extends U> |Optional<U> 或
Optional.empty();
| 12 | flatMap | 转换
1. 调用对象为null， 返回 Optional.empty()
2. 调用对象不为null，通过Function接口（函数型接口）对其进行处理，返回 Optional<任意值> | Function<? super T, Optional<U>> |Optional<U>
map与flatMap的区别：
 1. 请求参数：
  map：  Function接口返回 任意类型 参数。
  flatMap：Function接口返回 Optional类型 参数。
 2. 返回值：
  map：  Function接口返回的参数，再 额外包装一层Optional。
  flatMap：Function接口返回参数。
 3. 结论： 简单理解，返回值类型为Optional<T>时使用flatMap，返回值为其他类型时使用map。

2 常用方法

案例1 Optional.of 创建实例

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 1 | Optional.of | 创建 Optional 类
静态方法，创建一个 Optional 实例 | T value |Optional<T>

案例代码一  Optional.of 创建实例

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.of
 */
public class Demo1OptionalOf {
    public static void main(String[] args) {
        Optional<Employee> opt = Optional.of(new Employee());
    }
}

案例2 Optional.empty 创建空实例

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 2 | Optional.empty | 创建 Optional 类
静态方法，创建一个 Optional 空实例 | - |Optional<T>

案例代码二  Optional.empty 创建空实例

package com.groupies.jdk8.day03.practice;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.empty
 */
public class Demo2OptionalEmpty {
    public static void main(String[] args) {
        Optional<Object> opt = Optional.empty();
    }
}

案例3 Optional.ofNullable 有则创建/无则empty()

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 3 | Optional.ofNullable | 创建 Optional 类
静态方法
1. 入参 T 为null， 创建 Optional 空实例
2. 入参 T 不为null，创建 Optional 实例 | T| Optional<T>
案例代码三  Optional.ofNullable 有则创建/无则empty()

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.ofNullable
 */
public class Demo3OptionalOfNullable {
    public static void main(String[] args) {
        //1. 入参 T 为null， 创建 Optional 空实例
        Employee emp1 = null;
        Optional<Object> opt1 = Optional.ofNullable(emp1);
        System.out.println(opt1);//Optional.empty

        //2. 入参 T 不为null，创建 Optional 实例
        Employee emp2 = new Employee();
        Optional<Object> opt2 = Optional.ofNullable(emp2);
        System.out.println(opt2);//Optional[Employee(id=null, name=null, age=null, salary=null)]
    }
}

案例4 get 获取对象

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 4 | get | 获取对象
对于 Optional<T> 对象，通过get方法可以得到 T
其中 T 不能为空，否则会抛出异常 java.util.NoSuchElementException | - | T

案例代码四  Optional.get 获取对象

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.get
 */
public class Demo4OptionalGet {
    public static void main(String[] args) {
		//对于 Optional<T> 对象，通过get方法可以得到 T
        Employee emp1 = new Employee();
        Optional<Object> opt1 = Optional.ofNullable(emp1);
        System.out.println(opt1.get());//Employee(id=null, name=null, age=null, salary=null)

		//其中 T 不能为空，否则会抛出异常 java.util.NoSuchElementException
        Employee emp2 = null;
        Optional<Object> opt2 = Optional.ofNullable(emp2);
        System.out.println(opt2.get());//Exception in thread "main" java.util.NoSuchElementException: No value present
    }
}

案例5 isPresent 是否为空

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 5 | isPresent | 是否为空
1. 调用对象为null， 返回 false
2. 调用对象不为null，返回 true | - | boolean

案例代码五  Optional.isPresent 是否为空

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.isPresent
 */
public class Demo5OptionalIsPresent {
    public static void main(String[] args) {
        //1. 调用对象为null，返回 false
        Optional<Object> opt1 = Optional.empty();
        System.out.println(opt1.isPresent());//false

        //2. 调用对象不为null，返回 true
        Optional<Object> opt2 = Optional.ofNullable(new Employee());
        System.out.println(opt2.isPresent());//true
    }
}

案例6 ifPresent 有则Consumer/无则跳过

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 6 | ifPresent | 安全消费值
1. 调用对象为null， 什么都不做
2. 调用对象不为null，通过Consumer接口（消费型接口）对其进行消费 | Consumer<? extends T> | void
案例代码六  Optional.ifPresent 有则Consumer/无则跳过

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.ifPresent
 */
public class Demo6OptionalIfPresent {
    public static void main(String[] args) {
        //1. 调用对象为null，什么都不做
        Optional<Object> opt1 = Optional.empty();
        opt1.ifPresent(o -> System.out.println(o + " 来消费了"));//

        //2. 调用对象不为null，通过Consumer接口（消费型接口）对其进行消费
        Optional<Object> opt2 = Optional.ofNullable(new Employee());
            //Employee(id=null, name=null, age=null, salary=null) 来消费了
        opt2.ifPresent(o -> System.out.println(o + " 来消费了"));
    }
}

案例7 orElse 有则获取/无则Object

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 7 | orElse | 获取对象/指定值
1. 调用对象为null， 返回 T
2. 调用对象不为null，返回 调用对象

注意： 无论optional是否有值，orElse都会被执行| T| T 或
Object
案例代码七  Optional.orElse 有则获取/无则Object

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.orElse
 */
public class Demo7OptionalOrElse {
    public static void main(String[] args) {
        //1. 调用对象为null，返回 T
        Optional<Object> opt1 = Optional.empty();
        Object o1 = opt1.orElse(function());
        System.out.println(o1);//function方法执行了：0

        //2. 调用对象不为null，返回 调用对象
        Optional<Object> opt2 = Optional.of(new Employee());
        Object o2 = opt2.orElse(function());
        System.out.println(o2);//function方法执行了：Employee(id=null, name=null, age=null, salary=null)
    
        //3. orElse也可以直接传入Object类型参数
        Object o = opt2.orElse(0);
    }
	
	//注意： 无论optional是否有值，orElse都会被执行
    public static Object function() {
        System.out.print("function方法执行了：");
        return 0;
    }
}

案例8 orElseGet 有则获取/无则Supplier

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 8 | orElseGet | 获取对象/指定值
1. 调用对象为null， 返回 Supplier提供的返回值
2. 调用对象不为null，返回 调用对象

注意： 只有optional为空时，orElseGet才会被执行| Supplier<? extends T> | T 或
Supplier提供的返回值

案例代码八  Optional.orElseGet 有则获取/无则Supplier

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.orElseGet
 */
public class Demo8OptionalOrElseGet {
    final private static Employee admin = new Employee(0, "Administrator", 0, 0d);

    public static void main(String[] args) {
        //1. 调用对象为null，返回 T
        Optional<Object> opt1 = Optional.empty();
        System.out.println(opt1.orElseGet(() -> {
            System.out.print("Optional对象为空===");
            return admin;
        }));//Optional对象为空===Employee(id=0, name=Administrator, age=0, salary=0.0)

        //2. 调用对象不为null，返回 调用对象
        Optional<Object> opt2 = Optional.of(new Employee());
        System.out.println(opt2.orElseGet(() -> {
            System.out.println("Optional对象为空");
            return admin;
        }));//Employee(id=null, name=null, age=null, salary=null)
    }
}

案例9 orElseThrow 有则获取/无则异常

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 9 | orElseThrow | 获取对象/指定值
1. 调用对象为null， 抛出 X 异常
2. 调用对象不为null，返回 调用对象

注意： 只有optional为空时，orElseThrow才会被执行| Supplier<? extends X> throws X|<X extends Throwable> T
案例代码九  Optional.orElseThrow 有则获取/无则异常

package com.groupies.jdk8.day03.practice;
import com.groupies.jdk8.day03.po.Employee;
import java.util.Optional;
import java.util.function.Supplier;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.orElseThrow
 */
public class Demo9OptionalOrElseThrow {
    public static void main(String[] args) throws Throwable {
        //2. 调用对象不为null，返回 调用对象
        Optional<Object> opt2 = Optional.of(new Employee());
        System.out.println(opt2.orElseThrow((Supplier<Throwable>) () -> {
            System.out.print("orElseThrow方法执行了：");
            return new RuntimeException("Optional对象不能为空");
        }));//Employee(id=null, name=null, age=null, salary=null)

        //1. 调用对象为null，返回 T
        Optional<Object> opt1 = Optional.empty();
        System.out.println(opt1.orElseThrow((Supplier<Throwable>) () -> {
            System.out.print("orElseThrow方法执行了：");
            return new RuntimeException("Optional对象不能为空");
        }));//orElseThrow方法执行了：Exception in thread "main" java.lang.RuntimeException: Optional对象不能为空
    }
}

案例10 filter 过滤

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 10 | filter | 过滤
1. Predicate结果为true， 返回调用对象
2. Predicate结果为false，返回Optional.empty()| Predicate<? super T>|Optional<T> 或
Optional.empty();
需求： 过滤 id不为null 的员工，并打印

处理前：

Optional[Employee(id=null, name=张三, age=20, salary=6666.66)]
Optional[Employee(id=4, name=赵四, age=26, salary=3000.0)]
Optional[Employee(id=5, name=王五, age=55, salary=6000.0)]

处理后：

Optional.empty
Optional[Employee(id=4, name=赵四, age=26, salary=3000.0)]
Optional[Employee(id=5, name=王五, age=55, salary=6000.0)]

案例代码十  filter 过滤

package com.groupies.jdk8.day03.practice;

import com.groupies.jdk8.day03.po.Employee;
import com.groupies.jdk8.day03.service.OptionalService;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction
 */
public class Demo10OptionalFilter {
    @Autowired
    private static OptionalService optionalService;

    public static void main(String[] args) {
        List<Optional<Employee>> list = optionalService.getEmployee();
        System.out.println("=====处理前=====");
        list.forEach(System.out::println);

        List<Optional<Employee>> collect = list.stream()
                //如果Optional<Employee>中Employee的id为空,则返回Optional.empty
                .map(optional -> optional.filter(employee -> employee.getId() != null))
                .collect(Collectors.toList());

        System.out.println("=====处理后=====");
        collect.forEach(System.out::println);
    }
}

案例11 map 任意类型 转为 Optional

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 11 | map | 转换
1. 调用对象为null， 返回 Optional.empty()
2. 调用对象不为null，通过Function接口（函数型接口）对其进行处理，返回 Optional<任意值> | Function<? super T, ? extends U> |Optional<U> 或
Optional.empty();
案例代码十一  Optional.map 任意类型 转为 Optional

package com.groupies.jdk8.day03.practice;
import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.map
 */
public class Demo11OptionalMap {
    public static void main(String[] args) {
        Optional<Object> opt = Optional.of("abc");
        Optional<Integer> res1 = opt.map((o) -> 5);
        Optional<Optional<Integer>> res2 = opt.map((o) -> Optional.of(5));
        System.out.println(res1);//Optional[5]
        System.out.println(res2);//Optional[Optional[5]]
    }
}

案例12 flatMap Optional 转为 Optional

|id| 方法名 | 方法作用 | 请求参数 |返回值类型 |
|:–|:–|:–|:–|:–|:–|
| 12 | flatMap | 转换
1. 调用对象为null， 返回 Optional.empty()
2. 调用对象不为null，通过Function接口（函数型接口）对其进行处理，返回 Optional<任意值> | Function<? super T, Optional<U>> |Optional<U>
案例代码十二  Optional.flatMap Optional 转为 Optional

package com.groupies.jdk8.day03.practice;

import java.util.Optional;

/**
 * @author GroupiesM
 * @date 2022/01/12
 * @introduction Optional.filter
 */
public class Demo12OptionalFlatMap {
    public static void main(String[] args) {
        Optional<Object> opt = Optional.of("abc");
        Optional<Integer> res = opt.flatMap((o) -> Optional.of(5));
        System.out.println(res);//Optional[5]
    }
}

22/01/14

M

GroupiesM
关注
JDK8-Java8-JavaSE8新特性和增强功能-第一部
06-18
熟悉JDK8新特性和库对Android开发(基于Java语言)更加得心应手。 5. 熟悉JDK8新特性能方便进行Java底层开发,比如Spring MVC. 6. IDE目前基于轻便的VSCode开发说明, 也可以自行通过IDEAJ建立项目运行。
JavaSE--jdk-8u25-linux-x64.rar
11-18
6. **Optional类**：一个容器对象，可能包含或者不包含非null值。设计目的是为了防止NullPointerException，鼓励更清晰的代码编写。 7. **新的类型接口**：例如java.util.function包中的函数式接口，如Predicate、...
Optional用法与争议点
fm18771120556的博客
11-06 409
要说Java中什么异常最容易出现，我想NullPointerException一定当仁不让，为了解决这种null值判断问题，Java8中提供了一个新的工具类Optional，用于提示程序员注意null值，并在特定场景中简化代码逻辑。
Java8新特性之consumer的用法
热门推荐
qq_36893229的博客
02-10 1万+
consumer是一个函数式接口（可以采用lambda写法），它的源码如下 @FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after); return (T t) -&
java增效系列—jdk8新特性之Optional优雅处理null值情况
qq_45740561的博客
07-18 549
Optional 三种创建optional对象方式 public void test01(){ // 1.创建空optional Optional.empty(); // 2.使用非null值创建optional对象，使用null会报错 Optional.of("test"); // 3.可以使用任意值创建 Optional.ofNullable(null); } 正常引用和引用缺失情况下的使用 public void test01() { Op
使用Java 8 Optional避免空指针异常
weixin_34354173的博客
01-11 338
Optional可以让你的代码具有可读性，且会避免出现空指针异常。 都说没有遇到过空指针异常的程序员不是Java程序员，null确实引发过很多问题。Java 8中引入了一个叫做java.util.Optional的新类可以避免null引起的诸多问题。 我们看看一个null引用能导致哪些危害。首先创建一个类Computer，结构如下图所示: Computer类模型 当我们调用如下代码会怎样？ S...
3.1_24 JavaSE-JDK8新特性
GroupiesM的博客
02-11 225
目录
3.1_28_1 JDK8新特性【Date】之DayOfWeek 星期枚举
GroupiesM的博客
02-11 1085
5. 新API详解 id=2 DayOfWeek 星期枚举
3.1_28_4 JDK8新特性【Date】之ZoneId 时区信息
GroupiesM的博客
02-11 921
5. 新API详解 id=16 ZoneId 时区信息
3.1_28_5 JDK8新特性【Date】之ChronoField 时间结界
GroupiesM的博客
02-10 986
5. 新API详解 id=24 ChronoField 时间结界
3.1_28_3 JDK8新特性【Date】之ChronoUnit 时间单位枚举
GroupiesM的博客
02-11 601
5. 新API详解 id=14 ChronoUnit 时间单位枚举
JDK7-Java7-JavaSE7新特性和增强功能-第一部
06-18
熟悉JDK7新特性和库对Android开发(基于Java语言)更加得心应手。 5. 熟悉JDK7新特性能方便进行Java底层开发,比如Spring MVC. 6. IDE目前基于轻便的VSCode开发说明, 也可以自行通过IDEAJ建立项目运行。
jdk1.8 java官网正式版Windows 64位-jdk-8u202-windows-x64.exe
11-27
JDK 1.8引入了许多重要的新特性，提升了开发效率和程序性能。其中最显著的是Lambda表达式，这是一种函数式编程的概念，使得开发者能够更简洁地处理集合数据和并行操作。此外，新添加的Stream API简化了对集合对象的...
Jdk8下载(附：官网下载地址)
03-07
7. **Optional类**：为了解决null引用的问题，Java 8引入了`Optional`类，它是一个容器对象，可能包含或不包含非null值。如果值存在则`isPresent()`返回true，调用`get()`会返回该对象。 8. **类型推断的改进**：...
k8s中的层级结构，及节点组件的作用
2401_84019227的博客
09-06 2911
这五个是资源文件里面的顶级字段，最后一个status状态大部分情况下可以不写，在创建资源的时候。有各个被管理k8s集群的名称，管理用户，集群的证书cacert，客户端的证书cert，客户端的密钥key，等这些信息。这个配置文件里面有client主机想kubectl config操作的k8s集群的信息。controller-manager可以认为是一些程序的集合，也有对应的配置文件。控制器的作用也是为了实现k8s集群的各个品类的功能的需求的满足。那么这些api资源都是为了让k8s更好的提供容器化服务的工具。
weixin021基于JAVA微信点餐小程序设计+ssm.rar
最新发布
09-13
所有源码，都是可以运行起来的
基于深度神经网络的模型预测控制器(mpc-DL-controller).zip
09-13
该项目旨在开发一种基于深度神经网络（DNN）的预测最优控制器，用于对受干扰的系统（包括HVAC、太阳能电池和电池）进行控制。传统的模型预测控制（MPC）虽然广泛应用于化工、炼油厂和电力系统等行业，但在处理大量数据和实现快速实时控制方面面临挑战。利用深度神经网络的优势，本研究模拟了一种线下最优控制方案，通过对HVAC系统与电网、电池和太阳能电池板的连接进行模拟，训练一个深度神经网络（包含六层，每层五十个单元），以实现无需显式控制计算或指令的MPC控制。该项目的实施展示了深度学习和模型预测控制相结合在复杂系统中的潜力。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看READMe.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
Serial ATA revistion3.2 protocal SATA 3.2 协议 protocal
09-13
Serial ATA revistion3.2 protocal SATA 3.2 协议 protocal
https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html
03-16
这是Oracle官网上Java SE 8的下载页面，其中提供了Java SE 8开发工具包（JDK）和Java SE 8运行时环境（JRE）的下载链接。用户可以根据自己的需要选择不同的平台和版本进行下载安装。注意，Java SE 8已经不再接收免费...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值