设计模式和排序算法

最新推荐文章于 2022-04-27 19:36:29 发布
最新推荐文章于 2022-04-27 19:36:29 发布
阅读量987 收藏 1
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42513661/article/details/114999862
版权

设计模式

代理模式

给某一个对象提供一个代理，并由代理对象控制对原对象的引用
优点
1.代理模式能够协调调用者和被调用者，在一定程度上降低了系统的耦合度；
2.可以灵活地隐藏被代理对象的部分功能和服务，也增加额外的功能和服务。
缺点
1.由于使用了代理模式，因此程序的性能没有直接调用性能高；
2.使用代理模式提高了代码的复杂度。

静态代理

静态代理其实就是在程序运行之前，提前写好被代理方法的代理类。在程序运行之前，class已经存在。

  • 父母（代理类）给孩子（被代理类）做饭，目的是完成孩子吃饭（代理方法）
  • 学校（代理类）给孩子（被代理类）提供学校，目的是帮助孩子的学习（代理方法）提供学习环境

两个目标接口：IEat，IStudy

interface IEat{
    void eat();
}

interface IStudy{
    void study();
}

被代理类Child

public class Child implements IEat, IStudy{
    
    @Override
    public void eat() {
        System.out.println("吃饭、吃饭！");
    }

    @Override
    public void study() {
        System.out.println("我在看书学习！");
    }
}

代理类：School、Parent

//代理类1：辅助被代理对象，完成某一系列流程。父母，帮助孩子喂饭。
class Parent implements IEat{
    Child target;

    public Parent(Child target) {
        this.target = target;
    }

    @Override
    public void eat() {
        System.out.println("准备饭菜");
        target.eat();
        System.out.println("收拾餐具");
    }
}

//代理类2，学校。为孩子提供学习环境。
class School implements IStudy{
    Child target;
    public School(Child target){
        this.target = target;
    }

    @Override
    public void study() {
        System.out.println("上课了！");
        target.study();
        System.out.println("下课了！");
    }
}
动态代理

动态代理分为：jdk动态代理，需要实现接口。Cglib动态代理，不需要实现接口。

jdk动态代理：核心是一个静态类Proxy和一个接口InvocationHandler。

实现接口 InvocationHandler
public class LogInvocationHandler implements InvocationHandler {

    //被代理对象。
    IEat target;

    //设置被代理对象的值
    public void setTarget(IEat target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我开始我的代理！");
        
        //method.invoke(被代理对象，args参数)
        Object result = method.invoke(target, args);
        
        System.out.println("我结束了我的代理！");
        return result;
    }
}

通过Proxy静态类，获取动态代理类。

public static void main(String[] args) {
    //new一个调度处理程序，并设置被代理目标对象。
    LogInvocationHandler handler = new LogInvocationHandler();
    Child2 child = new Child2();
    handler.setTarget(child);
    
	//通过Proxy.newProxyInstance(代理类加载器，代理类实现接口，实现的调度处理程序)。
    //返回值就是新的代理类。
    IEat iEat = (IEat) Proxy.newProxyInstance(child.getClass().getClassLoader(), child.getClass().getInterfaces(), handler);
    iEat.eat();
}

单例模式

单例模式是一种常用的软件设计模式，在应用这个模式时，单例类必须自己创建自己的唯一实例，保证一个类仅有一个实例，并提供一个访问它的全局访问点。
优点：
不会频繁地创建和销毁对象，浪费系统资源。
避免对资源的多重占用
缺点：
没有接口，不能继承，与单一职责原则冲突
使用场景：IO 、数据库连接、Redis 连接

意图：保证一个类仅有一个实例。

饿汉模式

直接new一个静态对象，需要就拿。线程安全。

public class Singleton3 {

    private static Singleton3 instance = new Singleton3();

    private Singleton3() {}

    public static Singleton3 getInstance() {
        return instance;
    }
}
懒汉模式

需要时，再创建对象。线程不安全。

public class Singleton2 {

    private static Singleton2 instance;

    private Singleton2() {}

    public static synchronized Singleton2 getInstance() {
        //如果没有对象，就new一个对象
        if (instance == null) {
            instance = new Singleton2();
            //instance = new Singleton2();
            //分为三步：1.开辟内存空间。
            //        2.初始化对象。
            //        3.将对象引用赋值给instance
            //遇到指令重排，可能会123，有可能132。
       //如果132，instance不为null，但是未初始化，另外一个线程if判单之后，直接拿个未初始化的对象
        }
        return instance;
    }
}

双重检测：

public class Singleton7 {
	//volatile保证可见性、禁止指令重排、不保证原子性
    private static volatile Singleton7 instance = null;

    private Singleton7() {}

    public static Singleton7 getInstance() {
        if (instance == null) {
            //synchronized保证原子性，因为上锁了，所以指令重排不会影响安全性。
            synchronized (Singleton7.class) {
                if (instance == null) {
                    instance = new Singleton7();
                }
            }
        }
        return instance;
    }
}

工厂模式

意图：定义一个创建对象的接口，让其子类决定决定实例化哪一个工厂类。

public class XXFactory {

    //工厂类实现方法1：通过new对象，如果要添加新的工厂类，需要修改代码。
    public static Animal getAnimal(String animalType){
        if(animalType == null){
            return null;
        }else if(animalType == "dog"){
            return new Dog();
        }else if(animalType == "cat"){
            return new Cat();
        }else if(animalType == "monkey"){
            return new Monkey();
        }else
            return null;
    }

    //工厂类实现方法2：使用反射创建对象，要使用完整的包名。
    //参数animalType必须位全限定名
    public static Animal getAnimal2(String animalType) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Animal obj = (Animal) Class.forName(animalType).newInstance();
        return obj;
    }
}

观察者模式

意图：定义对象间的一种一对多的依赖关系。当被观察对象修改的时候，通知观察者。

被观察者：

public class Subject {

    //用于保存观察者们，用于自身改变时，通知所有观察者
    private List<Observer> observers = new ArrayList<>();
    private int state;

    public int getState() {
        return state;
    }

    //当目标对象改变时，通知所有的观察者。
    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }

    public void notifyAllObservers(){
        for (Observer observer : observers) {
            observer.update();
        }
    }

    public void attach(Observer observer){
        observers.add(observer);
    }
}

观察者：

//实现同一个接口。
interface Observer{
    public void update();
}

//二进制观察者：将被观察者当初成员变量，并且调用被观察者的attach方法，加入到被观察者的列表中。
class BinaryObserve implements Observer{

    private Subject subject;

    public BinaryObserve(Subject subject){
        this.subject = subject;
        subject.attach(this);
    }

    @Override
    public void update() {
        //输出对于的二进制。
        System.out.println("BinaryObserve:" + Integer.toBinaryString(subject.getState()));
    }
}

class OctalObserver implements Observer{
    private Subject subject;

    public OctalObserver(Subject subject) {
        this.subject = subject;
        subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("OctalObserver:" + Integer.toOctalString(subject.getState()));
    }
}

class HexObserver implements Observer{
    private Subject subject;

    public HexObserver(Subject subject) {
        this.subject = subject;
        subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("HexObserver:" + Integer.toHexString(subject.getState()));
    }
}

排序算法

image-20210318214715736

辅助记忆：

  • 时间复杂度记忆
    • 冒泡、选择、直接 排序需要两个for循环，每次只关注一个元素，平均时间复杂度为O（n2）O（n2）（一遍找元素O(n)O(n)，一遍找位置O(n)O(n)）
    • 快速、归并、希尔、堆基于二分思想，log以2为底，平均时间复杂度为O(nlogn)O(nlogn)（一遍找元素O(n)O(n)，一遍找位置O(logn)O(logn)）
  • 稳定性记忆-“快希选堆”（快牺牲稳定性）
  • 排序算法的稳定性：排序前后相同元素的相对位置不变，则称排序算法是稳定的；否则排序算法是不稳定的。

插入排序

1.数组第一个值默认有序。

2.判断待排序值插入在有序数组中的位置

3.不断重复2，直到遍历完数组。

核心：insetIndex，如果小于该位置值，继续前移，直到找到index。

package com.hx.sort;

import java.util.Arrays;
/**
 * 插入排序：
 * 1、数组第一个值默认有序。
 * 2、标记要插入元素的下标与值。
 * 3、插入到有序数组中。
 * 4、重复2、3直到数组遍历完。
 * */
public class ChaRu {
    public static void main(String[] args) {
        ChaRu chaRu = new ChaRu();
        System.out.println(Arrays.toString(chaRu.array));
        chaRu.insertStore();
        System.out.println(Arrays.toString(chaRu.array));
    }

    int[] temp = new int[20];
    int[] array = {5,4,7,8,13,6,6, 11,10,6,3,9,1};

    public void insertStore(){
        //遍历元素
        for(int i = 1; i < array.length - 1; i++){
            //要插入元素的下标与值。
            int insertValue = array[i];
            int insertIndex = i;

            //选择在有序数组中插入的位置。
            while (insertIndex > 0){
                //如果成立，insetIndex就是插入的位置
                if(array[insertIndex-1] < insertValue){
                    break;
                }
                //如果不是，后移数组
                array[insertIndex] = array[insertIndex - 1];
                insertIndex--;
            }
            array[insertIndex] = insertValue;
        }

    }
}

快速排序

快速排序之所比较快，每次交换是跳跃式的每次排序的时候设置一个基准点，
将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边
时间复杂度：最好O( nlog2n)，最坏O( n^2 )，平均O( nlog2n)，不稳定

1.找一个中心轴，默认数组左边第一个。

2.定义两个指针left与right，从right开始向左移，比中心轴小就放入left（由于left就是中心轴，可以直接覆盖）

3.从left开始右移，比中心轴大就放入right。

4.继续23，直到left与right重合。将中心轴放入重合位置。

5.中心轴将数组分割左右两个数组，继续对左右两个数组进行1234 。直到数组不可分割。

package com.hx.sort;

import java.util.Arrays;

public class KuaiPai {

    public static void main(String[] args) {
        KuaiPai kuaiPai = new KuaiPai();
        System.out.println(Arrays.toString(kuaiPai.array));

        kuaiPai.quickStore(0, (kuaiPai.array.length - 1));
        System.out.println(Arrays.toString(kuaiPai.array));
    }

    int[] temp = new int[20];
    int[] array = {5,4,7,8,13,6,6, 11,10,6,3,9,1};

    public void quickStore(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //基准位
        temp=arr[low];
        while(i<j){
            //先右边往左边递减
            while(arr[j]>=temp&&i<j){
                j--;
            }
            //再左边往右边递增
            while(arr[i]<=temp&&i<j){
                i++;
            }
            //满足条件则交换
            if(i<j){
                t=arr[i];
                arr[i]=arr[j];
                arr[j]=t;
            }
        }
        //i=j,交换基准位
        arr[low]=arr[i];
        arr[i]=temp;
        //递归基准位左边的数组
        quickStore(arr,low,j-1);
        //i递归基准位右边的数组
        quickStore(arr,j+1,high);
    }
}

归并排序

分治法，将数组拆分为一个个小问题。

不断将数组一分为二，直到不可拆分，然后再将数组合并，在合并的时候，进行排序。

package com.hx.sort;

import java.util.Arrays;

public class GuiBing {

    public static void main(String[] args) {
        GuiBing guiBing = new GuiBing();
        System.out.println(guiBing.toString());

        guiBing.mergeSort(0,(guiBing.array.length - 1));
        System.out.println(guiBing.toString());
    }

    int[] temp = new int[20];
    int[] array = {5,4,7,8,13,6,6, 11,10,6,3,9,1};

    public void mergeSort(int left, int right){
        int mid = (left + right)/2;
        if(left < right){
            mergeSort(left, mid);//左边小数组
            mergeSort(mid+1, right);//右边小数组
            merge(left, right);//合并左右两个小数组
        }
    }

    public void merge(int left, int right){
        int i = 0;//
        int mid = (left + right)/2;
        int l = left;
        int r = mid + 1;

        while (l <= mid && r <= right){//对左右两个小数组排序，当其中一个数组遍历完，就结束。
            if(array[l] < array[r]){
                temp[i] = array[l];
                l++;
            }else {
                temp[i] = array[r];
                r++;
            }
            i++;
        }

        //另一个没有遍历完的数组直接加在temp后面
        while (l <= mid){
            //左边没有遍历完
            temp[i] = array[l];
            l++;
            i++;
        }

        while (r <= right){
            //右边没有遍历完
            temp[i] = array[r];
            r++;
            i++;
        }

        //将排好序的temp，替换array中的位置。
        i = 0;
        while (left <= right){
            array[left] = temp[i];
            i++;
            left++;
        }
    }

    @Override
    public String toString() {
        return "GuiBing{" +
                "array=" + Arrays.toString(array) +
                '}';
    }
}

冒泡排序

冒泡排序：比较两个相邻的元素，将值大的元素交换到右边
时间复杂度：最坏O( n^2 )，最好O( n）稳定

public static void sort1(int[] arr){
        int t;
        for (int i = 0; i <arr.length-1 ; i++) {
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    t=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=t;
                }
            }
        }
        System.out.println(arr.length);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }

选择排序:

从头至尾扫描序列，找出最小的一个元素，和第一个元素交换，
接着从剩下的元素中继续这种选择和交换方式，最终得到一个有序序列
时间复杂度：O( n^2 )，不稳定

 public static void sort2(int[] arr){
            int t;`在这里插入代码片`
            for(int i=0;i<arr.length-1;i++){
                for(int j=i+1;j<arr.length;j++){
                    if (arr[i] > arr[j]) {
                        t=arr[i];
                        arr[i]=arr[j];
                        arr[j]=t;
                    }
                }
            }
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]);

            }
        }

二分查找

 public static void sort3(int[] arr,int value){
        int start=0,end=arr.length-1;
        int count=0;
        int mid=(start+end)/2;
        while(arr[mid]!=value){
            if(arr[mid]>value){
                end=mid;
                count++;
            }else if(arr[mid]<value){
                start=mid;
                count++;
            }
            mid=(start+end)/2;
            if(start>end){
                return ;
            }
        }
        System.out.println("查询次数:"+count+"位置:"+mid);
    }
龙孚3拳
关注
专栏目录
设计模式--组合模式--商品排序案例
山水间的漫步者
08-20 4979
所有的例子均来源与实际开发项目 本节介绍组合模式的使用–商品结果排序评分系统
Java基础简历6--设计模式--排序算法
cclliii的博客
10-09 375
Reactor（反应器）模式-为处理并发服务请求，并将请求提交到一个或者多个服务处理程序的事件设计模式。当客户端请求抵达后，服务器处理程序使用多路分配策略，由一个非阻塞的线程来接收所有的请求，然后派发这些请求至相关的工作线程进行处理。 首先是事件驱动的，有一个或多个并发输入源，有一个Service Handler，有多个Request Handlers；这个Service Handler会同步的...
简要介绍设计模式（按字典序排列A-Z）
sandays_cn的专栏
04-29 386
 Abstract Factory（抽象工厂模式）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 Adapter（适配器模式）：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 Bridge（桥接模式）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。 Builder（建造者模式）：将...
排序算法和设计模式
热门推荐
编程之路的专栏
03-12 1万+
两种基本排序算法 冒泡排序 相邻元素两两进行比较，大的往后放，第一次比较完毕后，最大值在最大索引处。循环进行，直到全部比完。 代码： public static voidbubbleSort(int[] arr) {
九、设计模式以及查找、排序算法
Karen博客
08-28 365
九、设计模式 1. 说一下你熟悉的设计模式？ 2. 简单工厂和查询工厂有什么区别？
TemplateDPMerge:模板设计模式和归并排序算法的实现
06-04
在本练习中，您必须使用模板方法模式。 下面是 Sequence 界面。 当使用来自 SC1（第一学期）的合并骨架合并两个序列时，将使用此接口。 所有序列都包含实现 Comparable 接口的对象。 public interface Sequence...
常用设计模式与算法的使用
最新发布
10-07
在软件开发中，设计模式和算法是至关重要的概念，它们能帮助我们编写可维护、可扩展的高效代码。本文将详细探讨三个常见的设计模式：工厂方法模式、简单工厂模式和抽象工厂模式，以及它们在实际应用中的作用。 首先...
bajins-java-clazz:Java基础，多线程，设计模式，排序算法，数据结构等
03-28
4. **排序算法**：排序是计算机科学中的基础算法，项目可能包括冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等，并对每种算法的时间复杂度和空间复杂度进行分析。 5. **数据结构**：数据结构是有效...
软件工程师必备算法和设计模式的知识
07-31
在软件开发领域，算法与设计模式是两个至关重要的概念，对于任何希望提升自己技能的软件工程师来说，理解和掌握它们都是必不可少的。算法是解决问题的精确步骤，而设计模式则是解决常见编程问题的经验总结。让我们...
java设计模式四大常用架构迭代模型并行排序算法.pdf
11-24
Java 设计模式四大常用架构迭代模型并行排序算法 Java 设计模式是软件工程中的一种思想，旨在提高软件的重用性和可维护性。1995 年，著名的书籍《Design Pattern》出版，总结了 23 种经典的设计模式，成为软件设计...
java设计模式_四大常用架构_迭代模型_并行排序算法
09-27
java设计模式_四大常用架构_迭代模型_并行排序算法
排序与设计模式
ych19871020的专栏
05-19 758
我们一般在客户端会留统一接口从而动态xuanz
对接多种三方的设计模式_自学程序---趣解常见的排序算法顺带几种常见的设计模式...
weixin_39526185的博客
12-08 492
零 文章概要 壹 前言贰 桶排序与常用设计模式的结合实践叁 冒泡排序肆 选择排序伍 插入排序陆 快速排序柒 计数排序 捌 归并排序 玖 希尔排序 拾 堆排序 拾壹 结尾语壹 前言 本来想着单独总结一篇有关设计模式的文章，可是23种设计模式中，我们常用的也就那么几个，而且有些设计模式不用我们刻意使用，比如享元模式（有些万年不变的东西，可能时不时的被用到，所以我们提前创造出来...
设计模式:选择排序(select sorting)
m0_37564426的博客
01-06 299
import java.util.Arrays; public class SelectSort { public static void main(String[] args) { int[] arr = {8,1,4,5,3,6,2,7}; selectSort(arr); System.out.println(...
Java8集成多种排序算法 (冒泡、选择、插入、希尔、快速及归并排序)
因吉的博客
11-12 428
引入   实现排序算法：   1）bubble；   2）select；   3）insert；   4）shell；   5）quick；   6）merge。   使用示例如下，默认排序方式为快速排序： MySort test = new MySort(new int[]{ 14, 67, 96, 37, 93, 39, 18, 49, 91, 7, 58, 35, 34, 36, 64, 61, 65, 70, 88, 59, 68,
Java相关面试题总结+答案（五）
weixin_30496431的博客
05-02 122
【异常】 74. throw 和 throws 的区别？ throw 是真实抛出一个异常； throws 是声明可能会抛出一个异常。 75. final、finally、finalize 有什么区别？ final：是修饰符，可以修饰类、方法、变量，如果修饰类，此类不能被继承；如果修饰方法，此方法不能被重写（override）；如果修饰变量，则该变量是不可修改的，即变量变成...
java中关于排序方式的实例讲解
gp16674213804的博客
04-27 143
Java属于入门容易，天花板却极高的编程语言。java中关于排序方式的实例讲解?对于java工程师来说技术的不断发展,需要不断学习java进阶知识。为了帮助大家巩固基础，本文解答了java中关于排序方式的实例讲解等相关问题，希望可以帮到大家。 java中关于排序方式的实例讲解 冒泡排序 特点：效率低，实现简单 思想(从小到大排)：每一趟将待排序序列中最大元素移到最后，剩下的为新的待排序序列，重复上述步骤直到排完所有元素。这只是冒泡排序的一种，当然也可以从后往前排。 选择排序 特点：效率低，容
常用排序算法与实现
lx1997530的博客
03-07 243
1. 插入排序 1.1直接插入排序
各种排序算法的整合
为了守护世界的和平
04-23 157
**相关代码： #include<iostream> using namespace std; //内部排序 插、交、选、归、基 /** 一、插入排序 1）直接插入排序，找到插入位置，插入位置的元素往后移动 2）折半插入排序，是对寻找插入位置的时间复杂度进行的优化，用到分治的思想 相应的每一趟中比较的次数会减少，每趟比较的次数为O(log2n); 3）希尔排序（缩小增量排序）,先追求表中的元素部分有序，在逐渐逼近全局有序 */ /** 1、直接插入排序 */ void InsertSort(i
"设计模式与算法：工厂方法模式的实现与应用
设计模式是软件工程中常用的重要概念，通过对重复出现的设计问题进行总结和抽象，提出了各种常用的设计模式，从而遵循了面向对象设计原则，实现了代码的可维护性和灵活性。常用的设计模式包括工厂方法模式、单例模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值