Java面向对象（高级）-- 单例(Singleton)设计模式

news2024/10/7 6:48:35

文章目录

  • 一、单例设计模式
    • （1） 设计模式概述
    • （2） 何为单例模式
    • （3） 实现思路
    • （4） 单例模式的两种实现方式
      • 1. 饿汉式
      • 2. 懒汉式
      • 3. 饿汉式 vs 懒汉式
    • （5） 单例模式的优点及应用场景
  • 二、理解main方法的语法
    • （1）main()方法的剖析
    • （2）与控制台交互
      • 1.举例1
        • 1.1 方式一、命令行
        • 1.2 方法二、编译器
      • 2.举例2
    • （3）笔试题

一、单例设计模式

（1） 设计模式概述

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。

设计模式免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。“套路”

经典的设计模式共有23种。每个设计模式均是特定环境下特定问题的处理方法。

创建型模式：主要用于创建对象，根据不同场景设计不同的设计模式。

image.png

简单工厂模式并不是23中经典模式的一种，是其中工厂方法模式的简化版

对软件设计模式的研究造就了一本可能是面向对象设计方面最有影响的书籍：《设计模式》：《Design Patterns: Elements of Reusable Object-Oriented Software》（即后述《设计模式》一书），由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著（Addison-Wesley，1995）。这几位作者常被称为"四人组（Gang of Four）"，而这本书也就被称为"四人组（或 GoF）"书。

（2） 何为单例模式

单例–单独一个实例（对象）

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例（不需要多个对象），并且该类只提供一个取得其对象实例的方法。

（3） 实现思路

如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。

因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法（方法不能是非静态的，因为非静态方法要通过对象去调用，

此时外部无法创建对象来调用方法，只能通过类调用静态方法）以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

（4） 单例模式的两种实现方式

1. 饿汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }

    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single = new Singleton();

    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        return single;
    }
}

【举例】

场景：假设Bank只有一个实例。

package yuyi04;

public class BankTest {

}

class Bank{ //假设这个银行只有一个实例：中国人民银行


}

①类的构造器私有化 (避免类的外部创建对象)

为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器。

class Bank{ //假设这个银行只有一个实例：中国人民银行
	//1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }
}

②在类的内部创建当前类的实例 (一个就可以了)

class Bank{ //假设这个银行只有一个实例：中国人民银行
	//1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }

     //2.在类的内部创建当前类的实例 (一个就可以了)
    private Bank instance=new Bank();   //可以看作当前类的一个属性 (是当前类类型的)，不需要放到方法里面，习惯将它私有化
    
}

③提供私有属性的get方法

类的外部想用这个对象，但是对象被私有化了，外部无法调用，所以要有方法提供

class Bank{ //假设这个银行只有一个实例：中国人民银行
	//1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }

    
     //2.在类的内部创建当前类的实例 (一个就可以了)
    private Bank instance=new Bank();   //可以看作当前类的一个属性 (是当前类类型的)，不需要放到方法里面，习惯将它私有化

    
    //3.提供私有属性的get方法
    //类的外部想用这个对象，但是对象被私有化了，外部无法调用，所以要有方法提供
    public Bank getInstance(){
        return instance;    //在方法里面，将造好的对象返回
    }
}

使用getXxx()方法获取当前类的实例，必须声明为static的。

通过方法返回当前类的实例，那么这个getInstance方法谁来调呢？

现在只能拿“对象”来调用这个方法，才能拿到getInstance方法来获取此对象。(此时在类外部需要一个对象，但是无法通过构造器来创建，只能通过getInstance方法来获取一个对象，但是这个方法也需要通过对象才能调用，而对象需要通过这个方法来获取，绕进去了…)

要想调用getInstance方法来获取对象，肯定不能拿对象去调用，只能通过类来调用，那就意味着getInstance方法需要静态化。

public static Bank getInstance(){
    return instance;    //在方法里面，将造好的对象返回
}

④属性设置为static

上一步将方法声明为static之后，会发现报错，如下：

image.png

这是因为静态方法中，只能调用静态属性或方法。

所以instance也必须静态化，如下：

private static Bank instance=new Bank();

目前整体的Bank类如下：

class Bank{ //假设这个银行只有一个实例：中国人民银行

    //1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }

    //2.在类的内部创建当前类的实例 (一个就可以了)
    //4.此属性也必须声明为static的
    private static Bank instance=new Bank();   //可以看作当前类的一个属性 (是当前类类型的)，不需要放到方法里面，习惯将它私有化

    //3.使用getXxx()方法获取当前类的实例，必须声明为static的
    //类的外部想用这个对象，但是对象被私有化了，外部无法调用，所以要有方法提供
    public static Bank getInstance(){
        return instance;    //在方法里面，将造好的对象返回
    }
}

④测试

使用当前类的唯一实例。

package yuyi04;

/**
 * ClassName: BankTest
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/17 0017 8:43
 */
public class BankTest {
    public static void main(String[] args) {
        //使用当前类的唯一实例
        Bank bank1=Bank.getInstance();

        //再通过getInstance方法获取另外一个所谓的实例，其实和上面的实例指向同一个
        Bank bank2=Bank.getInstance();

        //测试
        System.out.println(bank1==bank2);
    }
}

class Bank{ //假设这个银行只有一个实例：中国人民银行

    //1.类的构造器私有化 (避免类的外部创建对象)
    //为了保证这个类只能造一个对象，而造对象需要使用到构造器，那么在这个类外面就不能让它随便调用构造器
    private Bank(){ //构造器私有化，不对外暴露

    }

    //2.在类的内部创建当前类的实例 (一个就可以了)
    //4.此属性也必须声明为static的
    private static Bank instance=new Bank();   //可以看作当前类的一个属性 (是当前类类型的)，不需要放到方法里面，习惯将它私有化

    //3.使用getXxx()方法获取当前类的实例，必须声明为static的
    //类的外部想用这个对象，但是对象被私有化了，外部无法调用，所以要有方法提供
    public static Bank getInstance(){
        return instance;    //在方法里面，将造好的对象返回
    }
}

输出结果：

image.png

2. 懒汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single;
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        if(single == null) {
            single = new Singleton();
        }
        return single;
    }
}

【举例】

场景：GirlFriend只能有一个实例。

package yuyi04;

/**
 * ClassName: GirlFriend
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/17 0017 9:24
 */
public class GirlFriendTest {
    public static void main(String[] args) {

    }
}

class GirlFriend{

}

①**类的构造器私有化 **

class GirlFriend{
    //1.类的构造器私有化 
    private GirlFriend(){

    }
}

②声明当前类的实例，作为一个属性出现。

这时候并没有创建这个对象。

class GirlFriend{
    //1.类的构造器私有化
    private GirlFriend(){

    }

    //2.声明当前类的实例，作为一个属性出现
    //和刚才一样，外边不能造对象了，里边就得造。里面造和上一种方法的区别就在于这里只是做了一个声明。
    private GirlFriend instance=null;   //右边在赋值的时候赋值了一个null，若是不写本身也是null
}

③通过getXxx()方法获取当前类的实例，如果未创建对象，则在方法内部进行创建。

通过get方法去调用的时候，发现没有实例化，就帮忙造一下。

class GirlFriend{
    //1.类的构造器私有化
    private GirlFriend(){

    }

    
    //2.声明当前类的实例，作为一个属性出现
    //和刚才一样，外边不能造对象了，里边就得造。里面造和上一种方法的区别就在于这里只是做了一个声明。
    private GirlFriend instance=null;   //右边在赋值的时候赋值了一个null，若是不写本身也是null

    
    //3.通过getXxx()方法获取当前类的实例，如果未创建对象，则在方法内部进行创建
    /*public GirlFriend getInstance(){
        if(instance==null){ //若此时没有实例化，就实例化一下
            instance=new GirlFriend();
            return instance;    //创建好实例之后返回即可
        }else{  //若之前已经创建好对象了，直接return就好
            return instance;
        }
    }*/

    public GirlFriend getInstance(){
        if(instance==null){ //若此时没有实例化，就实例化一下
            instance=new GirlFriend();
        }
        //若发现没有实例化，就进入if创建好之后返回即可；若发现已经有实例了，不执行if直接return即可
        return instance;
    }
}

这里优化一下，如下：
image.png

④静态化属性和方法

和饿汉式一样，getInstance方法需要通过类来调用，所以这里也需要加上static。如下：

public static GirlFriend getInstance(){
    if(instance==null){ //若此时没有实例化，就实例化一下
        instance=new GirlFriend();
    }
    //若发现没有实例化，就进入if创建好之后返回即可；若发现已经有实例了，不执行if直接return即可
    return instance;
}

然后静态方法里面只能调静态的，所以instance也要加上static。如下：

private static GirlFriend instance=null;

现在整体的GirlFriend如下：

class GirlFriend{
    //1.类的构造器私有化
    private GirlFriend(){

    }

    //2.声明当前类的实例，作为一个属性出现
    //4.此属性也必须声明为static的
    private static GirlFriend instance=null;   //右边在赋值的时候赋值了一个null，若是不写本身也是null


    //3.通过getXxx()方法获取当前类的实例，如果未创建对象，则在方法内部进行创建
    public static GirlFriend getInstance(){
        if(instance==null){ //若此时没有实例化，就实例化一下
            instance=new GirlFriend();
        }
        //若发现没有实例化，就进入if创建好之后返回即可；若发现已经有实例了，不执行if直接return即可
        return instance;
    }
}

3. 饿汉式 vs 懒汉式

饿汉式：

  • 特点：立即加载，即在使用类的时候已经将对象创建完毕。
  • 优点：实现起来简单；没有多线程安全问题。
  • 缺点：当类被加载的时候，会初始化static的实例，静态变量被创建并分配内存空间，从这以后，这个static的实例便一直占着这块内存，直到类被卸载时，静态变量被摧毁，并释放所占有的内存。因此在某些特定条件下会耗费内存。

懒汉式：

  • 特点：延迟加载，即在调用静态方法时实例才被创建。
  • 优点：实现起来比较简单；当类被加载的时候，static的实例未被创建并分配内存空间，当静态方法第一次被调用时，初始化实例变量，并分配内存，因此在某些特定条件下会节约内存。
  • 缺点：在多线程环境中，这种实现方法是完全错误的，线程不安全，根本不能保证单例的唯一性。
    • 说明：在多线程章节，会将懒汉式改造成线程安全的模式。

【举例】

还是拿上面两个例子作比较，如下：（这里过滤掉属性了，针对当前创建的实例没有任何属性，它不属于单例模式的核心问题，这里就过滤掉了）

image.png

“饿汉式”一上来就把对象创建好了（立即加载），静态声明的变量随着类的加载而加载，比较早得出现在内存当中，需要用得时候直接拿来用；同样随着类的消亡而消亡，其实并不会轻易卸载类，类都加载到方法区内，GC回收方法区的频率非常低，此时试图卸载一个类也非常困难，因为这个类可能会在任意地方被使用（包括被类的加载器所引用，类的加载器不消亡它也不会消亡，同样静态变量也消除不了，所以在内存中占用时间就会很长）。

“懒汉式”一上来没有创建，当需要的时候才创建（延时加载）。

从内存节省的角度来说，“懒汉式”比较好，“饿汉式”实例的生命周期有点长。

之前说过的“内存泄露”-- 本身是个垃圾，但是GC还没有帮我们回收。在一定程度上来说，有的变量也谈不上泄露，但是它的生命周期特别长，使用的时间又特别短，多余的时间不想要（可以回收掉），但是它是静态的，导致生命周期很长却没有办法回收，一定程度上也可以认为是泄露（生命周期过长，超出了使用的范围）。

【对比两种模式】（特点、优缺点）

  • 特点
    • 饿汉式：“立即加载”，随着类的加载，当前的唯一实例就创建了。
    • 懒汉式：“延迟加载”，在需要使用的时候，进行创建。
  • 优缺点
    • 饿汉式：（优点）写法简单，由于内存中较早加载，使用更方便、更快。是线程安全的。 （缺点）内存中占用时间较长。
    • 懒汉式：（缺点）线程不安全 （有可能会创建好几次对象，放到多线程章节时解决）（优点）在需要的时候进行创建，节省内存空间。

（5） 单例模式的优点及应用场景

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。

举例：

Java中有一个类叫Runtime（运行时环境），单例设计模式–饿汉式，如下：

image.png

应用场景

  • Windows的Task Manager (任务管理器)就是很典型的单例模式 。
  • Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
  • Application 也是单例的典型应用。
  • 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只
    能有一个实例去操作，否则内容不好追加。
  • 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

二、理解main方法的语法

（1）main()方法的剖析

public static void main(String args[]){
    
}

理解1：看做是一个普通的静态方法。

理解2：看做是程序的入口，格式是固定的。

解释：

public–此方法权限很大，在整个项目中都能看得到。

static–静态的，随着类的加载而加载。main方法是程序的入口，不能说一上来就造一个本类的对象，若是造对象才能掉方法，但是造对象的方法也得在程序入口里面做，卡死了。所以这个时候方法不能拿对象去调，只能拿类去调，所以只能是static的。

void–这个方法执行完也不需要返回，也没有可以返回的结构了，已经是最基础的方法了。

main–这个方法比较特别，是程序的入口，所以写成main表示入口的意思。

由于JVM需要调用类的main()方法，所以该方法的访问权限必须是public，又因为JVM在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。

又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到。

【举例】

package yuyi04;

/**
 * ClassName: MainTest
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/18 0018 20:55
 */
public class MainTest {
    public static void main(String[] args) {    //程序的入口
        //造一个String类型的数组
        String[] arr=new String[]{"AA","BB","CC"};

        //通过Main类来调用此类中的静态方法main()
        Main.main(arr);
    }
}

class Main{
    public static void main(String[] args) {    //看作是普通的静态方法
        //把参数对应的数组遍历一下
        System.out.println("Main的main()的调用");
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

输出结果：

image.png

（2）与控制台交互

可以发现，main方法带了一个形参String args[]，到目前为止好像没有用过它，有啥用呢？

💬如何从键盘获取数据？

方式1：使用Scanner（传的是各种类型）

方式2：使用main()的形参进行传值。（只能传递String类型）

1.举例1

先写一段代码。

【MainDemo.java】

package yuyi04;

/**
 * ClassName: MainDemo
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 7:38
 */
public class MainDemo {
    public static void main(String[] args) {    //当我们调用main方法时，传递了一个String数组
        for (int i = 0; i < args.length; i++) { //遍历打印
            System.out.println("hello:"+args[i]);
        }
    }
}
1.1 方式一、命令行

先将文件【MainDemo.java】复制到一个文件夹中，比如D盘：

image.png

命令行的时候没有包的概念，记得将第一行导包注释掉，如下：

image.png

记得将文件的字符集改为“ANSI”，因为黑窗口的字符集默认GBK，如下：

image.png

改为ANSI，才不会乱码：

image.png

执行文件：

image.png

由于代码没有输入任何数据，所以args.length是0，就没有任何执行效果啦。

那如何传呢？

在写完类名的时候，再写一个空格，后边就可以输入数据了，第一个要加双引号，后边可以不用，中间用空格隔开，注意一定要是英文格式下。比如：java MainDemo "Tom" Jarry 89 true，回车之后便可输出，如下：

image.png

相当于args数组的长度是4，依次遍历了它的元素。（从控制台获取String类型的数据）

在代码层面，可以把89转化为int类型，把true转化为boolean类型。（讲包装类的时候再说这个问题）

1.2 方法二、编译器

上面演示了命令行的方式，那么在idea编译器中如何体现传值呢？

先配置一下。

“运行”–>“编辑配置”：

image.png

可以看到如下信息：

image.png

找到这个地方，点击它：

image.png

然后输入“MainDemo”，选中这个文件：

image.png

现在就可以在这个地方输入了：

image.png

比如：（中间用空格隔开）

image.png

回到编译器中再次Run，可以发现刚才的数据输出了：

image.png

其实还有其他的方法，这里做了解就好，不必追究。

2.举例2

代码部分：

public class CommandPara {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

//运行程序CommandPara.java
java CommandPara "Tom" "Jerry" "Shkstart"

image.png

IDEA工具：

（1）配置运行参数

image.png

image.png

（2）运行程序

image.png

输出：

//输出结果
args[0] = Tom
args[1] = Jerry
args[2] = Shkstart

（3）笔试题

如下：

//此处，Something类的文件名叫OtherThing.java
class Something {
    public static void main(String[] something_to_do) {        
        System.out.println("Do something ...");
    }
}


//上述程序是否可以正常编译、运行？	可以

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

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

相关文章

SQL零基础入门教程，贼拉详细！贼拉简单！ 速通数据库期末考！（九）

SQL零基础入门教程，贼拉详细！贼拉简单！ 速通数据库期末考！（九）

UNION ALL UNION ALL 用于合并两个或多个 SELECT 语句的结果。 请注意&#xff0c;UNION ALL 合并的每个 SELECT 语句必须是查询相同数量&#xff0c;相同数据类型的字段&#xff0c;且顺序也必须一致。另外结果集中的列名总是等于 UNION ALL 中第一个 SELECT 语句中的列名。 …
阅读更多...
PyQt（学习笔记）

PyQt（学习笔记）

学习资料来源&#xff1a; PyQt快速入门——b站王铭东老师 PyQt&#xff08;学习笔记&#xff09; Pycharm环境准备运行第一个程序QPushButtonQLabelQLineEdit调整窗口大小、位置、图标布局信号与槽PyQt引入多线程 Pycharm环境准备 新建环境——添加PyQt5模块——验证版本 如果…
阅读更多...
视频封面：从视频中提取封面，轻松制作吸引人的视频

视频封面：从视频中提取封面，轻松制作吸引人的视频

在当今的数字时代&#xff0c;视频已成为人们获取信息、娱乐和交流的重要方式。一个吸引人的视频封面往往能抓住眼球&#xff0c;提高点击率和观看率。今天将介绍如何从视频中提取封面&#xff0c;轻松制作吸引人的视频封面。 一、准备素材选择合适的视频片段 首先&#xff0…
阅读更多...
光敏传感器模块（YH-LDR）

光敏传感器模块（YH-LDR）

目录 1. YH-LDR模块说明 1.1 简介 1.2 YH-LDR 模块的引脚说明 1.3 LDR 传感器工作原理与输出特性 2. 使用单片机系统控制 YH-LDR 模块 2.1 通用控制说明 1. YH-LDR模块说明 1.1 简介 YH-LDR 是野火设计的光强传感器&#xff0c;使用一个光敏电阻作为采集源&#x…
阅读更多...
设计模式（二）-创建者模式（2）-工厂模式

设计模式（二）-创建者模式（2）-工厂模式

一、为何需要工厂模式&#xff08;Factory Pattern&#xff09;? 由于简单工厂模式存在一个缺点&#xff0c;如果工厂类创建的对象过多&#xff0c;使得代码变得越来越臃肿。这样导致工厂类难以扩展新实例&#xff0c;以及难以维护代码逻辑。于是在简单工厂模式的基础上&…
阅读更多...
SPASS-距离分析

SPASS-距离分析

基本概念 距离分析是对观测量之间相似或不相似程度的一种测度&#xff0c;是计算一对观测量之间的广义距离。这些相似性或距离测度可以用于其他分析过程&#xff0c;例如因子分析、聚类分析或多维定标分析&#xff0c;有助于分析复杂的数据集。 统计原理 不相似性测度 对定距…
阅读更多...
STM32F4系列单片机GPIO概述和寄存器分析

STM32F4系列单片机GPIO概述和寄存器分析

第2章 STM32-GPIO口 2.1 GPIO口概述 通用输入/输出口 2.1.1 GPIO口作用 GPIO是单片机与外界进行数据交流的窗口。 2.1.2 STM32的GPIO口 在51单片机中&#xff0c;IO口&#xff0c;以数字进行分组&#xff08;P0~P3&#xff09;&#xff0c;每一组里面又有8个IO口。 在ST…
阅读更多...
月子会所信息展示服务预约小程序的作用是什么

月子会所信息展示服务预约小程序的作用是什么

传统线下门店经营只依赖自然流量咨询或简单的线上付费推广是比较低效的&#xff0c;属于靠“天”吃饭&#xff0c;如今的年轻人学历水平相对较高&#xff0c;接触的事物或接受的思想也更多更广&#xff0c;加之生活水平提升及互联网带来的长期知识赋能&#xff0c;因此在寻找/咨…
阅读更多...
【刷题专栏—突破思维】LeetCode 142. 环形链表 II

【刷题专栏—突破思维】LeetCode 142. 环形链表 II

前言&#xff1a;本篇博客将讲解三个OJ题&#xff0c;前两个作为铺垫&#xff0c;最后完成环形链表的节点的寻找 文章目录 一、160. 相交链表二、141. 环形链表三、142. 环形链表II 一、160. 相交链表 题目链接&#xff1a;LeetCode—相交链表 题目描述&#xff1a; 给你两个单…
阅读更多...
【心得】PHP的文件上传个人笔记

【心得】PHP的文件上传个人笔记

目录 1 php的文件上传绕过 黑名单绕过 2 php文件上传的00截断 3 iconv字符转换异常后造成了字符截断 4 文件后缀是白名单的时候的绕过 web服务器的解析漏洞绕过 5.高级文件上传绕过 1 .htaccess nginx.htaccess 2 服务端内容检测 3 配合伪协议来绕过 4.配合日志包含绕…
阅读更多...
2023年【安全员-B证】考试内容及安全员-B证考试资料

2023年【安全员-B证】考试内容及安全员-B证考试资料

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 安全员-B证考试内容参考答案及安全员-B证考试试题解析是安全生产模拟考试一点通题库老师及安全员-B证操作证已考过的学员汇总&#xff0c;相对有效帮助安全员-B证考试资料学员顺利通过考试。 1、【多选题】《中华人民…
阅读更多...
FL Studio2024免费编曲音乐制作软件

FL Studio2024免费编曲音乐制作软件

用FL Studio编曲&#xff0c;让音乐成为你的翅膀&#xff0c;飞翔在无尽的创作海洋中吧&#xff01; FL Studio作为一款功能强大且备受赞誉的音乐制作软件&#xff0c;为你提供了一个独特的创作平台。通过FL Studio&#xff0c;你可以自由地创作、编曲&#xff0c;制作属于自己…
阅读更多...
【算法萌新闯力扣】：旋转字符串

【算法萌新闯力扣】：旋转字符串

力扣热题&#xff1a;796.旋转字符串 开篇 今天下午刷了6道力扣算法题&#xff0c;选了一道有多种解法的题目与大家分享。 题目链接:796.旋转字符串 题目描述 代码思路 完全按照题目的要求&#xff0c;利用StringBuffer中的方法对字符串进行旋转&#xff0c;寻找相同的一项 …
阅读更多...
Fibonacci 数列与黄金分割

Fibonacci 数列与黄金分割

mapp[1 for item in range(30)] for item in range(3,30):mapp[item]mapp[item-1]mapp[item-2]pass numint(input()) if num>19:print("0.61803399")pass else:anss float((mapp[num]*1.0) / (mapp[num 1]*1.0))print(format(anss,.8f))进行短程的打表就可以看出…
阅读更多...
指南：关于帮助中心需要注意的一些细节

指南：关于帮助中心需要注意的一些细节

在现代商业环境中&#xff0c;帮助中心已经成为企业提供客户支持和解决问题的重要方式之一。然而&#xff0c;建立一个高效的帮助中心并不简单。除了选择合适的软件平台和工具之外&#xff0c;还需要注意一些细节&#xff0c;以确保能够真正帮助客户并提高客户满意度。 | 1.设计…
阅读更多...
在Java代码中指定用JAXB的XmlElement注解的元素的顺序

在Java代码中指定用JAXB的XmlElement注解的元素的顺序

例如&#xff0c;下面的类RegisterResponse 使用了XmlRootElement注解&#xff0c;同时也使用XmlType注解&#xff0c;并用XmlType注解的propOrder属性&#xff0c;指定了两个用XmlElement注解的元素出现的顺序&#xff0c;先出现flag&#xff0c;后出现enterpriseId&#xff0…
阅读更多...
图像分类(七) 全面解读复现ShuffleNetV1-V2

图像分类(七) 全面解读复现ShuffleNetV1-V2

ShuffleNetV1 前言 前面我们学了MobileNetV1-3&#xff0c;从这篇开始我们学习ShuffleNet系列。ShuffleNet是Face&#xff08;旷视&#xff09;在2017年发布的一个高效率可以运行在手机等移动设备的网络结构&#xff0c;论文发表在CVRP2018上。这个新的轻量级网络使用了两个新…
阅读更多...
HDFS、MapReduce原理--学习笔记

HDFS、MapReduce原理--学习笔记

1.Hadoop框架 1.1框架与Hadoop架构简介 &#xff08;1&#xff09;广义解释 从广义上来说&#xff0c;随着大数据开发技术的快速发展与逐步成熟&#xff0c;在行业里&#xff0c;Hadoop可以泛指为&#xff1a;Hadoop生态圈。 也就是说&#xff0c;Hadoop指的是大数据生态圈整…
阅读更多...
使用Docker/K8S部署项目流程

使用Docker/K8S部署项目流程

一、制作镜像&#xff1a; 1、创建nginx配置文件default.conf server {listen 80;server_name localhost; # 修改为docker服务宿主机的iplocation / {root /usr/share/nginx/html;index index.html index.htm;try_files $uri $uri/ /index.html 404;}error_page …
阅读更多...
【每日一题】689. 三个无重叠子数组的最大和-2023.11.19

【每日一题】689. 三个无重叠子数组的最大和-2023.11.19

题目&#xff1a; 689. 三个无重叠子数组的最大和 给你一个整数数组 nums 和一个整数 k &#xff0c;找出三个长度为 k 、互不重叠、且全部数字和&#xff08;3 * k 项&#xff09;最大的子数组&#xff0c;并返回这三个子数组。 以下标的数组形式返回结果&#xff0c;数组中…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023