代理模式

最新推荐文章于 2024-08-18 23:25:39 发布
最新推荐文章于 2024-08-18 23:25:39 发布
阅读量278 收藏 1
点赞数
分类专栏： 设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43381785/article/details/108353666
版权

代理模式（proxy）

1. 定义代理模式

代理模式为另一个对象提供了一个替身或占位符以控制对这个对象的访问。

使用代理创建代表（representiative）对象。让代表对象控制某对象的访问，被代理的对象可以是远程对象，创建开销大的对象或需要安全控制的对象。

类图：

«interface» Subject request() Proxy request() RealSubject request() subject
  • RealSubject和Proxy实现了共同的接口，这允许任何客户都可以像处理RealSubject对象一样处理Proxy对象
  • RealSubjct是真正做事的对象，它是被Proxy代理和控制访问的对象。
  • Proxy拥有RealSubject的引用，甚至有时候负责RealSubject对象的创建与销毁。

2. 远程代理(RMI)

2.1 Java RMI 概观

Java RMI，即 远程方法调用(Remote Method Invocation)，一种用于实现远程过程调用(RPC)(Remote procedure call)的Java API， 能直接传输序列化后的Java对象和分布式垃圾收集。它的实现依赖于Java虚拟机(JVM)，因此它仅支持从一个JVM到另一个JVM的调用。

RMI 将客户辅助对象称为stub(桩)，服务辅助对象称为skeleton(骨架)。

RMI原理图

2.2 RMI 实现

步骤一：定义远程接口
定义要供客户远程调用的方法

  1. 扩展java.rmi.Remote接口，这是一个标记接口。
  2. 所有远程方法都抛出RemoteException异常。
  3. 返回类型必须可序列化(实现了Serializable接口)或者为原语类型。
// 远程接口 扩展了 java.rmi.Remote接口，这是个标记接口
public interface MyRemote extends Remote {
	/**
	 * 所有的远程方法都必须声明RemoteExeception
	 * @return 返回值必须是实现了 Serializable 或者 原语类型
	 * @throws RemoteException 代表是有风险的
	 */
	public String sayHello() throws RemoteException; 
}

步骤二：实现远程接口

  1. 实现远程接口。
  2. 扩展java.rmi.server.UnicastRemoteObject，让超类帮我们做某些“远程功能”的工作。
  3. 使用LocateRegistry.getRegistry()静态方法获取Registry。
  4. 使用RMI Registry的bind、rebind方法注册服务，端口默认为1099。
  5. 开启终端。
/**
 * 扩展自UnicastRemoteObject，让超类帮我们做"远程"工作
 */
public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote {
	// 超类构造器抛出了异常，我们必须处理
	protected MyRemoteImpl() throws RemoteException {}
	// 不需要声明RemoteException
	public String sayHello() {
		return "Server says: 'Hey'";
	}
	public static void main(String[] args) {
		try {
			MyRemote service = new MyRemoteImpl();
			LocateRegistry.createRegistry(1099);
			// 注册服务，让客户可查询调用
			// 注册到 RMI registry(在服务器上)
			Registry registry = LocateRegistry.getRegistry();
			registry.bind("RemoteHello", service);
			System.out.println("RMI Server ready!");
		    } catch (RemoteException e) {
			e.printStackTrace();
		} catch (AlreadyBoundException e) {
			e.printStackTrace();
		}
	}
}

服务端开启成功时：

RMI Server ready!

步骤三：制作客户端

  1. 根据ip地址和port端口获取指定的RMI Registry。
  2. 使用Registry 的 lookup方法寻找stub对象（代理对象）。
  3. 像使用本地对象方法那样调用远程方法。
  4. 开启另一个终端。
public class MyRemoteClient {
	public static void main(String[] args) {
		new MyRemoteClient().go();
	}
	public void go() {
		try { 
			// 需要ip地址或者主机名 和 服务被绑定/重绑定时用的名称
			Registry registry = LocateRegistry.getRegistry("localhost");
			MyRemote service = (MyRemote)registry.lookup("RemoteHello");
			System.out.println(service.sayHello());
		} catch (RemoteException e) {
			e.printStackTrace();
		} catch (NotBoundException e) {
			e.printStackTrace();
		} 
		
	}
}

成功调用远程方法结果：

Server says: 'Hey'

注意：必须先开启服务端，注册Registry服务，即在服务端创建stub类，然后在客户端RMI Registry才能找到相应的服务（stub类）。

2.3 工作方式

RMI工作方式图

3. 虚拟代理(Virtual Proxy)

3.1 概观

虚拟代理：经常直到我们真正需要对象时才创建它。当对象在创建前和创建中时，由虚拟代理来扮演对象的替身。对象创建后，代理将请求直接委托给对象。
虚拟代理图

3.2 设计CD封面虚拟代理

需求
使用 Swing创建一个 Icon接口从网络上加载CD封面图片，并且在等待加载时，显示一些东西，加载完成后，图像就显示出来。
设计
使用 虚拟代理代理 Icon，管理加载，在加载未完成时显示“CD封面加载中，请稍后…”，加载完成后，代理把显示的责任 委托给 Icon。

类图：

«interface» Icon getIconWidth() getIconHeight() paintIcon() ImageProxy getIconWidth() getIconHeight() paintIcon() ImageIcon getIconWidth() getIconHeight() paintIcon()

运作方式：

  1. ImageProxy创建一个ImageIcon，然后开始在网络URL上加载图像。
  2. 在加载过程中，ImageProxy显示"CD封面加载中，请稍后…"。
  3. 当加载完成后，ImageProxy把所有方法调用委托给真正的ImageIcon。
  4. 如果用户请求新的图像，我们就创建新的代理，重复这样的操作。

3.3 实现虚拟代理

编写ImageProxy图像代理类：

public class ImageProxy implements Icon {
	ImageIcon imageIcon; // 拥有ImageIcon对象的引用
	URL imageURL;
	boolean retrieval = false; // 是否取回
	
	public ImageProxy(URL imageURL) {
		this.imageURL = imageURL;
	}
	// 实现Icon接口方法
	// 当需要在屏幕上绘制图像时，就会调用该方法
	public void paintIcon(final Component c, Graphics g, int x, int y) {
		if(imageIcon != null) // 加载完成后
			imageIcon.paintIcon(c, g, x, y);
		else { // 加载前和加载中
			g.drawString("Loading CD cover, please wait...", x+300, y+190);
			if(!retrieval) { // 还没有取回，创建ImageIcon对象
				retrieval = true;
				// 为了异步加载，开启一个新的线程去创建一个ImageIcon对象
				new Thread(new Runnable() {
					public void run() {
						try {
							// 实例化Icon对象，其构造器会在图像加载完成后返回
							imageIcon = new ImageIcon(imageURL, "CD cover");
							// 当图像准备好了告诉Swing重绘
							c.repaint();
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				}).start();
			}
		}
	}
	public int getIconWidth() {
		if(imageIcon != null) // 加载完成后
			return imageIcon.getIconWidth();
		return 800; // 默认宽800px
	}
	public int getIconHeight() {
		if(imageIcon != null) // 加载完成后
			return imageIcon.getIconHeight();
		return 600; // 默认高600px
	}
}

自定义一个图像组件，将方法的处理代理委托给Icon对象：ImageComponent

/**
 * 封装ImageProxy，让它是一个组件
 */
public class ImageComponent extends JComponent {
	private Icon icon;
	public ImageComponent(Icon icon) { this.icon = icon; }
	public void setIcon(Icon icon) { this.icon = icon; }
	// 当JFrame调用repaint()方法刷新时，该方法被调用
	@Override
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		int w = icon.getIconWidth();
		int h = icon.getIconHeight();
		int x = (800 - w) / 2;
		int y = (600 - h) / 2;
		icon.paintIcon(this, g, x, y);
	}
}

构建GUI程序并测试：ImageProxyFrame、SwingUtil、ImageProxyTest

/**
 * 显示CD图片的代理
 * 创建开销大的CD图片对象,并且控制对CD对象的访问
 */
class ImageProxyFrame extends JFrame {
	ImageComponent imageComponent; 
	JMenuBar menuBar;
	JMenu menu;
	HashMap<String, String> cds = new HashMap<String, String>();
	
	public ImageProxyFrame() throws Exception {
		this("CD Cover Viewer");
	}

	public ImageProxyFrame(String title) throws Exception {
		super(title);
		cds.put("Buddha Bar", "http://images.amazon.com/images/P/B00009XBYK.01.LZZZZZZZ.jpg");
		cds.put("Ima", "http://images.amazon.com/images/P/B000005IRM.01.LZZZZZZZ.jpg");
		cds.put("Karma", "http://images.amazon.com/images/P/B000005DCB.01.LZZZZZZZ.gif");
		cds.put("MCMXC A.D.", "http://images.amazon.com/images/P/B000002URV.01.LZZZZZZZ.jpg");
		cds.put("Northern Exposure", "http://images.amazon.com/images/P/B000003SFN.01.LZZZZZZZ.jpg");
		cds.put("Selected Ambient Works, Vol. 2", "http://images.amazon.com/images/P/B000002MNZ.01.LZZZZZZZ.jpg");
		// 定义默认图片
		URL initialURL = new URL(cds.get("Selected Ambient Works, Vol. 2"));
		menuBar = new JMenuBar();
		menu = new JMenu("Favorite CDs");
		menuBar.add(menu);
		setJMenuBar(menuBar);
		for (Map.Entry<String, String> cd : cds.entrySet()) {
			String cdName = cd.getKey().trim();
			JMenuItem menuItem = new JMenuItem(cdName);
			menu.add(menuItem);
			// 请求新的图像，就创建新的代理
			menuItem.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) {
					imageComponent.setIcon(
							new ImageProxy(
									getCDUrl(e.getActionCommand())));
					repaint(); // 重绘
				}
			});
		}
		Icon icon = new ImageProxy(initialURL);
		imageComponent = new ImageComponent(icon);
		// 规范得做法：
		// 直接获得JFrame的内容面板，然后添加组件
		// 或者把添加一个面板组件JPane，然后添加imageComponent
		getContentPane().add(imageComponent);
	}

	// 从cds拿到url，并处理异常
	private URL getCDUrl(String name) {
		try {
			return new URL(cds.get(name));
		} catch (MalformedURLException e) {
			e.printStackTrace();
		}
		return null;
	}
}
/**
 * Swing工具类
 * 负责开启专门的线程创建和初始化JFrame程序
 */
class SwingUtil {
	public static void run(
		final JFrame frame, final int width, final int height) {
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
				frame.setSize(width, height);
				frame.setVisible(true);
			}
		});
	}
}
// 运行
public class ImageProxyTest {
	public static void main(String[] args) throws Exception {
		SwingUtil.run(new ImageProxyFrame(), 800, 600);
	}
}

测试结果：

加载中：

加载中
加载后：

加载后

4. 保护代理(Access Proxy) – 使用动态代理

4.1 认识动态代理

Java内置了对代理的支持，通过使用java.lang.reflect包可以创建动态代理，即在运行时创建代理类。

类图：

Subject ,<<interface>> request() RealSubject request() Proxy request() «interface» InvocationHandler invoke() ConcreteInvocationHandler invoke() has-a
  • Proxy不是我们直接实现的，是Java产生的。
  • InvocationHandler类是代理的调用处理器，工作是响应Proxy的任何调用，拥有RealSubject对象的引用，控制对该对象的访问。

4.2 设计保护控制

设计一个约会系统，用户可以查看约会对象的信息，并且给约会对象评分，但是不允许修改别人的信息，和自己给自己评分，这是不规范的操作。

每个用户都必须实现PersonBean接口：

// 设置或者获取一个个人信息的接口
public interface PersonBean {
	String getName();
	String getGender();
	String getInterests();
	int getHotOrNotRating();
	
	void setName(String name);
	void setGender(String gender);
	void setInterests(String interests);
	void setHotOrNotRating(int rating);
}

下面是PersonBean的实现：

public class PersonBeanImpl implements PersonBean {
	private String name;
	private String gender;
	private String interests;
	int rating; // 评级（1-10）
	int ratingCount = 0; // 评级人数
	// getter 方法
	public String getName() { return name; }
	public String getGender() { return gender; }
	public String getInterests() { return interests; }
	public int getHotOrNotRating() {
		if(ratingCount == 0) return 0;
		return (rating / ratingCount);
	}
	// setter 方法
	public void setName(String name) { this.name = name; }
	public void setGender(String gender) { this.gender = gender; }
	public void setInterests(String interests) { this.interests = interests; }
	public void setHotOrNotRating(int rating) {
		this.rating += rating;
		ratingCount++;
	}
	@Override public String toString() { 
		// 打印用户信息... 
	}
}

为了实现以上的功能，我们应用保护代理模式，保护控制访问PersonBean对象，并且使用动态代理技术：

步骤一：
创建 两个 InvocationHandler，即需要两个代理。一个控制访问自己，另一个控制访问别人
步骤二：
写代理创建动态代理。导入 java.lang.reflect.Proxy包，使用 Proxy.newProxyInstance()静态方法
步骤三：
利用 适当的代理包装任何 PersonBean对象。即用户自己修改自己的信息那么就使用"拥有者代理"，否则使用"非拥有者代理"。

4.3 实现保护代理

分别创建一个访问自己和别人的InvocationHandler，并在invoke方法实现中进行保护控制：OwnerInvocationHandler，NonOwnerInvocationHandler

// 给拥有者使用的调用处理器
// 保护控制 --> 不允许自己评级
public class OwnerInvocationHandler implements InvocationHandler {
	PersonBean person;
	
	public OwnerInvocationHandler(PersonBean person) {
		this.person = person;
	}
	
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		try {
			if(method.getName().startsWith("get"))
				return method.invoke(person, args);
			else if(method.getName().equals("setHotOrNotRating"))
				throw new IllegalAccessException();
			else if(method.getName().startsWith("set"))
				return method.invoke(person, args);
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		// 调用其他方法也不允许，返回null
		return null;
	}
}

// 给非拥有者使用的调用处理器
// 保护控制 --> 不允许修改自己的信息
public class NonOwnerInvocationHandler implements InvocationHandler {
	PersonBean person;
	
	public NonOwnerInvocationHandler(PersonBean person) {
		this.person = person;
	}
	
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		try {
			if(method.getName().startsWith("get"))
				return method.invoke(person, args);
			else if(method.getName().equals("setHotOrNotRating"))
				return method.invoke(person, args);
			else if(method.getName().startsWith("set"))
				throw new IllegalAccessException();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		return null;
	}
}

动态创建代理的代码：

// 通过java.util.reflect.Proxy的静态方法newProxyInstance()
// 动态创建Proxy代理对象
// 拥有者代理对象
PersonBean getOwnerProxy(PersonBean person) {
	return (PersonBean) Proxy.newProxyInstance(
			person.getClass().getClassLoader(),
			person.getClass().getInterfaces(),
			new OwnerInvocationHandler(person));
}
// 非拥有者代理对象
PersonBean getNonOwnerProxy(PersonBean person) {
	return (PersonBean) Proxy.newProxyInstance(
			person.getClass().getClassLoader(),
			person.getClass().getInterfaces(),
			new NonOwnerInvocationHandler(person));
}

测试约会系统：MatchMakingTest

package headfirst.designpatterns.proxy.javaproxy;

import java.lang.reflect.Proxy;
import java.util.HashMap;

public class MatchMakingTest {
	private HashMap<String, PersonBean> datingDB = 
		new HashMap<String, PersonBean>();
	
	public MatchMakingTest() {
		initializeDatabase();
	}

	public static void main(String[] args) {
		MatchMakingTest test = new MatchMakingTest();
		test.drive();
	}
	
	// 测试代码在这里...
	public void drive() {
		PersonBean joe = getPersonFromDatabase("Joe Javabean");
		System.out.println("Date information: " + joe + "\n");
		
		// 获得Joe的拥有者代理对象;
		PersonBean ownerProxy = getOwnerProxy(joe);
		System.out.println("Name is " + ownerProxy.getName());
		try {
			// 尝试不合规定的操作，看会不会抛出异常？
			ownerProxy.setHotOrNotRating(10);
		} catch (Exception e) {
			System.out.println("Can't set rating from owner proxy");
		}
		System.out.println("Rating is " + ownerProxy.getHotOrNotRating());
		
		System.out.println();
		
		// 获得Joe的非拥有者代理对象;
		PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
		System.out.println("Name is " + ownerProxy.getName());
		try {
			// 尝试不合规定的操作，看会不会抛出异常？
			nonOwnerProxy.setInterests("bowing, GO");
		} catch (Exception e) {
			System.out.println("Can't set interests from non owner proxy");
		}
		nonOwnerProxy.setHotOrNotRating(3);
		System.out.println("Rating set from non owner proxy");
		System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());
	}
	
	// 动态创建Proxy代理对象的方法 
	// getOwnerProxy，getNotOwnerProxy
	
	// 模拟从数据库中获取数据的方法 getPersonFromDatabase(String name)
	// 实例化两个对象，模拟数据库初始化的方法 initializeDatabase()
}

测试结果：

Date information: [Joe Javabean, female, (cars, computers, music), 7]

Name is Joe Javabean
Can't set rating from owner proxy
Rating is 7

Name is Joe Javabean
Can't set interests from non owner proxy
Rating set from non owner proxy
Rating is 5

可见保护代理起作用了，测试对象Joe不能自己修改自己的评分，也不能修改非拥有者代理的对象的信息。

5. 认识其他代理

防火墙代理（FireWall Proxy）：控制网络资源的访问，保护主题免于“坏客户”的侵害。
智能引用代理（Smart Reference Proxy）：当主题被引用时，进行额外的动作，例如计算一个对象被引用的次数。
缓存代理（Caching Proxy）：为开销大的运算结果提供暂时的缓存：它也允许多个用户共享结果，以减少计算或网络延迟。
同步代理（Synchronization Proxy）：在多线程的情况下为主题提供安全的访问。
复杂隐藏代理（Complexity Hiding Proxy）：用来隐藏一个类的复杂集合的复杂度，并进行控制访问。
写入时复制代理（Copy-On-Write Proxy）：用来控制对象的复制，方法是延迟对象的复制，直到客户真正需要为止。这是一个虚拟代理的变体。

6. 要点

  • 代理模式为另一个对象提供代表，以便控制客户对对象的访问，管理访问的方式有许多种。
  • 远程代理管理客户的远程对象之间的交互。
  • 虚拟代理控制访问实例化开销大的对象。
  • 保护代理基于调用者控制对象方法的访问。
  • 代理在结构上类似装饰者，但是目的不同。
  • Java内置的代理支持，可以根据需要建立动态代理，并将所有调用分配到所选的处理器。
  • 就和其他包装者一样，代理会造成你的设计类的数目增加。
DragonZou_blog
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何正确使用 HTTP proxy
一介码农
11-30 4万+
目录两种 HTTP 代理Proxy 如何获取目标服务器地址两种 request-URL 格式如何代理 HTTPS编程实现 两种 HTTP 代理 第一种是 RFC 7230 - HTTP/1.1: Message Syntax and Routing（即修订后的 RFC 2616，HTTP/1.1 协议的第一部分）描述的普通代理。其代理过程为： client 请求 proxy proxy 解析请求...
Proxy 模式
stepMore的博客
12-27 334
Proxy 模式 Proxy是“代理人”的意思，它指的是代替别人进行工作的人。当不一定需要本人亲自进行工作时，就可以寻找代理人去完成工作。但代理人毕竟只是代理人，能代替本人做的事情终究是有限的。因此，当代理人遇到无法自己解决的事情时就会去找本人解决该问题。 在面向对象编程中，“本人”和“代理人”都是对象。如果“本人”对象太忙了，有些工作无法自己亲自完成，就将其交给“代理人”对象负责。 示例程序 类...
保护代理模式-Access Proxy(Java实现)
weixin_30662849的博客
05-20 367
保护代理模式-Access Proxy 保护代理模式(Access Proxy), 也叫Protect Proxy. 这种代理用于对真实对象的功能做一些访问限制, 在代理层做身份验证. 通过了验证, 才调用真实的主体对象的相应方法. 模拟场景如下: 某平台的系统有查询功能, 可以根据关键词进行查询, 在查询之前对该关键词进行检查, 如果关键词是敏感词, 那么就不予处理. 如果成功查询了该关键...
每日一个设计模式之【代理模式】
热爱编程、热爱生活、热爱探索
11-17 848
大家好✋，我是知识汲取者😄，今天给大家带来一篇有关代理模式的学习笔记。众所周知能够熟练使用设计模式是一个优秀程序猿的必备技能，当我们在项目中选择一个或多个合适的设计模式，不仅能大大提高项目的稳健性、可移植性、可维护性，同时还能让你的代码更加精炼，具备艺术美感。推荐阅读设计模式导学：🚪传送门🚪传送门设计模式专属Gitee仓库：✈启程设计模式专属Github仓库：🚀上路💓点我哦什么是代理模式？代理模式（Proxy Pattern）也称委托模式，是一种结构型模式，代理模式的作用。
accessproxy:本地redhat访问开发的代理
05-24
此仓库已弃用。 请改用 。 访问代理 使用以下方法安装模块： sudo npm install accessproxy -g 使用以下方式配置模块： accessproxy configure 执照 版权所有（c）2014，根据MIT许可进行许可。
代理模式1
08-08
【代理模式】是一种设计模式，它的核心思想是为一个对象提供一个代用品或占位符，以便控制对该对象的访问。在代理模式中，代理对象作为客户端与目标对象之间的中介，处理请求并转发给目标对象，同时可以在转发之前或...
Java 代理模式详解
12-22
代理模式是我们比较常用的设计模式之一。其中新思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信，代理模式一般涉及到的角色有： 　...
java代理模式
02-06
Java代理模式是一种设计模式，它在面向对象编程中扮演着重要的角色，主要目的是为了在不修改原有对象的基础上，为对象添加额外的功能或者控制对对象的访问。代理模式的核心思想是通过代理类来间接调用目标类的方法，...
代理模式代码
09-20
代理模式是一种设计模式，它在软件工程中扮演着重要的角色，允许我们创建一个代表原始对象的代理对象，以便在客户端和原始对象之间增加一层间接性。这样做的好处包括控制访问、增强功能、延迟加载和安全保护等。在这...
代理模式实例
08-21
代理模式是一种设计模式，它是结构型模式的一种，主要用于在对象之间提供一个代理以控制对原对象的访问。在这个实例中，我们看到的是如何通过代理模式来实现某种功能的增强或控制。下面将详细讲解代理模式的基本概念...
Spring Boot实现简单的Oracle数据库操作
beautiful77moon的博客
08-18 375
使用到的技术：1. Spring Boot：用于简化Spring应用的开发。2. Dynamic DataSource：实现动态多数据源的访问和切换3. Oracle JDBC Driver：与Oracle数据库进行连接和交互。4. Mybatis-Plus：简化SQL映射和数据库访问。其中BaseMapper接口提供了对数据表进行基本操作的功能。5. Lombok：用于简化Java类的开发，自动生成常用的代码，比如getter、setter、构造函数等。
Linux配置Maven环境
Java全栈开发者
08-18 376
官网地址：https://maven.apache.org/download.cgi。获取其对应的下载链接（也可以使用下载到本地后，手动上传到服务器的方式）切到自己想要存放的路径后，使用wget下载。使用pwd查看文件路径，ll查看文件名称。这里以当前最新版本3.9.8为例。
【Spring框架】
m0_71941456的博客
08-18 993
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 952
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 505
【代码】springboot网上商品订单转手系统bootpf
指针详解（四）
最新发布
Limerence_Aries的博客
08-18 1005
目录1. 字符指针变量2. 数组指针变量3. 数组指针变初始化4. 二维数组传参的本质5. 函数指针变量1）函数指针变量的创建2）函数指针变量的使用3）代码解析6. typedef关键字7. 函数指针数组8. 转移表 代码const char* pstr = "hello bit."; 不是把字符串 hello bit 放到字符指针 pstr 里，而是把字符串hello bit.的首字符的地址放到了pstr中我们通过一道例题加深理解 所以数组指针变量：存放的应该是数组的地址，能够指向数组的指针变
旅游网站
weixin_43213064的博客
08-16 1165
【代码】springboot旅游网站
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值