(超级详细)JAVA之Stream流分析-------持续更新喔！！！

学习目标：

  • 掌握 Java Stream流的相关api
  • 掌握 Java Stream流的基本实现
  • 掌握 java Stream流的使用场景
  • 代码已经整理上传到了gitee中，有需要的小伙伴可以取查看一下源码点个小心心喔

大家也可以帮我提交一点案例喔！！！！！
大家一起交流学习！
https://gitee.com/Aoyuan-210902/JAVAStreamDemo.git

点个赞嘛！！！！！！！！！！！！！！！！！！！！！！！！！
在这里插入图片描述

JAVA Stream流

概述

Java Stream API 是 Java 8 中引入的一个功能强大的新库，它提供了一种高效且声明式的处理数据集合的方法。通过使用 Streams，开发者可以写出简洁且易于理解的代码，用于对数据执行复杂的查询和聚合操作。

什么是Stream流，Stream流的特点是什么？

  • 含义
    在 Java 中，Stream 是对集合（Collection）对象功能的一个补充，它支持顺序和并行的聚集操作。Streams 不存储数据，它们只在需要时从源（如集合或数组）中获取数据。

  • 主要特点
    声明式：相比于传统的迭代方式，stream 提供了一种声明式的方法来表达数据处理任务。
    可组合：stream 操作可以链接起来，形成一个大的流水线，这样可以表达复杂的数据处理策略（比如筛选，排序等）。
    并行能力：Streams 可以透明地并行处理，利用多核架构而无需编写特定的多线程代码。

常见操作

Stream 操作分为中间操作和终端操作两种：

中间操作：如 filter、map、sorted 等，它们返回一个新的 Stream，可以连接多个中间操作。
终端操作：如 forEach、collect、reduce 等，它们输出结果或者产生副作用（例如输出到屏幕），并且关闭 Stream。

一些Stream的特性

  • 函数式编程： 通过Stream流可以代替复繁琐难懂的for循环等代码，对数据进行操作。
  • Stream流不会直接得出结果，而是在调用终端操作的时候，才会运行中间操作。

Optional类

在Java中，Optional是一个容器类，它可以包含也可以不包含非空值。Optional类主要用于防止NullPointerException异常的发生，它提供了一种更优雅的方法来处理可能为null的对象。使用Optional可以显式地要求调用者处理空值情况。

Optional提供了多种方法来检查、获取和转换包含的值：

isPresent()：检查Optional是否有值。
get()：获取Optional的值，如果Optional为空，则抛出NoSuchElementException。
orElse()：如果Optional有值则返回该值，否则返回传递给orElse的参数。
ifPresent()：如果值存在，执行给定的操作。 map()和flatMap()：对Optional的值应用函数。
Optional常用于新的Java API中，如Stream的终端操作，返回一个Optional类型的结果

。

Stream流的操作

distinct

package distinctStream;

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

public class DistincrtStrream {
    public static void main(String[] args) {
        //distint主要是去除掉集合中重复的代码
        List<Integer> list = Arrays.asList(1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6);
        List<Integer> collect = list.stream().distinct().collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
}
运行实例

在这里插入图片描述

filter筛选操作

示例1

package filterStream;

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

public class FilterDemo01 {
    //找到集合中元素大于5的数
    public static void main(String[] args) {
        List<Integer> demo01 = new ArrayList<>();
        demo01.add(1);
        demo01.add(5);
        demo01.add(7);
        demo01.add(8);
        demo01.add(9);
        System.out.println("没有进行筛选之前的数据");

        demo01.forEach(System.out::println);
        System.out.println("筛选之后的数据");
        demo01.stream().filter(x -> x > 5).forEach(System.out::println);
    }
}

在这里插入图片描述
示例2

package filterStream;

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

public class FilterDemo02 {
    public String username;
    public String password;

    public FilterDemo02() {
    }

    public FilterDemo02(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "FilterDemo02{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public static void main(String[] args) {
        FilterDemo02 user01 = new FilterDemo02("aoyuan","123");
        FilterDemo02 user02 = new FilterDemo02("yuan","234");
        FilterDemo02 user03 = new FilterDemo02("ao","345");

        List<FilterDemo02> list  = new ArrayList<>();
        list.add(user01);
        list.add(user02);
        list.add(user03);
        //查找username = aoyuan的
        List<FilterDemo02> collect = list.stream().filter(n -> n.getUsername().equals("aoyuan")).collect(Collectors.toList());
        collect.forEach(System.out::println);
                System.out.println("------------------------------------------------------------------------------");

         //查找username =ao
         List<FilterDemo02> collect01 = list.stream().filter(n -> n.getUsername().equals("ao")).collect(Collectors.toList());
         collect01.forEach(System.out::println);
        System.out.println("------------------------------------------------------------------------------");
         List<FilterDemo02> collect02 = list.stream().filter(n -> n.getPassword() != "123").collect(Collectors.toList());
         collect02.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述

limit截取操作

示例1

package limitStream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class LimitDemo01 {
    public static void main(String[] args) {
        //limit是截取第n个元素
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        Stream<Integer> limit1 = list.stream().limit(2);
        Stream<Integer> limit2 = list.stream().limit(6);
        System.out.println("----------------截取第2个---------------");
        limit1.forEach(System.out::println);
        System.out.println("-----------------截取6个---------------------");
        limit2.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述
示例2

package limitStream;

import java.util.stream.Stream;

public class LimitDemo02 {
    public static void main(String[] args) {
        //interage迭代器会一直进行下去，所以由inerate创建的流是无限流，需要limit方法截断
        Stream<Integer> demo03 = Stream.iterate(0, n -> n+2).limit(6);
        demo03.forEach(System.out::println);
        System.out.println("limit起到了什么作用呢？起到了截断的作用");
        Stream<Integer>  demo04 = Stream.iterate(0,n -> n+2).limit(7);
        demo04.forEach(System.out::println);
        System.out.println("generate方法");
        //generate方法
        Stream<Double> generateStream = Stream.generate(Math::random).limit(5);
        generateStream.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述

map映射操作

User类

package mapStream;

public class User {
    private String username;
    private Integer id;
    private String address;

    public User() {
    }

    public User(String username, Integer id, String address) {
        this.username = username;
        this.id = id;
        this.address = address;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", id=" + id +
                ", address='" + address + '\'' +
                '}';
    }
}

userdao类

package mapStream;

public class UserDao {
    private String username;
    private String address;

    public UserDao() {
    }

    public UserDao(String username, String address) {
        this.username = username;
        this.address = address;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "UserDao{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

示例1

package mapStream;

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

public class FilterDemo01 {
    public static void main(String[] args) {

        List<User>  userList= new ArrayList<>();
        userList.add(new User("aoyuan",1,"baotou"));
        userList.add(new User("aoyuan01",2,"bao"));
        userList.add(new User("aoyuan02",3,"tou"));
        //拿到用户集合中的数据并将用户名转化为大写
        List<String> collect = userList.stream().map(x -> x.getUsername().toUpperCase()).collect(Collectors.toList());
        collect.forEach(System.out::println);
       //拿到user集合选择数据存储在新的userDao集合中
        List<UserDao> collect1 = userList.stream().map(x -> {
            UserDao userDao = new UserDao();
            userDao.setUsername(x.getUsername());
            userDao.setAddress(x.getAddress());
            return userDao;
        }).collect(Collectors.toList());
        collect1.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述
示例2

package mapStream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterDmeo02 {
    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> collect = list.stream().map(x -> x + 3).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }



}
运行示例

在这里插入图片描述

取max和min的相关操作

示例1

package maxStream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Demo {
    public static void main(String[] args) {
        //自定义排序
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        //从大到小排序
        Optional<Integer> max = list.stream().max((o1, o2) -> o1 - o2);
        System.out.println("最大值为+"+ max.get());

    }
}

运行示例

在这里插入图片描述

示例2

package maxStream;

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

public class Demo01 {
    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Optional<Integer> max = list.stream().max(Integer::compareTo);
        System.out.println("最大值为+："+ max);



    }
}

运行示例

在这里插入图片描述

示例3

package maxStream;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

public class Demo02 {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("aoyuan", "aoyuanao", "aoyuanaoyuan");
        Optional<String> max = strings.stream().max(Comparator.comparing(String::length));
        System.out.println("最长的字符串为" + max);
    }



}

运行示例

在这里插入图片描述
示例3

package minStream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class StreamMinExample01 {
    static class Person {
        String name;
        int age;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        int getAge() {
            return age;
        }

        @Override
        public String toString() {
            return name + ": " + age;
        }
    }

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 22),
                new Person("Bob", 20),
                new Person("Charlie", 30),
                new Person("David", 25)
        );


        Optional<Person> youngest = people.stream().min((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()));


        youngest.ifPresent(person -> System.out.println("The youngest person is " + person));
    }
}

运行示例

在这里插入图片描述

示例4

package minStream;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class StreamMinExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, -1, 6, 7);

        // Using Stream.min() to find the minimum value in the list
        Optional<Integer> minNumber = numbers.stream()
                .min(Integer::compare);

        // Checking and displaying the minimum number
        if (minNumber.isPresent()) {
            System.out.println("The minimum number is " + minNumber.get());
        } else {
            System.out.println("List is empty.");
        }
    }
}

运行示例

在这里插入图片描述

reduce归约

package reduce;

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

public class ReduceStreamDemo {

    public static void main(String[] args) {
        List<Integer> demo = new ArrayList<>();
        demo.add(2);
        demo.add(4);
        demo.add(1);
        demo.add(5);
//x+y的和
        Optional<Integer> reduce = demo.stream().reduce((x, y) -> x + y);
        System.out.println(reduce.get());
        //求最大值
        Optional<Integer> reduce1 = demo.stream().reduce((x, y) -> x > y ? x : y);
        System.out.println(reduce1.get());

    }
}
运行示例

在这里插入图片描述

排序

示例1

package sortStream;

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

public class StreamSortExample {
    static class Person {
        String name;
        int age;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        String getName() {
            return name;
        }

        @Override
        public String toString() {
            return name + ": " + age;
        }
    }

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 22),
                new Person("Charlie", 30),
                new Person("David", 25),
                new Person("Bob", 20)
        );


        List<Person> sortedPeople = people.stream()
                .sorted((p1, p2) -> p1.getName().compareTo(p2.getName()))
                .collect(Collectors.toList());

                sortedPeople.forEach(System.out::println);



    }
}
运行示例

在这里插入图片描述

示例2

package sortStream;

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

public class StreamSortExample02 {
    static class Person {
        String name;
        int age;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        int getAge() {
            return age;
        }

        public String getName() {
            return name;
        }

        @Override
        public String toString() {
            return name + ": " + age;
        }
    }

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 22),
                new Person("Charlie", 30),
                new Person("David", 25),
                new Person("Bob", 20)
        );

        // Sorting people by age using Stream
        List<Person> sortedByAge = people.stream()
                //自然排序
                .sorted((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()))
                .collect(Collectors.toList());

        // Displaying the sorted list
        sortedByAge.forEach(System.out::println);
        System.out.println("------------------自定义排序--------------");
        //先根据年龄再根据姓名排序
        List<Person> collect = people.stream().sorted((p1, p2) -> {
            if (p1.getAge() == p2.getAge()) {
                return p1.getName().compareTo(p2.getName());
            } else {
                return p2.getAge() - p1.getAge();
            }

        }).collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
}
运行示例

在这里插入图片描述

总结

作用场景

Java Stream API 是用于处理集合和数据库的理想选择，它能够执行如排序、过滤或映射数据等聚合操作。Stream 支持并行处理，使得它能够有效地处理大型数据集。此外，Stream 在处理数据序列时能增强代码的可读性和减少样板代码，使编程更加表达和简洁。它在 Java 中的函数式编程模式中尤为有价值，帮助以声明方式操作集合。

优势和不足

优势
  1. 提高代码可读性和简洁性：通过流式表达式，可以用更少的代码完成复杂的集合处理，使代码更易于理解和维护。
  2. 支持并行处理：Stream API 设计支持并行执行，可以很容易地对数据进行并行处理，提高处理效率，尤其适用于处理大数据量。
  3. 函数式编程：支持函数式编程风格，有助于减少副作用，使程序更加稳定。
不足
  1. 性能开销：相对于传统的 for-loop，Stream 操作可能引入更多的性能开销，尤其是在小数据量或高性能场景中。
  2. 学习曲线：对于初学者，Stream API 的一些操作和概念可能比较难以理解，需要一定的学习投入。
  3. 调试困难：由于 Stream 操作的链式结构，调试可能比较复杂，特别是在流水线操作中定位问题可能比较困难。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/568287.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

水平越权，垂直越权

水平越权，垂直越权

水平越权和垂直越权 水平越权 首先自己创建一个账号 然后在自己的修改密码&#xff0c;抓包&#xff0c;修改用户名等 但一般都会固定&#xff0c;它会固定当前用户名 垂直越权 不用登录就可以删除 当我们复制管理员的删除地址&#xff0c;然后访问它 它会跳出登录地址&#…
阅读更多...
美国签证证件照规格要求（51mm*51mm）

美国签证证件照规格要求（51mm*51mm）

美国签证证件照规格要求&#xff08;51mm*51mm&#xff09;
阅读更多...
解码数据世界：统计学入门与应用指南

解码数据世界：统计学入门与应用指南

引言 统计学可以被定义为研究数据的科学&#xff0c;它涉及到数据的收集、分析、解释和呈现。其目标是从数据中提取有意义的信息&#xff0c;并使用这些信息来做出推断与决策。 统计学主要分别以下几个主要领域&#xff1a; 描述性统计&#xff1a;使用图表、图形和其他工具…
阅读更多...
计算二维主应力的前端界面

计算二维主应力的前端界面

<!DOCTYPE html> <html> <head> <title>二维主应力</title> </head> <body> <h2>计算二维主应力</h2> <form> <label for"input1">σ_1(Mpa):</label> <input type"t…
阅读更多...
【数据结构】stack queue —— 栈和队列

【数据结构】stack queue —— 栈和队列

前言 这阵子一直在学数据结构&#xff0c;知识点消化地有点慢导致博客一直没写&#xff0c;现在总算是有时间歇下来补补前面落下的博客了。从现在起恢复周更&#xff0c;努努力一周两篇也不是梦……闲话少说&#xff0c;今天就让我们一起来认识栈和队列 1. 栈的介绍和使用 栈…
阅读更多...
《HCIP-openEuler实验指导手册》1.4 Apache MPM工作模式调整

《HCIP-openEuler实验指导手册》1.4 Apache MPM工作模式调整

MPM介绍 二、配置步骤 查看MPM当前工作模式 方法一&#xff1a; httpd -M | grep mpm方法二&#xff1a; 浏览器访问&#xff1a;http://IP:端口/server-status 方法三&#xff1a; cat /etc/httpd/conf.modules.d/00-mpm.conf查看 LoadModule mpm_event_module modules/mo…
阅读更多...
C语言 字符类型

C语言 字符类型

下面 我们来说字符类型 我们来看这个 保险单 金额 和 总额 都可以用数字类型 而性别则需要字符型 字符数据的存储 – ASCI码 字符类型 char 就是专为存储字符(如字母&#xff0c;标点和数字)而设计的类型。 使用单引号包含单个字符或转义字符去表示一个 char 类型的常量。 …
阅读更多...
371D - Vessels

371D - Vessels

思路&#xff1a;用并查集维护&#xff0c;如果当前容器没有满&#xff0c;就指向自己&#xff0c;否则指向下一个容器。 这样就可以快速 find 到下一个没有满的容器&#xff0c;从而模拟询问 1。 代码&#xff1a; void solve(){int n;cin >> n;vector<int>p(n …
阅读更多...
JRT1.5发布演示

JRT1.5发布演示

JRT1.5演示视频 这是一次思想的解放&#xff0c;这是一次自我的挑战&#xff0c;这是一次涅槃重生。信创、安可、Linux、麒麟、UOS、King、PGSQL、ARM、Java围绕在我周围。JRT在DotNetCore的基础上完成了重生。对我而言&#xff0c;它不仅仅是一套框架那么简单&#xff1b;它更…
阅读更多...
探索嵌入式系统：快速入门指南概览

探索嵌入式系统：快速入门指南概览

✨✨ 欢迎大家来访Srlua的博文&#xff08;づ&#xffe3;3&#xffe3;&#xff09;づ╭❤&#xff5e;✨✨ &#x1f31f;&#x1f31f; 欢迎各位亲爱的读者&#xff0c;感谢你们抽出宝贵的时间来阅读我的文章。 我是Srlua小谢&#xff0c;在这里我会分享我的知识和经验。&am…
阅读更多...
【数据结构（邓俊辉）学习笔记】向量03——常规向量

【数据结构（邓俊辉）学习笔记】向量03——常规向量

文章目录 0.概述1.元素访问2.置乱器3.判等器与比较器4.无序查找4.1 判等器4.2 顺序查找4.3 实现4.4 复杂度 5. 插入5.1 算法实现5.2 复杂度分析 6. 删除6.1 区间删除6.2 单元删除6.3 复杂度 7. 唯一化7.1 实现7.2 正确性7.3 复杂度 8. 遍历8.1 实现8.2 复杂度 9. 总结 0.概述 …
阅读更多...
CUDA线程管理

CUDA线程管理

核函数在主机端启动时&#xff0c;执行会转移到设备上&#xff0c;并且将控制权转移回主机。当核函数在GPU上运行时&#xff0c;主机可以运行其他函数。因此&#xff0c;主机与核函数是异步的。 此时&#xff0c;设备端也就是GPU上会产生大量的线程&#xff0c;并且每个线程都…
阅读更多...
手势估计 | 使用TensorRT实现的实时手势估计+手势分类

手势估计 | 使用TensorRT实现的实时手势估计+手势分类

项目应用场景 面向手势识别场景&#xff0c;项目具有实时手势识别 手势分类功能&#xff0c;采用 TensorRT 进行 GPU 加速推理&#xff0c;可通过手势识别进行远程控制。 项目效果 项目细节 > 具体参见项目 README.md (1) 安装依赖 git clone https://github.com/NVIDIA-…
阅读更多...
初入单元测试

初入单元测试

单元测试&#xff1a;针对最小的功能单元(方法)&#xff0c;编写测试代码对其进行正确性测试 Junit可以用来对方法进行测试&#xff0c;虽然是有第三方公司开发&#xff0c;但是很多开发工具已经集成了&#xff0c;如IDEA。 Junit 优点&#xff1a;可以灵活的编写测试代码&am…
阅读更多...
2024年Java接单平台强力推荐！各个都知名！

2024年Java接单平台强力推荐！各个都知名！

Java这几年真卷飞了&#xff0c;一点都不夸张。因此&#xff0c;很多程序员朋友都已经试着转方向、换赛道了。试着接单、找私活就是一大途径。当然&#xff0c;特别是有技术、又有相对空闲时间的朋友&#xff0c;更值得一试。既是增加收入的捷径&#xff0c;又可以提升自我——…
阅读更多...
SQL Server 中语句显示红色波浪线，提示对象/列名无效解决方法（无其他任何显式错误的情况）

SQL Server 中语句显示红色波浪线，提示对象/列名无效解决方法（无其他任何显式错误的情况）

拼写 名称等都没有出现任何错误时&#xff0c;依旧报错&#xff1a;对象/列名无效 解决步骤&#xff1a; 工具-选项-文本编辑器-Transact-SQL-IntelliSense重新勾选 启用 IntelliSense或者将 最大脚本大小改为 无限制 当然 工具卡了也可能会失效&#xff0c;进行 刷新 保存 或…
阅读更多...
智慧安防视频监控EasyCVR视频汇聚平台无法自动播放视频的原因排查与解决

智慧安防视频监控EasyCVR视频汇聚平台无法自动播放视频的原因排查与解决

国标GB28181协议EasyCVR安防视频监控平台可以提供实时远程视频监控、视频录像、录像回放与存储、告警、语音对讲、云台控制、平台级联、磁盘阵列存储、视频集中存储、云存储等丰富的视频能力&#xff0c;平台支持7*24小时实时高清视频监控&#xff0c;能同时播放多路监控视频流…
阅读更多...
开源大模型Llama3，堪比GPT-4。手把手本地安装，纯小白可操作，不需要编程经验，国内可下载，可视化使用。

开源大模型Llama3，堪比GPT-4。手把手本地安装，纯小白可操作，不需要编程经验，国内可下载，可视化使用。

最近最劲爆科技动态&#xff0c;Meta开源Llama3模型&#xff0c;最强开源模型。 Llama3发布后&#xff0c;扎克伯格亲自给媒体表示“要超越所有人&#xff0c;做最领先AI”。 吴恩达等一众大佬表示祝贺。 在线体验地址&#xff1a;https://www.meta.ai/ 不过国内在线体验基本…
阅读更多...
【服务器部署篇】Linux下Ansible安装和配置

【服务器部署篇】Linux下Ansible安装和配置

作者介绍&#xff1a;本人笔名姑苏老陈&#xff0c;从事JAVA开发工作十多年了&#xff0c;带过刚毕业的实习生&#xff0c;也带过技术团队。最近有个朋友的表弟&#xff0c;马上要大学毕业了&#xff0c;想从事JAVA开发工作&#xff0c;但不知道从何处入手。于是&#xff0c;产…
阅读更多...
MySQL的root用户无法远程连接

MySQL的root用户无法远程连接

默认root用户只允许本地连接&#xff0c;所以需要修改mysql库中user表中名为root的用户的host为“%” select Host,User from user;UPDATE mysql.user SET host % WHERE user root; FLUSH PRIVILEGES;
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站