枚举 + 单例模式 + 双链表

最新推荐文章于 2024-10-12 01:17:55 发布
最新推荐文章于 2024-10-12 01:17:55 发布
阅读量39 收藏
点赞数
文章标签： 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70054514/article/details/132679233
版权
枚举：

用来定义一组命名的常量，存放的都是有关的常量。

关键字：enum

有构造函数，默认private修饰，不能实例化，不能继承，有成员

定义多个实例用 , 最后一个使用 ;

都属于java.lang.Enum的子类

继承的方法：

ordinal() : 返回实例声明的索引

static values() : 将枚举的所有对象存到数组中

static valueOf() : 返回对象所在的下标

public enum Day {
    SUNDAY("星期天"),MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),THURSDAY("星期四"),
    FRIDAY("星期五"),SATURDAY("星期六");
    private String name;
    Day(String name){ //构造默认方法私有，不能实例化
       this.name = name;
    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }


}
class TestEnum {
    public static void main(String[] args) {
        Day day = Day.SATURDAY;
        System.out.println(day);  //SATURDAY
        System.out.println(day.getName()); //星期六
        System.out.println(day.ordinal());//返回声明时所在的位置  6
        Day[] days = Day.values(); //将Day中的每一个对象存到数组中
        for (Day day1 : days) {
            System.out.print(day1 + " ");
        }
        System.out.println();

        System.out.println(Day.valueOf("TUESDAY"));  //通过常量名获取对应的枚举实例

        day.setName("Sunday");
        System.out.println(day.getName()); //Sunday

    }
}
单例模式：

只有一个实例（一个类）

注：

  • 只有一个实例

  • 自己创建自己

  • 给其他对象提供这一实例

实现：

私有构造，对外不能访问

提供对外访问方法，static(外部不创建对象)

获取实例：

1.饿汉模式：

创建对象直接赋值，对象私有，静态常量

缺点：从未使用过这个实例，造成内存浪费

public class HungrySingleton {
    //饿汉模式：创建对象时直接赋值，对外提供static访问方法，构造私有
    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private String name = "Hungry";
    private HungrySingleton(){}
    public static void getHS(){
        System.out.println(hungrySingleton.name);
    }

}

class HungrySingletonTest{
    public static void main(String[] args) {
        HungrySingleton.getHS();
    }
}

2.懒汉模式

在对外方法中赋值，单线程下使用

public class LazySingleton {
    //懒汉模式：在对外提供的方法中赋值
    private static LazySingleton lazySingleton;
    private String name = "Lazy";
    private LazySingleton(){}
    public static LazySingleton getLS() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        } else {
            return lazySingleton;
        }
       return lazySingleton;
    }
}

class LazySingletonTest{
    public static void main(String[] args) {
        System.out.println(LazySingleton.getLS());
    }
}

3.静态内部类

在外类，构造私有，提供方法返回内部类属性

在内部类创建对象

优点：避免线程不安全，延迟加载，效率高

public class InnerSingleton {
    //静态内部类：在内部类中创建外部类对象，在外部类中static方法中返回内部类对象属性
    public static InnerSingleton getINS(){
        return Inner.innerSingleton;
    }
    private InnerSingleton(){
        System.out.println();
    }

    class Inner{
        private static InnerSingleton innerSingleton = new InnerSingleton();

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

    }
}

双链表：

import java.util.Objects;

public class DoubleLinked {
    //双链表
    private Node first;
    private Node last;
    private int count;

    //尾部添加元素
    public boolean add(Object o) {
        Node current = new Node(null, o, null);
        if (first == null) {
            first = current;
            last = first;
            count++;
            return true;
        }
        last.next = current;
        current.prev = last;
        last = current;
        count++;
        return true;
    }

    //删除第一个元素
    public boolean removeFirst() {
        if (first == null) { //为空
            return false;
        }
        if (first.next == null) { //只有一个元素
            first = null;
            last = null;
            count--;
            return true;
        }
        Node node = first.next; //含其他元素
        node.prev = null;
        first = node;
        count--;
        return true;
    }

    //删除最后一个元素
    public boolean removeLast() {
        if (last == null) { //为空
            return false;
        }
        if (first == last) { //只有一个元素
            first = null;
            last = null;
            count--;
            return true;
        }
        Node node = last.prev; //含有其他元素
        node.next = null;
        last = node;
        count--;
        return true;
    }

    //删除其他元素
    public boolean removeNode(Object o) {
        if (isEmpty()){
            return false;
        }
        if (Objects.equals(first.value, o)) {  //要删除的元素等于第一个
            return removeFirst();
        }
        if (Objects.equals(last.value, o)) {   //要删除的元素等于最后一个
            return removeLast();
        }
        Node node = first.next;
        while (!Objects.equals(node.value, o)) {  // 2
            node = node.next;                    //  3
            if (node == null) {             //   4
                return false;
            }
        }
        Node current = node.prev;  //要删除元素的前一个元素
        Node temp = node.next;     //要删除元素的前一个元素
        current.next = temp;  //前一个元素的下一个位置指向current的后一个元素
        temp.prev = current;
        count--;
        return true;
    }

    //转换成字符串输出
    @Override
    public String toString() {
        if (isEmpty()) {
            return null;
        }
        Node node = first;
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        while (node != last) {
            sb.append(node.value + "，");
            node = node.next;
        }
        sb.append(last.value + "]");
        return sb.toString();
    }

    //输出指定位置的元素
    public Object getElement(int index) {
        if (isEmpty()) {
            return null;
        }
        if (index < 0 || index > count) {
            return null;
        }
        Node node = first;
        int num = 0;
        while (num <= index) {
            node = node.next;
            if (node == null) {
                return null;
            }
            num++;
        }
        return node.value;
    }

    //返回指定元素的下标
    public int getIndex(Object o) {
        if (!isContain(o)) {
            return -1;
        }
        Node node = first;
        int num = 0;
        while (!Objects.equals(node.value, o)) {
            node = node.next;
            if (node == null) {
                return -1;
            }
            num++;
        }
        return num;
    }

    //在指定位置插入元素
    public boolean insertElement(Object o, int index) {
        Node node = new Node(null, o, null);
        if (index < 0 || index > count){
            return false;
        }
        if (index == 0) { //下标为0
            if (isEmpty()) {  //为空
                first = node;
                last = node;
                count++;
                return true;
            }else {  //不为空
                node.next = first;
                first.prev = node;
                first = node;
                count ++;
                return true;
            }
        }
        Node la = last;
        if (index == count - 1){  //在最后一个位置插入
            node.next = la;
            la.prev.next = node;


            count ++;
            return true;
        }
        if (index == count){ // 在count位置插入
            last.next = node;
            node.prev = last;
            last = node;
            count ++;
            return true;
        }
        Node current = first;
        int num = 0;
        while (num != index){
            current = current.next;
            if (current == null){
                return false;
            }
            num ++;
        }
        node.next = current.next;
        current.next = node;


        count ++;
        return true;
    }

    //判断是否为空
    public boolean isEmpty() {
        return count == 0;
    }

    //判断是否包含该元素
    public boolean isContain(Object o) {
        if (isEmpty()) {
            return false;
        }
        Node node = first;
        while (!Objects.equals(node.value, o)) {
            node = node.next;
            if (node == null) {
                return false;
            }
        }
        return true;
    }

    //获取链表长度
    public int size() {
        return count;
    }


    class Node {
        private Node prev;
        private Object value;
        private Node next;

        public Node(Node prev, Object value, Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }

        public Object getValue() {
            return value;
        }
    }
}
public class DoubleLinkedTest {
    public static void main(String[] args) {
        DoubleLinked doubleLinked = new DoubleLinked();
        System.out.println(doubleLinked.add(1));
        System.out.println(doubleLinked.add(2));
        System.out.println(doubleLinked.add(3));
        System.out.println(doubleLinked.add(4));
        System.out.println(doubleLinked.add(5));

        System.out.println("获取链表长度：" + doubleLinked.size());
        //转换成字符串输出
        System.out.println("转换成字符串输出: " + doubleLinked);

        //在指定位置插入元素
        System.out.println("在指定位置插入元素：" + doubleLinked.insertElement(3, 5));
        System.out.println("转换成字符串输出: " + doubleLinked.toString());

        System.out.println("获取链表长度：" + doubleLinked.size());

        //输出指定位置的元素
        System.out.println("转换成字符串输出: " + doubleLinked);
        System.out.println("输出指定位置的元素：" + doubleLinked.getElement(4));

        System.out.println("判断是否包含某个元素：" + doubleLinked.isContain(-1));

        //返回指定元素的下标
        System.out.println("转换成字符串输出: " + doubleLinked);
        System.out.println("返回指定元素的下标：" + doubleLinked.getIndex(4));

        //删除其他位置的元素
        System.out.println("转换成字符串输出: " + doubleLinked);
        System.out.println("删除其他位置的元素：" + doubleLinked.removeNode(1));

        //删除第一个元素
        System.out.println("转换成字符串输出: " + doubleLinked);
        doubleLinked.removeFirst();
        System.out.println("删除第一个元素 ：" + doubleLinked);

        //删除最后一个元素
        System.out.println("转换成字符串输出: " + doubleLinked);
        doubleLinked.removeLast();
        System.out.println("删除最后一个元素：" + doubleLinked);


    }
}

运行结果：

少年的云和月(^～^)
关注
2020-10-23 集合+序列化+递归+多线程+泛型+枚举+单例+反射小记
qq_36095102的博客
10-23 312
1.集合 Collection接口 (Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是Set和List) Set接口(无序集合，不允许重复，检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变) HashSet(无序,以哈希表的形式存放元素，插入删除速度很快) LinkedHashSet SortedSet
查找和排序 + 集合 + 单例模式【学习笔记】Java 基础
做笔记，记录学习中遇到的问题。
09-17 597
本文讲述了几种重要的查找和排序、集合、单例模式。
单例模式、多例模式、枚举、工厂模式
copyright0501的博客
06-06 215
例模式、多例模式、枚举、工厂模式 第一章 单例设计模式 1. 单例设计模式作用 让一个类,最最最最多只能有一个对象 2. 单例设计模式实现步骤 a.构造方法私有化 b.我们要在类内部,创建一个静态的该类对象 c.我们要提供一个静态方法,用户可以通过静态方法获取刚刚我们准备的那个对象 3 单例设计模式的类型 a.饿汉式单例: 编写静态对象时,直接通过new 类名()赋值 b.懒汉式单例: 编写静态对象时,我们只定义对象,当用户调用getInstance方法,在方法中再创建对象 4
详解单例设计模式
shkstart的博客
08-03 284
什么是单例模式? 单例模式是为确保一个类只有一个实例，并为整个系统提供一个全局访问点的一种模式方法。 从概念中体现出了单例的一些特点： 在任何情况下，单例类永远只有一个实例存在 单例需要有能力为整个系统提供这一唯一实例 在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当
枚举类+注解+集合
cencen666的博客
06-05 352
第十二周总结 5.16 文章目录枚举类 枚举类 一、枚举类的使用 1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类 2.当需要定义一组常量时，强烈建议使用枚举类 3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式。 二、如何定义枚举类 方式一：jdk5.0之前，自定义枚举类 public class SeasonTest { public static void main(String[] args) { Season spring = Season.
排序算法、HashMap原理以及单例模式
King Gigi的博客
05-24 1636
二分查找、排序算法、数组和链表、HashMap原理、单例模式的五种实现方式
【iOS 】—— 单例模式，通知模式和代理模式
qq_72437394的博客
07-29 597
单例模式在整个工程中，相当于是全局变量，就是不论在哪里需要用到这个类的实例变量，都可以通过单例方法来取得，一旦创建一个单例类，不论在哪里调用这个单例方法，创建的所有对象都指向同一块内存地址。（即单例类保证了该类的实例对象是唯一存在的一个）存储是以name和object为维度，判断是不是同一个通知要从name和object区分。存储过程并没有做去重操作，这也解释了为什么同一个通知注册多次则响应多次。发送通知使用方法:，或者发送通知，后者默认userInfo为nil// 发送通知。
Java常用设计模式——单例模式
qq_44543551的博客
02-23 203
3.1、单例模式 （1）简介 定义： 指一个类只有一个实例，且该类能自行创建这个实例，并提供对实例的全局访问方法的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 特点： 单例类只有一个实例对象； 该单例对象必须由单例类自行创建自己的唯一实例； 单例类对外提供一个访问该单例的全局访问点； ...
JAVA基础之设计模式和枚举
Hackpatrick的博客
11-28 181
枚举 枚举是JDK1.5版本新增的特性(泛型、For-each等如今被广泛应用的特性也是由JDK1.5时所新增的)，另外到了JDK1.6后switch语句支持枚举类型； 枚举的使用情况： 有的时候一个类的对象是有限且固定的，这种情况下我们使用枚举类就比较方便； 枚举就是将所有的有限的类对象先定义好； 语法 public enum 枚举类名{ //枚举的所有对象都必须在第一行定义好 } 比如...
Java之枚举和设计模式
xing_ran_ran的博客
11-28 518
一. 枚举类 (1)语法 public enum 枚举类名{      } (2)适用场景： 当对象的个数已经固定，并有限时，例如：性别，星期等等() 举例： //定义一个枚举类 public enum Sex { //男性 MALE, //女性 FEMALE } (3)枚举类中常用的方法 //枚举类中常用的方法 //1...
Netty 中应用了哪些设计模式？
悟已往之不谏，知来者之可追
02-06 460
Netty 源码中运用了大量的设计模式，常见的设计模式在 Netty 源码中都有所体现。 文章目录单例模式双重检验锁静态内部类方式饿汉方式枚举方式工厂方法模式责任链模式责任处理器接口动态创建责任链，添加、删除责任处理器上下文责任传播和终止机制观察者模式策略模式装饰者模式总结 单例模式 单例模式是最常见的设计模式，它可以保证全局只有一个实例，避免线程安全问题。单例模式有很多种实现方法，其中我比较推荐四种最佳实践：双重检验锁、静态内部类方式、饿汉方式和枚举方式，其中双重检验锁和静态内部类方式属于懒汉式单例，饿汉
设计模式之美
白夜行
04-13 1092
介绍26种设计模式与常用设计原因，教你如何写出高质量的代码
超详细的Java面试题汇总（基础篇+框架篇）
qq_24047659的博客
03-09 642
Java面试题汇总-基础篇 1.面向对象是什么？ 答：面向对象是一种思想，世间万物都可以看做一个对象，这里只讨论面向对象编程（OOP），Java是一个支持并发、基于类和面向对象的计算机编程语言 面向对象软件开发的优点：代码开发模块化，更易维护和修改；代码复用性强；增强代码的可靠性和灵活性；增加代码的可读性。 2、String 是最基本的数据类型吗？ 答：不是。Java中的基...
不继承Mono的单例模式基类
2301_76618920的博客
10-12 240
不继承Mono的单例模式基类
设计模式：单例模式
HR_Reborn的博客
10-09 231
单例模式保证一个类只有一个实例，并且提供了全局访问该实例的方法。而懒汉则是有一种能少创建就少创建的偷懒的感觉，即只要在第一次调用获取实例的方法时才会创建唯一实例，从而节省资源。总结：饿汉单例适合在程序启动时资源充足，且需要立即使用单例的场景。懒汉单例适合资源敏感的场景，或者单例实例较大且不一定每次都需要实例化时使用。饿汉就是一点不顾一切的感觉，在类加载的时候就创建唯一的单例实例，不论该实例是否会被使用。在写具体代码之前还需要知道单例模式的两种分类，饿汉和懒汉。所谓的饿和懒其实是创建实例的状态形容。
2. 继承Mono的单例模式基类
最新发布
2301_76618920的博客
10-12 183
2.切换场景回来时，由于场景放置了挂载脚本的对象，回到该场景时 又会有一个该单例模式对象。3.还可以通过代码动态的添加多个该脚本 也会破坏唯一性。需要人为干涉，定规则，或者通过代码逻辑强制处理。因为很容易被破坏单例模式的唯一性。
单例模式（C++）
麦克·唐
10-11 138
原理：当多个线程尝试初始化同一个静态局部变量时，C++11标准保证只有一个线程能够成功执行初始化代码，而其他线程则会被阻塞，直到初始化完成。饿汉模式之所以线程安全是因为在main函数执行之前，全局作用域的类成员静态变量就已经完成了初始化。因此，饿汉模式不需要考虑多线程环境下的线程安全问题，因为实例的创建和初始化在多个线程可能开始执行之前就已经完成了。饿汉模式：优点是绝对的线程安全，但是有可能会增加程序启动时间。：一个类只能有一个实例，并且提供一个可全局访问获取该实例接口。懒汉模式：初次使用的时候初始化。
单例模式：Python中的“独一无二”模式
m0_71948321的博客
10-04 596
单例模式是一种常用的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式在需要控制资源消耗、管理共享资源或者协调系统组件时非常有用。例如，数据库连接、配置文件管理、日志记录等场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值