java知识梳理（二）

news2025/11/8 14:52:49

一.lambda表达式

作用：Lambda 表达式在 Java 8 引入，主要用于简化匿名内部类的写法，特别是在函数式编程场景中，比如 函数式接口、流式 API（Streams）、并发编程等。它让 Java 代码更简洁、可读性更强，同时提升开发效率。

1.Lambda表达式的语法

// 基本语法
(parameters) ->{ statements; }
// 1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
// 2. ->：可理解为“被用于”的意思
// 3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。

2.函数式接口

函数式接口定义：一个接口有且只有一个抽象方法。然后可以在接口上使用一个注解@FunctionalInterface，添加了这个注解之后，编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的，就相当于自动检测了。
注意：

1.函数式接口是指只有一个抽象方法的接口，但继承自 Object 类的方法不算抽象方法。

2.默认方法（default 方法），不是抽象方法。

3.静态方法（static 方法），也不是抽象方法。

3.使用案例

// 案例一
@FunctionalInterface
interface Rhm {
    void test();
}
public class Demo1 {
    public static void main(String[] args) {
        // 正常写法使用匿名内部类
        Rhm rhm1 = new Rhm(){
            public void test() {
            System.out.println("hello");
        }};
        // 使用Lambda表达式
        Rhm rhm2 = ()->{System.out.println("无参数无返回值");};
        // 使用
        rhm.test();
    }
}

// 案例二：创建一个Thread 类实例
public class Demo1 {
    public static void main(String[] args) {
        // 匿名内部类创建 Runnable ⼦类对象
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                System.out.println("使⽤匿名类创建 Runnable ⼦类对象");
            }
        });
        // 使用Lambda表达式
        Thread t2 = new Thread(() -> System.out.println("使⽤匿名类创建 Thread ⼦类对象"));
    }
}

4.变量捕获

Lambda 可以使用表达式外的变量但是只能使用没有改变过的变量或者被final关键字修饰的变量。

所以Lambda表达式只能捕获被final修饰的变量，如果不是被final修饰的，也要保证在使用之前，没有修改。

5.Lambda在集合框架中的使用

// 这里只演示List的foreach
public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("rhm");
    list.add("hello");
    list.add("lambda");
    // 使用匿名内部类
    list.forEach(new Consumer<String>(){
        public void accept(String str){
            System.out.print(str+" ");
        }
    });
    // 使用Lambda表达式
    list.forEach(s -> { System.out.println(s); });
}

二.文件操作和IO

1.file类

①属性

修饰符及类型属性说明
static StringpathSeparator依赖于系统的路径分隔符，String类型的表示
static charpathSeparator依赖于系统的路径分隔符，char类型的表示

②构造方法

签名说明
File(File parent, String child)根据父目录 + 孩子文件路径，创建一个新的 File 实例
File(String pathname)根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者相对路径
File(String parent, String child)根据父目录 + 孩子文件路径，创建一个新的 File 实例，父目录用路径表示

③方法

修饰符及返回值类型方法签名说明
StringgetParent()返回 File 对象的父目录文件路径
StringgetName()返回 File 对象的文件名称
StringgetPath()返回 File 对象的文件路径
StringgetAbsolutePath()返回 File 对象的绝对路径
StringgetCanonicalPath()返回 File 对象的修饰过的绝对路径
booleanexists()判断 File 对象描述的文件是否真实存在
booleanisDirectory()判断 File 对象代表的文件是否是一个目录
booleanisFile()判断 File 对象代表的文件是否是一个普通文件
booleancreateNewFile()根据 File 对象，自动创建一个空文件。成功创建后返回 true
booleandelete()根据 File 对象，删除该文件。成功删除后返回 true
voiddeleteOnExit()根据 File 对象，标注文件将被删除，删除动作会到 JVM 运行结束时才会进行
String[]list()返回 File 对象代表目录下的所有文件名
File[]listFiles()返回 File 对象代表目录下的所有文件，以 File 对象表示
booleanmkdir()创建 File 对象代表的目录
booleanmkdirs()创建 File 对象代表的目录，如果必要，会创建中间目录
booleanrenameTo(File dest)进行文件改名，也可以视为我们平时的剪切/粘贴操作
booleancanRead()判断用户是否对文件有可读权限
booleancanWrite()

判断用户是否对文件有可写的权限

代码案例：

public class Main {
public static void main(String[] args) throws IOException {
        File file = new File("..\\hello-world.txt"); // 并不要求该⽂件真实存
        System.out.println(file.getParent());
        System.out.println(file.getName());
        System.out.println(file.getPath());
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getCanonicalPath());
    }
}
// 其他代码就不多演示了

2.文件的读写

①Inputstream（字节流）

方法：

修饰符及返回值类型方法签名说明
intread()读取一个字节的数据，返回 -1 代表已经完全读完了
intread(byte[] b)最多读取 b.length 字节的数据到 b 中，返回实际读到的数量；-1 代表已经读完了
intread(byte[] b, int off, int len)最多读取 len 字节的数据到 b 中，放在从 off 开始的位置，返回实际读到的数量；-1 代表已经读完了
voidclose()关闭字节流

InputStream 只是⼀个抽象类，要使⽤还需要具体的实现类。关于 InputStream 的实现类有很多，基本可以认为不同的输⼊设备都可以对应⼀个 InputStream 类，我们现在只关⼼从⽂件中读取，所以使⽤ FileInputStream。

FileInputStream介绍：

构造方法：

签名说明
FileInputStream(File file)利用 File 对象构造文件输入流
FileInputStream(String name)利用文件路径构造文件输入流
代码案例： 
// 字节流读取操作
// 使用FileInputStream读取文件

public class fileinputstreamUser {
    public static void main(String[] args) throws IOException {
        try (InputStream inputStream = new FileInputStream("./test.txt")) {
            // 读文件操作.
            while (true) {
                // 一次读一个字节
//                int data = inputStream.read();
//                if (data == -1) {
//                    // 文件读完.
//                    break;
//                }
//                System.out.printf("0x%x\n", data);

                // 一次读多个字节, 数组的长度, 自行定义.
                byte[] data = new byte[3];
                // 读操作, 就会尽可能把字节数组给填满.
                // 填不满的话, 能填几个就是几个!
                // 此处的 n 就表示实际读了几个字节.
                int n = inputStream.read(data);
                System.out.println("n = " + n);
                if (n == -1) {
                    // 文件读完.
                    break;
                }
                for (int i = 0; i < n; i++) {
                    System.out.printf("0x%x\n", data[i]);
                }
                System.out.println("========================");
            }
        }
    }
}

②Outputstream（字节流）

方法：

修饰符及返回值类型方法签名说明
voidwrite(int b)写入一个字节的数据
voidwrite(byte[] b)将 b 这个字节数组中的数据全部写入输出流中
intwrite(byte[] b, int off, int len)将 b 这个字节数组中从 off 开始的数据写入输出流中，一共写 len 个字节
voidclose()关闭字节流
voidflush()重要：我们知道 I/O 的速度是很慢的，所以，⼤多的 OutputStream 为了减少设备操作的次数，在写数据的时候都会将数据先暂时写⼊内存的⼀个指定区域⾥，直到该区域满了或者其他指定条件时才真正将数据写⼊设备中，这个区域⼀般称为缓冲区。但造成⼀个结果，就是我们写的数据，很可能会遗留⼀部分在缓冲区中。需要在最后或者合适的位置，调⽤ flush（刷新）操作，将数据刷到设备中。

OutputStream 同样只是⼀个抽象类，要使⽤还需要具体的实现类。我们现在还是只关⼼写⼊⽂件中，所以使⽤ FileOutputStream。
代码案例：

//  字节流写入操作
//  使用FileOutputStream像文件中写内容

public class fileoutputstreamUser {
    public static void main(String[] args) {
                                                                            // append是从后面接着加入
        try (OutputStream outputStream = new FileOutputStream("./output.txt", true)) {
//            outputStream.write(97); // 97 在 ascii 中就是 'a'
//            outputStream.write(98);
//            outputStream.write(99);

            byte[] bytes = {99};
            outputStream.write(bytes);

        } catch (IOException e) {
            // 此处是需要处理两个异常. 由于此处并没有针对这两个异常提供不同的处理, 就直接合并了.
            throw new RuntimeException(e);
        }
    }
}

③Reader

Reader是抽象方法，需要使用FileReader。

代码案例：

// 使用FileReader
// 字符流读取
public class filereaderUser {
    public static void main(String[] args) {
        try (Reader reader = new FileReader("./test.txt")) {
            while (true) {
                char[] buf = new char[1024];
                int n = reader.read(buf);
                if (n == -1) {
                    break;
                }
                for (int i = 0; i < n; i++) {
                    System.out.println(buf[i]);
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

④Writer

Writer是抽象方法，需要使用FileWriter

代码案例：

// 使用 FileWriter
// 字符流写入
public class filewriterUser {
    public static void main(String[] args) {
        try (Writer writer = new FileWriter("./output.txt", true)) {
            // writer.write("This is a test");
            BufferedWriter bufferedWriter = new BufferedWriter(writer);
            bufferedWriter.write("Hello World");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

三.反射

作用：Java 反射（Reflection）允许在运行时获取类的元信息（如类名、方法、字段、构造器），并动态调用方法、修改字段或创建实例。

详细解析：Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类 .

1.反射相关的类：

类名用途
Class类代表类的实体，在运行的Java应用程序中表示类和接口
Field类代表类的成员变量/类的属性
Method类代表类的方法
Constructor类代表类的构造方法

2.Class类中的相关方法：

①常用获得类相关的方法
方法用途
getClassLoader()获得类的加载器
getDeclaredClasses()返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的)
forName(String className)根据类名返回类的对象
newInstance()创建类的实例
getName()获得类的完整路径名字
②常用获得类中属性相关的方法
方法用途
getField(String name)获得某个公有的属性对象
getFields()获得所有公有的属性对象
getDeclaredField(String name)获得某个属性对象
getDeclaredFields()获得所有属性对象
③获得类中构造器相关的方法
方法用途
getConstructor(Class...<?> parameterTypes)获得该类中与参数类型匹配的公有构造方法
getConstructors()获得该类的所有公有构造方法
getDeclaredConstructor(Class...<?> parameterTypes)获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()获得该类所有构造方法
④获得类中方法相关的方法
方法用途
getMethod(String name, Class...<?> parameterTypes)获得该类某个公有的方法
getMethods()获得该类所有公有的方法
getDeclaredMethod(String name, Class...<?> parameterTypes)获得该类某个方法
getDeclaredMethods()获得该类所有方法

3.反射的代码案例

①先创建一个类：

class Student{
    private String name = "rhm";
    public int age = 18;

    public Student(){
        System.out.println("Student()");
    }
    private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }

    private void eat(){
        System.out.println("i am eat");
    }
    public void sleep(){
        System.out.println("i am pig");
    }

    private void function(String str) {
        System.out.println(str);
    }
    public String toString() {
        return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

②获取Class对象：三种方法

public class TestDemo {
    public static void main(String[] args) {
        // 1.通过getClass获取Class对象
        Student s1 = new Student();
        Class c1 = s1.getClass();

        // 2.直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高这说明任何一个类都有一个隐含的静态成员变量 class
        Class c2 = Student.class;

        // 3、通过 Class 对象的 forName() 静态方法来获取，用的最多，但可能抛出ClassNotFoundException 异常
        try {
            //注意这里是类的全路径，如果有包需要加包的路径
            Class c3 = Class.forName("Student"); 
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的
        //c1,c2,c3进行 equals 比较，发现都是true
        System.out.println(c1.equals(c2));
        System.out.println(c1.equals(c3));
        System.out.println(c2.equals(c3));
    }
}

③反射的使用：

public class ReflectClassDemo {
    // 反射私有的构造方法 屏蔽内容为获得公有的构造方法
    public static void reflectPrivateConstructor() {
        try {
            Class<?> classStudent = Class.forName("Student");
            //注意传入对应的参数
            Constructor<?> declaredConstructorStudent = classStudent.getDeclaredConstructor(String.class,int.class);
            declaredConstructorStudent.setAccessible(true);  //设置为true后可修改访问权限
            Student student = (Student) declaredConstructorStudent.newInstance("冉汉梦",15);
            System.out.println("获得私有构造哈数且修改姓名和年龄："+student);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    // 反射私有属性
    public static void reflectPrivateField() {
        try {
            Class<?> classStudent = Class.forName("Student");
            Field field = classStudent.getDeclaredField("name");
            field.setAccessible(true);
            //可以修改该属性的值
            Student student = (Student) classStudent.newInstance();
            field.set(student,"小明");
            String name = (String) field.get(student);
            System.out.println("反射私有属性修改了name："+ name);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    // 反射私有方法
    public static void reflectPrivateMethod() {
        try {
            Class<?> classStudent = Class.forName("Student");
            Method methodStudent = classStudent.getDeclaredMethod("function",String.class);
            System.out.println("私有方法的方法名为："+methodStudent.getName());
            methodStudent.setAccessible(true);  //私有的一般都要加
            Student student = (Student) classStudent.newInstance();
            methodStudent.invoke(student,"我是给私有的function函数传的参数");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    public static void main(String[] args) {
        //reflectPrivateConstructor();
        //reflectPrivateField();
        reflectPrivateMethod();
    }
}

四.枚举类

定义：

枚举类型本质上也是一种类，只不过这个类的对象是有限的，只有固定的几个，不能让用户随意创建。

注意：

①枚举类的构造方法是私有的。

②是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承Enum，但是其默认继承了这个类。

1.常用方法

方法名称描述
values()以数组形式返回枚举类型的所有成员
ordinal()获取枚举成员的索引位置
valueOf()将普通字符串转换为枚举实例
compareTo()比较两个枚举成员在定义时的顺序

2.代码案例

// 使用案例一
public enum TestEnum {
    RED,BLACK,GREEN,WHITE;  // 定义的枚举类的对象
    public static void main(String[] args) {
        TestEnum[] testEnum = TestEnum.values(); // 获得枚举类的所用成员
        for (int i = 0; i < testEnum2.length; i++) {
            System.out.println(testEnum[i] + " " + testEnum[i].ordinal());
        }
        
        System.out.println(TestEnum.valueOf("GREEN")); // 字符串转换成枚举实例

        //拿到枚举实例BLACK和RED
        TestEnum testEnum1 = TestEnum.BLACK;
        TestEnum testEnum2 = TestEnum.RED;
        System.out.println(testEnum1.compareTo(testEnum2));
        System.out.println(RED.compareTo(BLACK));
    }
}

// 使用案例二
public enum TestEnum {
    RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);

    private String name;
    private int key;

    private TestEnum (String name,int key) {
        this.name = name;
        this.key = key;
    }
    public static TestEnum getEnumKey (int key) {
        for (TestEnum t: TestEnum.values()) {
            if(t.key == key) {
                return t;
            }
        }
        return null;
    }
    public static void main(String[] args) {
        System.out.println(getEnumKey(2));
    }
}

3.枚举类和反射

不能通过反射获取枚举类的私有构造方法。

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

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

相关文章

鸿蒙Flutter实战：20. Flutter集成高德地图，同层渲染

鸿蒙Flutter实战：20. Flutter集成高德地图，同层渲染

本文以同层渲染为例&#xff0c;介绍如何集成高德地图 完整代码见 Flutter 鸿蒙版 Demo 概述 Dart 侧 核心代码如下&#xff0c;通过 OhosView 来承载原生视图 OhosView(viewType: com.shaohushuo.app/customView,onPlatformViewCreated: _onPlatformViewCreated,creation…
阅读更多...
AI辅助下基于ArcGIS Pro的SWAT模型全流程高效建模实践与深度进阶应用

AI辅助下基于ArcGIS Pro的SWAT模型全流程高效建模实践与深度进阶应用

目前&#xff0c;流域水资源和水生态问题逐渐成为制约社会经济和环境可持续发展的重要因素。SWAT模型是一种基于物理机制的分布式流域水文与生态模拟模型&#xff0c;能够对流域的水循环过程、污染物迁移等过程进行精细模拟和量化分析。SWAT模型目前广泛应用于流域水文过程研究…
阅读更多...
尚语翻译图册翻译|专业图册翻译|北京专业翻译公司推荐|专业文件翻译报价

尚语翻译图册翻译|专业图册翻译|北京专业翻译公司推荐|专业文件翻译报价

内容概要 尚语翻译公司聚焦多语种产品图册翻译的竞价推广服务&#xff0c;通过行业垂直化运营构建差异化竞争力。其核心服务覆盖机械制造、医疗器械、电子元件三大领域&#xff0c;依托ISO 17100认证的翻译流程和Trados术语管理系统&#xff0c;实现技术文档的精准转化。为提升…
阅读更多...
LeetCode 解题思路 30（Hot 100）

LeetCode 解题思路 30（Hot 100）

解题思路&#xff1a; 递归参数&#xff1a; 生成括号的对数 n、结果集 result、当前路径 path、左括号数 open、右括号数 close。递归过程&#xff1a; 当当前路径 path 的长度等于 n * 2 时&#xff0c;说明已经生成有效括号&#xff0c;加入结果集。若左括号数小于 n&…
阅读更多...
Java EE(18)——网络原理——应用层HTTP协议

Java EE(18)——网络原理——应用层HTTP协议

一.初识HTTP协议 HTTP(HyperText Transfer Protocol&#xff0c;超文本传输协议)是用于在客户端&#xff08;如浏览器&#xff09;和服务器之间传输超媒体文档&#xff08;如HTML&#xff09;的应用层协议。 HTTP协议发展至今发布了多个版本&#xff0c;其中1.0&#xff0c;1.…
阅读更多...
强大而易用的JSON在线处理工具

强大而易用的JSON在线处理工具

强大而易用的JSON在线处理工具&#xff1a;程序员的得力助手 在当今的软件开发世界中&#xff0c;JSON&#xff08;JavaScript Object Notation&#xff09;已经成为了数据交换的通用语言。无论是前端还是后端开发&#xff0c;我们都经常需要处理、验证和转换JSON数据。今天&a…
阅读更多...
Qt笔记----》不同环境程序打包

Qt笔记----》不同环境程序打包

文章目录 概要1、windows环境下打包qt程序2、linux环境下打包qt程序2.1、程序目录2.2、创建一个空文件夹2.3、添加依赖脚本2.4、打包过程2.4.1、添加程序依赖库2.4.2、添加Qt相关依赖库 概要 qt不同运行环境下打包方式&#xff1a;windows/linux 1、windows环境下打包qt程序 …
阅读更多...
企业服务器备份软件，企业服务器备份的方法有哪些？

企业服务器备份软件，企业服务器备份的方法有哪些？

企业服务器备份需综合考虑数据量、业务连续性要求&#xff08;RTO/RPO&#xff09;、合规性及成本等因素。以下是分场景的工具和方法指南&#xff1a; 一、备份软件推荐 1. 80KM备份软件 80KM备份软件可以进行很复杂的备份方式&#xff0c;也可以内网对内网备份、还能内网的…
阅读更多...
html5炫酷图片悬停效果实现详解

html5炫酷图片悬停效果实现详解

html5炫酷图片悬停效果实现详解 这里写目录标题 html5炫酷图片悬停效果实现详解项目介绍技术栈核心功能实现1. 页面布局2. 图片容器样式3. 炫酷悬停效果缩放效果倾斜效果模糊效果旋转效果 4. 悬停文字效果5. 性能优化6. 响应式设计 项目亮点总结 项目介绍 本文将详细介绍如何使…
阅读更多...
机器学习的一百个概念（5）数据增强

机器学习的一百个概念（5）数据增强

前言 本文隶属于专栏《机器学习的一百个概念》&#xff0c;该专栏为笔者原创&#xff0c;引用请注明来源&#xff0c;不足和错误之处请在评论区帮忙指出&#xff0c;谢谢&#xff01; 本专栏目录结构和参考文献请见[《机器学习的一百个概念》 ima 知识库 知识库广场搜索&…
阅读更多...
在MCU工程中优化CPU工作效率的几种方法

在MCU工程中优化CPU工作效率的几种方法

在嵌入式系统开发中&#xff0c;优化 CPU 工作效率对于提升系统性能、降低功耗、提高实时性至关重要。Keil 作为主流的嵌入式开发工具&#xff0c;提供了多种优化策略&#xff0c;包括 关键字使用、内存管理、字节对齐、算法优化 等。本文将从多个方面介绍如何在 Keil 工程中优…
阅读更多...
美团民宿 mtgsig 小程序 mtgsig1.2 分析

美团民宿 mtgsig 小程序 mtgsig1.2 分析

声明 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff0c;抓包内容、敏感网址、数据接口等均已做脱敏处理&#xff0c;严禁用于商业用途和非法用途&#xff0c;否则由此产生的一切后果均与作者无关&#xff01; 逆向分析 cp execjs.compile(open(民…
阅读更多...
(done) MIT6.824 Lecture 02 - RPC and Threads

(done) MIT6.824 Lecture 02 - RPC and Threads

知乎专栏&#xff1a;https://zhuanlan.zhihu.com/p/641105196 原视频&#xff1a;https://www.bilibili.com/video/BV16f4y1z7kn?spm_id_from333.788.videopod.episodes&vd_source7a1a0bc74158c6993c7355c5490fc600&p2 看知乎专栏 一、Why we choose go&#xff1f…
阅读更多...
LayaAir3.3.0-beta.3重磅更新！Spine4.2、2D物理、UI系统、TileMap等全面升级！

LayaAir3.3.0-beta.3重磅更新！Spine4.2、2D物理、UI系统、TileMap等全面升级！

正式版推出前&#xff0c;说明3.3的功能还没开发完。所以&#xff0c;又一大波更新来了~ 下面对重点更新进行说明。 Spine的重要更新 3.3.0-beta.3版本开始&#xff0c;新增了Spine 4.2 的运行时库&#xff0c;Spine动画上可以支持物理特性了。例如&#xff0c;下图右侧女孩在启…
阅读更多...
【AI学习】机器学习算法

【AI学习】机器学习算法

1&#xff0c;线性回归模型&#xff08;Linear Regression&#xff09;:预测连续数值 寻找自变量&#xff08;解释变量&#xff09;与因变量&#xff08;被解释变量&#xff09;之间的线性关联关系&#xff0c;通过构建线性方程来对数据进行拟合和预测。即两个变量之间是一次函…
阅读更多...
【渗透测试】Vulnhub靶机-FSoft Challenges VM: 1-详细通关教程

【渗透测试】Vulnhub靶机-FSoft Challenges VM: 1-详细通关教程

下载地址&#xff1a;https://www.vulnhub.com/entry/fsoft-challenges-vm-1,402/ 目录 前言 信息收集 目录扫描 wpscan扫描 修改密码 反弹shell 提权 思路总结 前言 开始前注意靶机简介&#xff0c;当第一次开机时会报apache错误&#xff0c;所以要等一分钟后重启才…
阅读更多...
【区块链+ 房产建筑】山东省建筑产业互联网平台 | FISCO BCOS 应用案例

【区块链+ 房产建筑】山东省建筑产业互联网平台 | FISCO BCOS 应用案例

山东省建筑产业互联网平台&#xff08;山东省弘商易盟平台&#xff09;是基于区块链技术构建的分布式产业互联网平台&#xff0c; 旨在把各企业内部的供应链协同管理系统&#xff08;包括采购或者SRM 系统&#xff0c; 以及销售或CRM 系统&#xff09;利用区块链技术链接起来&a…
阅读更多...
国家天文台携手阿里云，发布国际首个太阳大模型“金乌”

国家天文台携手阿里云，发布国际首个太阳大模型“金乌”

2025年4月1日&#xff0c;中国科学院国家天文台与阿里云共同宣布推出全球首个太阳物理大模型“金乌”&#xff0c;在太阳活动预测领域实现颠覆性突破——其针对破坏性最强的M5级太阳耀斑预报准确率高达91%&#xff0c;远超传统数值模型&#xff0c;标志着人类对太阳的认知迈入“…
阅读更多...
数据结构（5）——栈

数据结构（5）——栈

目录 前言 一、栈的概念及其结构 二、栈的实现 2.1说明 2.2动态栈结构体定义 2.3初始化 2.4销毁 2.5进&#xff08;压&#xff09;栈 2.6检验栈是否为空 2.7弹&#xff08;出&#xff09;栈 2.8栈的元素个数 2.9访问栈顶元素 三、运行 总结 前言 栈是一种常见的…
阅读更多...
Css径向渐变 - radial-gradient

Css径向渐变 - radial-gradient

由background-image: radial-gradient(at 75% 7%, blue 0px, transparent 50%);引出&#xff1a; 一、径向渐变是什么 径向渐变是颜色从一个中心点向外扩散的变化过程。 二、radial-gradient 函数是什么 1、使用语法&#xff1a; background-image: radial-gradient(shape si…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023