JAVA实训第二天

news2024/10/6 18:31:30

目录

JDK8新特性

Java8介绍

JAVA 8主要新特性 

 Java 8接口增强-默认方法

 接口

 接口的应用

Lambda表达式介绍

Lambda表达式的写法

功能性接口Lambda表达式的应用

函数接口

JDK8新特性

Java8介绍

• Java8 是 Java 发布以来改动最大的一个版本，其中主要添加了函数式编程、 Stream 、一些日期处理类。函数式编程 中新 加了一些概念： Lambda 表达式 、函数式接口、函数引用、默认方法、 Optional 类等； Stream 中提供了一些流式处理集合的方法，并提供了一些归约、划分等类的方法；日期中添加了 ZoneDateTime 、 DataFormater 等线程安全的方法 类 ；

JAVA 8主要新特性 

• Lambda  表达式
• 函数 式 接口
• Stream API
• 方法 引用
• Date-Time API
• 接口增强

 Java 8接口增强-默认方法

• Java 8 新增了接口的默认方法。
• 简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。
• 我们只需在方法名前面加个 default 关键字即可实现默认方法。

为什么要有这个特性？

         首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

由于同一个方法可以从不同接口引入，

自然而然的会有冲突的现象，规则如下：

1）一个声明在类里面的方法优先于

任何默认方法
2）优先选取最具体的实现

静态方法的使用区别于前两者

 接口

 接口的应用

接口

package shili22;

/**
 * 接口特点：
 *      行为协议--标准：抽象方法
 *      不可以直接使用（不可以直接创建对象）---如何应用呢？
 *       实现类。
 *
 *
 * 接口引用：实现类。

 * @date : 2022/11/22 9:17
 */

@FunctionalInterface
public interface MyInterface {

//    常量和抽象方法（jdk8之前）：public 修饰
//      常量 ：public static。。。。
    public static final int MAX_VALUE = 10;


    //      抽象方法：（jdk8之前） public abstract ....
    public abstract  void method1();


}

实现类1

package shili22;

/**
 *
 * @date : 2022/11/22 9:24
 */
public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method1() {
        System.out.println("oracle数据库执行操作");
    }
}

实现类2 

package shili22;

/**
 *
 * @date : 2022/11/22 9:25
 */
public class MyInterfaceImpl2 implements MyInterface{
    @Override
    public void method1() {
        System.out.println("mysql功能处理2");
    }
}

实现类3与匿名内部类

package shili22;

/**
 * 当前这个类中所实现接口中的功能处理  仅仅在整个项目中只被应用一次   此时定义一个类  不合适---》如何处理呢？    匿名类
 * @date : 2022/11/22 9:32
 */

//
public class MyInterfaceImpl3 implements MyInterface{
    @Override
    public void method1() {
        System.out.println("查询订单。。。。个人订单----特殊情况下使用---假设整个系统中只被执行一次");
    }
}

class Demo01{


    public static void main(String[] args) {
//        内部类的调用
        MyInterface myInterface2 = new MyInterfaceImpl3();
        myInterface2.method1();


//       匿名内部类----》 匿名类   使用一次情况下常用
        MyInterface myInterface3 = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("查询订单。。。。个人订单----特殊情况下使用---假设整个系统中只被执行一次");
            }
        };

        myInterface3.method1();

    }
}

测试类

package shili22;

/**
 *
 * @date : 2022/11/22 9:22
 */
public class TestMyInterface {

    public static void main(String[] args) {
//        访问接口中成员：
//        常量：MyInterface.常量名，可直接调用静态常量
        System.out.println(MyInterface.MAX_VALUE);

//        接口不可以直接进行实例化
//接口特点： 行为协议--标准：抽象方法 不可以直接使用（不可以直接创建对象）---如何应用呢？ 实现类。 接口引用：实现类。
//        MyInterface myInterface = new MyInterface();(错误示范)

//        接口引用：实现类。
        MyInterface  myInterface = new MyInterfaceImpl();
        myInterface.method1();

    }
}

Lambda表达式介绍

 

 正如你所看到的，使用Lambda表达式不仅让代码变的简单、而且可读、最重要的是代码量也随之减少很多

代码对比 

package lambda;

/**
 *
 * @date : 2022/11/22 10:23
 */
@FunctionalInterface
//当有两个时，就不是功能型接口，就不能使用Lambda
public interface MyInterface {

    public void method1();
//    public void method2(int a);
}


class Demo01{
    public static void main(String[] args) {
        /*MyInterface myInterface = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("method1........");
            }
        };*/

//        lambda:代码简洁  可读性强
        MyInterface myInterface = ()-> {System.out.println("执行代码");};
        myInterface.method1();

    }
}
package lambda;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * @date : 2022/11/22 10:29
 */
public class Demo02Lambda {

    public static void main(String[] args) {

//        是否是所有接口都可以应用lambda表达式呢？

//         观察：一个接口中定义多个抽象方法  再使用lambda表达式 就出现编译型问题---》改为函数式接口\功能性接口
//         使用lambda表达式前提---必须是一个函数式接口\功能性接口
//           函数式接口\功能性接口：只有一个抽象方法的接口才称为功能性接口
//                              如何检查是否是功能性接口：可以标注 @FunctionalInterface 编译通过说明是
//

//        改变排序规则：降序
        /*TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });*/
        TreeSet<Integer> treeSet = new TreeSet<>((Integer o1, Integer o2)->{return o2.compareTo(o1);});
        treeSet.add(30);
        treeSet.add(10);
        treeSet.add(20);
        System.out.println(treeSet);


    }
}

查看源码发现,在接口中只有一个抽象方法，接口上多了一个@FunctionalInterface注解，这种格式的接口被称为函数式接口，

函数式接口定义如下：

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，但是可以有多个非抽象方法。Java中的Lambda才能顺利地进行推导。

Lambda表达式的写法

Lambda表达式格式-([参数类型 ]参数名称) ‐> { 代码语句 }

需求

格式

说明

有一个形参

参数名称->{代码语句}

一个形参可以省略小括号

没有形参

（）->{代码语句}

没有形参括号不能省略

方法体中只有一行代码

(参数名称)->代码语句

方法体中只有一行代码，可以省略大括号，分号和return关键字

package lambda;

@FunctionalInterface
public interface MyInterfaceLambda {

//    public void method1();
//     public void method2(int a);
//     public void method2(int a,String str);
     public int method2(int a,String str);

}

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

//        1)没有返回值 没有参数
        /*MyInterfaceLambda myInterfaceLambda = ()->{
            System.out.println("hello");
            System.out.println("java");
        };
        myInterfaceLambda.method1();
        System.out.println("===================");
//        {}是否可以省略问题 :{}中只有一行代码  {}可以省略
        MyInterfaceLambda myInterfaceLambda2 = ()->
            System.out.println("hello");
        ;
        myInterfaceLambda2.method1();*/


//        2)没有返回值  有参数--1个参数
//        A:lambda--形参名字--自定义
//        B:形参 类型可以省略
//        C:()可以省略
        /*MyInterfaceLambda myInterfaceLambda3 = (int a)->{
            if(a>2){
                System.out.println("b>2");
            }else{
                System.out.println("a<2");
            }
        };*/
        /*MyInterfaceLambda myInterfaceLambda3 = (a)->{
            if(a>2){
                System.out.println("a>2");
            }else{
                System.out.println("a<2");
            }
        };*/

        /*MyInterfaceLambda myInterfaceLambda3 = a->{
            if(a>2){
                System.out.println("a>2");
            }else{
                System.out.println("a<2");
            }
        };
        myInterfaceLambda3.method2(1);*/



//        3)没有返回值  有参数--多个参数  ()不可以省略
       /* MyInterfaceLambda myInterfaceLambda4=(int a,String str)->{
            System.out.println(a+"=========="+str);
        };*/
       /* MyInterfaceLambda myInterfaceLambda4=(a,str)->
            System.out.println(a+"=========="+str);
        ;

        myInterfaceLambda4.method2(66,"hello");*/



//        4)有返回值抽象方法  return 关键字
       /* MyInterfaceLambda myInterfaceLambda5 = (a,str)->{

            String result = a+"==="+str;
            System.out.println(result);
            if (a>100){
                return a;
            }
            return 0;
        };

        myInterfaceLambda5.method2(200,"hello");*/

//        有返回值的方法： 如果{}里面只有一行代码  {}省略同时return也要省略
        MyInterfaceLambda myInterfaceLambda5 = (a,str)-> a;

        int result = myInterfaceLambda5.method2(200, "hello");
        System.out.println("result:"+result);

    }
}

功能性接口Lambda表达式的应用

package lambda.demo03;

import org.junit.Test;

/**
 * @date : 2022/11/22 11:12
 */
public class JunitTest {

    public void testMyFunction(MyFunction myFunction){
        myFunction.test("tidy");
    }


    @Test
    //加上注释变成测试类
    public void testMethod(){

      /*  MyFunction myFunction = name->{
            System.out.println("name:"+name);
        };

        testMyFunction(myFunction);*/
       /* testMyFunction(name->{
            System.out.println("name:"+name);
        });*/

        testMyFunction(name->
            System.out.println("name:"+name)
        );

    }



}

package part2;

@FunctionalInterface
public interface MyFunction {

    //    抽象方法  a=10,b=20;计算a+b,并返回计算结果
//    方法：
//      3要素：1)是否有返回值    2）方法名    3）方法參數
    public int operation(int num1, int num2);

}

class Demo {


    public static void main(String[] args) {
        //案例一:a=10,b=20;计算a+b,并返回计算结果
//        MyFunction myFunction = (num1,num2)->{return num1+num2;};
        MyFunction myFunction = (num1, num2) -> num1 + num2;
        int result1 = myFunction.operation(10, 20);
        System.out.println("result1:" + result1);

//        a=10,b=20;计算a*b,并返回计算结果

        MyFunction myFunction2 = (num1, num2) -> num1 * num2;
        int result2 = myFunction2.operation(10, 20);
        System.out.println("result2:" + result2);

        System.out.println("======================");

        Demo demo = new Demo();
        /*MyFunction myfunction3 = (a,b)->a+b;
        int sum = demo.sum(50, 60, myfunction3);*/
        int sum = demo.sum(50, 60, (a,b)->a*b);
        System.out.println("sum:"+sum);
    }


    public int sum(int a, int b, MyFunction myfunction) {
        return myfunction.operation(a, b);
    }

}

 

函数接口

 四个接口示例

package part2;

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

/**
 * @date : 2022/11/22 15:35
 */
public class FunctionDemo02 {

    public static void main(String[] args) {
//        1)消费型接口---传入参数
        Consumer consumer = t->{
            if(t.equals("hello")){
                System.out.println("OK");
            }else{
                System.out.println("NG");
            }
        };

        consumer.accept("hello");


//        2）Supplier供给型接口--返回值
        System.out.println("==Supplier供给型接口--返回值：=================");


        Supplier<Integer> supplier = ()->new Integer(12);

        Integer num = supplier.get();
        System.out.println(num);

//        3）Function<T , R>： Function接口
        System.out.println("=Function<T , R>： Function接口：=================");
//        判断用户名是否正确：  tidy  success  否则 fail
        String inputName = "tidy";
        Function<String,String> function = str->{
            if ("tidy".equals(str)){
                return "Success";
            }else{
                return "fail";
            }
        };

        String result = function.apply(inputName);
        System.out.println("result:"+result);



//        4)Predicate<T>：断言型接口
        Predicate<String> predicate = t->{

            return "123456".equals(t)?true:false;

        };

        boolean flg = predicate.test("123456");
        System.out.println("flg:"+flg);

    }






}

作业

1. 给一个整数集合，分别求集合中偶数和与奇数和

 

package housework;

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

public interface test221 {

    public int[] operation(List<Integer> list);
}

class test11221{
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        test221 function = (list2)->{
            int jishuSum =0;
            int oushuSum = 0;
            for (int i = 0; i < list2.size(); i++) {
                if (list2.get(i)%2==0){
                    oushuSum=oushuSum+list2.get(i);
                }else{
                    jishuSum = jishuSum+list2.get(i);
                }
            }
            int[] arr = new int[2];
            arr[0]=jishuSum;
            arr[1]=oushuSum;
            return arr;
        } ;
        int[] arr2 = function.operation(list);
        System.out.println("奇数和："+arr2[0]);
        System.out.println("偶数和："+arr2[1]);
    }
}

2. 给一个整数集合，将集合分成偶数集合和奇数集合

 

package housework;

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

public interface test222 {

    public List operation(List<Integer> list);
}

class test11222{
    public static void main(String[] args) {
        test222 function = (list2)->{
            List<Integer> ji = new ArrayList<>();
            List<Integer> ou = new ArrayList<>();
            for (int i = 0; i < list2.size(); i++) {
                if (list2.get(i)%2==0){
                    ou.add(list2.get(i));
                }else{
                    ji.add(list2.get(i));
                }
            }
            List<List<Integer>> sum = new ArrayList<>();
            sum.add(ou);
            sum.add(ji);
            return sum;
        } ;
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        function.operation(list);
        List list1 = function.operation(list);
        System.out.println("奇数和："+ list1.get(1));
        System.out.println("偶数和："+list1.get(0));
    }
}

3. 集合转换：[[1, 2, 3, 4, 5], [2, 1, 9, 3, 6, 7], [3, 1, 6]] > ["1", "2", "4", "5", "2", …… "3", "1","6"]

package housework;

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

public interface test223 {

    public List<String> operation(List<List<Integer>> list);
}

class test11223{
    public static void main(String[] args) {
        test223 function = (list2)->{
            List<String> ji = new ArrayList<>();
            for (int i = 0; i < list2.size(); i++) {
                for (int j = 0; j < (list2.get(i)).size(); j++)
                     ji.add("“"+list2.get(i).get(j).toString()+"”");
            }
            return ji;
        } ;
        List<List<Integer>> list = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();

        Collections.addAll(list1,1,2,3,4,5);
        Collections.addAll(list2,3,1,6);
        Collections.addAll(list3,2,1,9,3,6,7);
        list.add(list1);
        list.add(list2);
        list.add(list3);
//        System.out.println(list);
//        function.operation(list);
        List<String> list4 = function.operation(list);
        System.out.println("后："+ list4);

    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

自定义数据类型——结构体

自定义数据类型——结构体

我们今天来简单介绍一下结构体。 目录 1. 结构体的声明 2. 结构体成员的访问 3. 结构体传参 首先我们要知道为什么会有结构体的存在&#xff0c;我们的生活里有很多东西&#xff0c;比如一只猫&#xff0c;一本书&#xff0c;一个人&#xff0c;我们如果要用程序来描述他们…
阅读更多...
C语言 指针

C语言 指针

C语言 指针引言1. 什么是指针2. 简单认识指针3. 取地址符 & 和解引用 * 符一、指针与内存二、指针类型的存在意义1. 指针变量的大小2. 指针移动3. 不同指针类型的解引用三、指针运算1. 指针加减整数程序清单1程序清单22. 指针 - 指针3. 指针关系运算四、二级指针五、野指针…
阅读更多...
这个双11，我薅了华为云会议的羊毛

这个双11，我薅了华为云会议的羊毛

文章目录前言华为云会议悄然助力各行各业和其他云会议产品相比&#xff0c;华为云会议优势是什么&#xff1f;云端一体线下会议室和云会议互通专业会管与会控能力更安全华为云会议有哪些 AI 能力&#xff1f;华为云会议入门有多简单&#xff1f;下载步骤如下安装加入会议预约会…
阅读更多...
原生js 之 (DOM操作）

原生js 之 (DOM操作）

Web API Web API是浏览器提供的一套操作浏览器功能和页面元素的API(BOM和DOM) JavaScipt由三部分构成 ECMAScript、DOM和BOM。 BOM浏览器对象模型&#xff0c;提供了与浏览器的交互方法和接口&#xff1b; DOM 文档对象模型&#xff0c;提供了处理网页内容、结构 、样式的方法…
阅读更多...
【数据结构】图的遍历

【数据结构】图的遍历

深度优先遍历 深度优先遍历思想 对于图&#xff1a;选中一个结点&#xff0c;访问和其相邻的、未被访问过的点&#xff0c;全部访问完毕后回退到上一个结点&#xff0c;直至全部结点访问完毕&#xff0c;类似于图的先序遍历&#xff0c;如有邻接表&#xff0c;则按邻接矩阵的顺…
阅读更多...
一文熟悉 Go 的基础语法和基本数据类型

一文熟悉 Go 的基础语法和基本数据类型

一文熟悉 Go 的基础语法和基本数据类型前言Hello&#xff0c;World&#xff01;有关 main 函数的一些要点关键字package声明引入基本数据类型整形数据类型有符号整数类型无符号整数类型其他整数类型浮点数据类型字符类型布尔类型字符串类型基本数据类型的默认值常量和变量声明结…
阅读更多...
swift指针内存管理-指针类型使用

swift指针内存管理-指针类型使用

为什么说指针不安全 我们在创建一个对象的时候&#xff0c;是需要在堆上开辟内存空间的 但是这个内存空间的声明周期是有限的 也就意味着如果使用指针指向这块内存空间&#xff0c;当这块内存空间的生命周期结束&#xff08;引用计数为0&#xff09;&#xff0c;那么当前的指针…
阅读更多...
mac m1 配置goland debbug

mac m1 配置goland debbug

大概率无法使用goland的debug功能&#xff0c;如果自己安装没选对路径&#xff0c;也无法使用。原因是&#xff1a; go env 配置不对&#xff0c;需要指向 ARM64&#xff1b; dlv版本不对&#xff0c;需要使用 arm64 系列&#xff1b; dlv路径不对&#xff0c;需要使用 macarm…
阅读更多...
Linux服务器使用git clone命令时报错的解决方案

Linux服务器使用git clone命令时报错的解决方案

在往GitHub上上传项目时&#xff0c;使用git clone xxxxx.git时候报错&#xff1a; “gnutls_handshake() failed: the TLS connection was non-properly terminated” 由系统的 git 默认使用的 libcurl4-gnutls-dev 造成&#xff0c;可以使用openssl解决. 但是这个过程也很多…
阅读更多...
2022亚太B题赛题分享

2022亚太B题赛题分享

高速列车的优化设计 2022年4月12日&#xff0c;中国高铁复兴CR450多机组成功实现单列列车速度435 km/h&#xff0c;相对速度870 km/h&#xff0c;创造了高铁多机组列车穿越明线和隧道速度的世界纪录。新一代标准动车组“复兴”是中国自主研发的具有全知识产权的新一代高速列车。…
阅读更多...
Doris 5 处理Sentinel-1 生成干涉图 interferogram

Doris 5 处理Sentinel-1 生成干涉图 interferogram

Doris 5 处理Sentinel-1 Step 0 创建文件夹 首先创建一个文件夹用来准备数据处理&#xff0c;例如 “Doris_test1”&#xff0c;然后在该文件夹下创建五个文件夹&#xff0c;用来存放数据&#xff0c;例如 AOI (研究区的shp文件), archive_data (已下载的Sentinel-1 SLC文件&…
阅读更多...
手部IK，自制动画，蒙太奇——开门手臂自动弯曲、靠墙手自动扶墙

手部IK，自制动画，蒙太奇——开门手臂自动弯曲、靠墙手自动扶墙

开门手臂自动弯曲 实现效果&#xff1a;人物做出抬手的开门动画时&#xff0c;若手臂碰到静态网格物体&#xff0c;拳头不会穿过物体&#xff0c;而是会产生手臂IK弯曲动画效果。 重要参考资料&#xff1a; 学习UE4动画蓝图&#xff1a;配置手部IK_YakSue的博客-CSDN博客_ue…
阅读更多...
ImageProvider工作流程和AssetImage 加载流程

ImageProvider工作流程和AssetImage 加载流程

Flutter 学习&#xff1a;ImageProvider工作流程和AssetImage 的自动分辨率适配原理https://cloud.tencent.com/developer/article/1748045上面流程为ImageProvider工作流程细节&#xff0c;作者已经写的很详细了&#xff0c;非常受用&#xff0c;现在接着上面作者内容讨论下As…
阅读更多...
【32-业务开发-基础业务-规格参数-保存数据-查询数据-更新操作之数据回显展示-更新操作-前后端项目交互整合与测试-总结收获】

【32-业务开发-基础业务-规格参数-保存数据-查询数据-更新操作之数据回显展示-更新操作-前后端项目交互整合与测试-总结收获】

一.知识回顾 【0.三高商城系统的专题专栏都帮你整理好了&#xff0c;请点击这里&#xff01;】 【1-系统架构演进过程】 【2-微服务系统架构需求】 【3-高性能、高并发、高可用的三高商城系统项目介绍】 【4-Linux云服务器上安装Docker】 【5-Docker安装部署MySQL和Redis服务】…
阅读更多...
1532_AURIX_TriCore内核架构_中断

1532_AURIX_TriCore内核架构_中断

全部学习汇总&#xff1a; GreyZhang/g_tricore_architecture: some learning note about tricore architecture. (github.com) 中断一直是我想了解关注的一个功能模块&#xff0c;因为感觉不同的芯片上这部分的设计差异比较大。而这部分也跟我们嵌入式软件的设计模式直接相关。…
阅读更多...
使用HikariCP连接池常用配置讲解及注意事项

使用HikariCP连接池常用配置讲解及注意事项

使用HikariCP连接池常用配置讲解及注意事项常遇到的几种错误Possibly consider using a shorter maxLifetime valueConnection is not available, request timed out after xxxxxmsNo operations allowed after connection closed常见配置及注释说明&#xff0c;可以使用并根据…
阅读更多...
每日刷题2——指针概念

每日刷题2——指针概念

更新不易&#xff0c;麻烦多多点赞&#xff0c;欢迎你的提问&#xff0c;感谢你的转发&#xff0c; 最后的最后&#xff0c;关注我&#xff0c;关注我&#xff0c;关注我&#xff0c;你会看到更多有趣的博客哦&#xff01;&#xff01;&#xff01; 喵喵喵&#xff0c;你对我…
阅读更多...
Twins: Revisiting the Design of Spatial Attention in Vision Transformers

Twins: Revisiting the Design of Spatial Attention in Vision Transformers

Twins: Revisiting the Design of Spatial Attention in Vision Transformers一、引言二、Twins-PCPVT三、Twins-SVT四、实验五、消融实验文章链接: https://arxiv.org/abs/2104.13840代码链接: https://github.com/Meituan-AutoML/Twins一、引言 在本文中&#xff0c;重新审…
阅读更多...
基于Matlab计算经典CFAR阈值

基于Matlab计算经典CFAR阈值

✅作者简介&#xff1a;热爱科研的Matlab仿真开发者&#xff0c;修心和技术同步精进&#xff0c;matlab项目合作可私信。 &#x1f34e;个人主页&#xff1a;Matlab科研工作室 &#x1f34a;个人信条&#xff1a;格物致知。 更多Matlab仿真内容点击&#x1f447; 智能优化算法 …
阅读更多...
基于开源 PolarDB-X 打造中正智能身份认证业务数据基座

基于开源 PolarDB-X 打造中正智能身份认证业务数据基座

一、公司及业务介绍 中正智能是全球领先的生物识别和身份认证公司之一。我们曾负责公安部指纹算法国家标准的起草、编写&#xff0c;具备从算法、终端、平台、设计、生产、交付全域自研的能力&#xff0c;拥有多项自主知识产权的产品&#xff0c;并积极与高校合作开展基础研发。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023