JAVA入门14 算法和设计模式

最新推荐文章于 2024-08-17 17:16:24 发布
最新推荐文章于 2024-08-17 17:16:24 发布
阅读量240 收藏
点赞数
分类专栏： Java基础 java高级
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h356363/article/details/100600740
版权

递归算法

模拟单向链表

package com.zz;

/**
 *  单向链表 结构
 * @author jiyu
 *
 */
public class Node {
	//指向， 下一个节点
	Node next;
	//节点的名字
	String name;
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	

}

测试：

package com.zz;

import java.util.*;

public class Test2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Node node1=new Node();
		node1.setName("祖宗");
		
		Node node2=new Node();
		node2.setName("a");
		
		Node node3=new Node();
		node3.setName("b");
		
		
		node1.setNext(node2);
		
		node2.setNext(node3);
		
		
		printNodeName(node1);
		
		
	}
	
	
	public static void printNodeName(Node node){
		  System.out.println(node.name);
		  if(node.next!=null){
			  printNodeName(node.next);
		  }
	}

}

测试数据结构图

在这里插入图片描述

运行结果：

祖宗
a
b

单向 ，多个子节点

package com.zz;

import java.util.List;

/**
 *  单向链表 结构
 * @author jiyu
 *
 */
public class Node2 {
	//指向， 下一个节点
	List<Node2> next;
	//节点的名字
	String name;
	public List<Node2> getNext() {
		return next;
	}
	public void setNext(List<Node2> next) {
		this.next = next;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	

}

测试：

package com.zz;

import java.util.ArrayList;
import java.util.List;

public class Test3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Node2 n1=new Node2();
		n1.setName("根节点");
		
		
		Node2 n2=new Node2();
		n2.setName("家电");
		
		Node2 n3=new Node2();
		n3.setName("服装");
		
		Node2 n21=new Node2();
		n21.setName("洗衣机");
		
		Node2 n22=new Node2();
		n22.setName("电视机");
		
		
		Node2 n31=new Node2();
		n31.setName("女装");
		
		Node2 n32=new Node2();
		n32.setName("男装");
		
		List<Node2> ls1=new ArrayList();
		ls1.add(n2);
		ls1.add(n3);
		n1.setNext(ls1);
		
		List<Node2> ls2=new ArrayList();
		ls2.add(n21);
		ls2.add(n22);
		n2.setNext(ls2);
		
		
		List<Node2> ls3=new ArrayList();
		ls3.add(n31);
		ls3.add(n32);
		n3.setNext(ls3);
		
		printNodeName(n1.next);
	}
	
	
	public static void printNodeName(List<Node2> nodelist){
		  for(Node2 node:nodelist){
			  System.out.println(node.name);

			  if(node.next!=null){
				  //自己调用了自己
				  printNodeName(node.next);
			  }
		  }
		
	}

}

代理模式

Java 的代理就是客户类不再直接和委托类打交道, 而是通过一个中间层来访问, 这个中间层就是代理。为啥要这样呢, 是因为使用代理有 2 个优势：

  • 可以隐藏委托类的实现

  • 可以实现客户与委托类之间的解耦, 在不修改委托类代码的情况下能够做一些额外的处理。
    在这里插入图片描述

从上面图中列子，我们知道，消费类，不知道工厂类的具体情况， 代理类，可以对目标类的方法结果进行包装修改。

代理模式一个有三种

  • 静态代理
  • 动态代理
  • CGLIB代理
静态代理的实现关键点
  • 目标类和代理类必须实现同一接口
  • 代理类里面，需要有目标类的对象引用，然后代理类的方法里面，会执行目标类的对象的方法。
  • 消费类，调用代理类的方法，但是代理类方法的里面，又调用了目标类的方法，并且可以添加额外的功能，从而达到消费类间接的执行目标类方法，并且代理类还提供额外功能的目的。
// 委托接口
public interface IHelloService {

    /**
     * 定义接口方法
     * @param userName
     * @return
     */
    String sayHello(String userName);

}
// 委托类实现
public class HelloService implements IHelloService {

    @Override
    public String sayHello(String userName) {
        System.out.println("helloService" + userName);
        return "HelloService" + userName;
    }
}

// 代理类
public class StaticProxyHello implements IHelloService {

    private IHelloService helloService = new HelloService();

    @Override
    public String sayHello(String userName) {
        /** 代理对象可以在此处包装一下*/
        System.out.println("代理对象包装礼盒...");
        return helloService.sayHello(userName);
    }
}
// 测试静态代理类
public class MainStatic {
    public static void main(String[] args) {
        StaticProxyHello staticProxyHello = new StaticProxyHello();
        staticProxyHello.sayHello("isole");
    }
}
JAVA 动态代理的实现关键点
  • 目标类一定实现了某个接口
  • 中间类一定要实现InvocationHandler接口
  • 中间类通过反射，动态的生成代理类
  • 动态生成的代理类，执行任何方法，都会先执行invoke方法

代理类在程序运行时创建的代理方式被成为 动态代理。在了解动态代理之前, 我们先简回顾一下 JVM 的类加载机制中的加载阶段要做的三件事情
( 附 Java 中的类加载器 )

通过一个类的全名或其它途径来获取这个类的二进制字节流

将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构

在内存中生成一个代表这个类的 Class 对象, 作为方法区中对这个类访问的入口

而我们要说的动态代理，主要就发生在第一个阶段, 这个阶段类的二进制字节流的来源可以有很多, 比如 zip 包、网络、运行时计算生成、其它文件生成 (JSP)、数据库获取。其中运行时计算生成就是我们所说的动态代理技术，在 Proxy 类中, 就是运用了 ProxyGenerator.generateProxyClass 来为特定接口生成形式为 *$Proxy 的代理类的二进制字节流。所谓的动态代理就是想办法根据接口或者目标对象计算出代理类的字节码然后加载进 JVM 中。实际计算的情况会很复杂，我们借助一些诸如 JDK 动态代理实现、CGLIB 第三方库来完成的

例子：

// 委托类接口
public interface IHelloService {

/**
 * 方法1
 * @param userName
 * @return
 */
String sayHello(String userName);

/**
 * 方法2
 * @param userName
 * @return
 */
String sayByeBye(String userName);

}
// 委托类
public class HelloService implements IHelloService {

@Override
public String sayHello(String userName) {
    System.out.println(userName + " hello");
    return userName + " hello";
}

@Override
public String sayByeBye(String userName) {
    System.out.println(userName + " ByeBye");
    return userName + " ByeBye";
}

}
// 中间类
public class JavaProxyInvocationHandler implements InvocationHandler {

/**
 * 中间类持有委托类对象的引用,这里会构成一种静态代理关系
 */
private Object obj ;

/**
 * 有参构造器,传入委托类的对象
 * @param obj 委托类的对象
 */
public JavaProxyInvocationHandler(Object obj){
    this.obj = obj;

}

/**
 * 动态生成代理类对象,Proxy.newProxyInstance
 * @return 返回代理类的实例
 */
public Object newProxyInstance() {
    return Proxy.newProxyInstance(
            //指定代理对象的类加载器
            obj.getClass().getClassLoader(),
            //代理对象需要实现的接口，可以同时指定多个接口
            obj.getClass().getInterfaces(),
            //方法调用的实际处理者，代理对象的方法调用都会转发到这里
            this);
}


/**
 *
 * @param proxy 代理对象
 * @param method 代理方法
 * @param args 方法的参数
 * @return
 * @throws Throwable
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("invoke before");
    Object result = method.invoke(obj, args);
    System.out.println("invoke after");
    return result;
}

}

// 测试动态代理类
public class MainJavaProxy {
    public static void main(String[] args) {
        JavaProxyInvocationHandler proxyInvocationHandler = new JavaProxyInvocationHandler(new HelloService());
        IHelloService helloService = (IHelloService) proxyInvocationHandler.newProxyInstance();
        helloService.sayByeBye("paopao");
        helloService.sayHello("yupao");
    }

}
CGLIB 动态代理

JDK 动态代理依赖接口实现，而当我们只有类没有接口的时候就需要使用另一种动态代理技术 CGLIB 动态代理。首先 CGLIB 动态代理是第三方框架实现的，在 maven 工程中我们需要引入 cglib 的包, 如下:

cglib cglib 2.2

CGLIB 代理是针对类来实现代理的，原理是对指定的委托类生成一个子类并重写其中业务方法来实现代理。代理类对象是由 Enhancer 类创建的。CGLIB 创建动态代理类的模式是:

查找目标类上的所有非 final 的 public 类型的方法 (final 的不能被重写)

将这些方法的定义转成字节码

将组成的字节码转换成相应的代理的 Class 对象然后通过反射获得代理类的实例对象

实现 MethodInterceptor 接口, 用来处理对代理类上所有方法的请求

// 委托类,是一个简单类
public class CglibHelloClass {
/**
* 方法1
* @param userName
* @return
*/
public String sayHello(String userName){
System.out.println(“目标对象的方法执行了”);
return userName + " sayHello";
}

public String sayByeBye(String userName){
    System.out.println("目标对象的方法执行了");
    return userName + " sayByeBye";
}

}
/**

  • CglibInterceptor 用于对方法调用拦截以及回调

/
public class CglibInterceptor implements MethodInterceptor {
/*
* CGLIB 增强类对象，代理类对象是由 Enhancer 类创建的，
* Enhancer 是 CGLIB 的字节码增强器，可以很方便的对类进行拓展
*/
private Enhancer enhancer = new Enhancer();

/**
 *
 * @param obj  被代理的对象
 * @param method 代理的方法
 * @param args 方法的参数
 * @param proxy CGLIB方法代理对象
 * @return  cglib生成用来代替Method对象的一个对象，使用MethodProxy比调用JDK自身的Method直接执行方法效率会有提升
 * @throws Throwable
 */
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    System.out.println("方法调用之前");
    Object o = proxy.invokeSuper(obj, args);
    System.out.println("方法调用之后");
    return o;
}


/**
 * 使用动态代理创建一个代理对象
 * @param c
 * @return
 */
public  Object newProxyInstance(Class<?> c) {
    /**
     * 设置产生的代理对象的父类,增强类型
     */
    enhancer.setSuperclass(c);
    /**
     * 定义代理逻辑对象为当前对象，要求当前对象实现 MethodInterceptor 接口
     */
    enhancer.setCallback(this);
    /**
     * 使用默认无参数的构造函数创建目标对象,这是一个前提,被代理的类要提供无参构造方法
     */
    return enhancer.create();
}

}

//测试类
public class MainCglibProxy {
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
CglibHelloClass cglibHelloClass = (CglibHelloClass) cglibProxy.newProxyInstance(CglibHelloClass.class);
cglibHelloClass.sayHello(“isole”);
cglibHelloClass.sayByeBye(“sss”);
}
}
对于需要被代理的类，它只是动态生成一个子类以覆盖非 final 的方法，同时绑定钩子回调自定义的拦截器。值得说的是，它比 JDK 动态代理还要快。值得注意的是，我们传入目标类作为代理的父类。不同于 JDK 动态代理，我们不能使用目标对象来创建代理。目标对象只能被 CGLIB 创建。在例子中，默认的无参构造方法被使用来创建目标对象。

JAVA 动态代理和GCLIB代理的区别
  • JAVA 动态代理 基于接口动态生成实现类
  • GCLIB代理 基于继承，动态生成子类
潘多编程
关注
专栏目录
JAVA常用算法以及常用设计模式(面试经常设计到）
2301_80979729的博客
01-16 1174
工厂模式分为简单工厂模式和工厂方法模式，简单工厂模式是只有一个工厂类，这个类里面有很多的方法，每一个方法的返回值就是一个对象，你需要什么对象，就调用什么方法。工厂方法模式是每一个实体类都有一个工厂，所以有很多的工厂，每一个工厂里面的返回值就是对应的一个对象，所以，想要使用什么对象，直接创建对应的工厂类，调用里面的方法就可以得到。//4.将左侧找到的打印等于基准值的值加入到右边的坑中，右指针向中间移动一个位置j-- if(i<j){
Java数据结构和算法（十四）——堆
北国觅梦
08-28 212
参考链接： https://www.cnblogs.com/ysocean/p/8032660.html#_label0 https://blog.csdn.net/abcd1f2/article/details/54863445 https://www.cnblogs.com/skywang12345/p/3602162.html 这几个链接写的非常好，我只是记录我自己需要的内容，大家可...
Java二十三种设计模式-迭代子模式（16/23）
最新发布
小相探索IT世界
08-17 913
迭代器模式是一种行为型设计模式，用于提供一种顺序访问集合元素的方法，而不暴露集合的内部结构。迭代器模式定义了一种迭代访问一个聚合对象中各个元素的接口，允许在不暴露其内部表示的情况下，顺序访问聚合对象中的各个元素。迭代器模式提供了一种强大的方式来顺序访问集合中的元素，同时隐藏了集合的具体实现。通过本文的深入分析，希望读者能够对迭代器模式有更全面的理解，并在实际开发中做出合理的设计选择。Java二十三种设计模式-单例模式（1/23）Java二十三种设计模式-工厂方法模式（2/23）
Java中的设计模式和算法
Recently祝祝的博客
06-02 925
今天内容： (1)常用的设计原则 (2)常用的设计模式 (3)常用的查找算法 (4)常用的排序算法 1.常用的设计原则(记住) 1.1 软件开发的流程 需求分析文档 => 概要设计文档 => 详细设计文档 => 编码和测试 => 安装和调试 => 维护和升级 1.2 常用的设计原则 开闭原则 - 对扩展开放，对修改关闭。 - 提高了代码的扩展性和维护性。（封装后尽量不要改） 如： public class Person { private String name; priva
经典算法 java_14种经典Java算法详解，面试官随便问
weixin_33458169的博客
02-12 90
又是新的一年，去年“金九银十”没赶上，问到算法一脸懵逼，吞吞吐吐。今年重振旗鼓，记住下面这些算法，手撕面试官！赶上“金三银四”的首班车！二分查找又叫折半查找，要求待查找的序列有序。每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字。publi...
java大厂技术面试第七课 设计模式与算法
fegus的博客
05-02 286
第27讲：单例的实现方式有几种？它们有什么优缺点？ 单例模式是 Java 中最简单的设计模式之一，它是指一个类在运行期间始终只有一个实例，我们就把它称之为单例模式。它不但被应用在实际的工作中，而且还是面试中最常考的题目之一。通过单例模式我们可以知道此人的编程风格，以及对于基础知识的掌握是否牢固。 我们本课时的面试题是，单例的实现方式有几种？它们有什么优缺点？ 典型回答 单例的实现分为饿汉模式和懒汉模式。顾名思义，饿汉模式就好比他是一个饿汉，而且有一定的危机意识，他会提前把食物囤积好，以备饿了之后直接能吃到食
Java核心技术,并发设计模式，数据结构与算法
10-04
Java核心技术,并发设计模式，数据结构与算法，SpringBoot,OAuth2.0源码分析，Mysql进阶篇,Git高级操作，Netty教程，Redis设计与实战,Flink入门教程，Kafka入门与架构分析,Linux入门与Shell编程,DDD架构设计
java 算法入门到精通
09-18
### Java算法入门到精通知识点概览 ...以上知识点不仅涵盖了从Java编程的基础知识到高级算法、设计模式的全面内容，还提供了大量实用的实例分析和技术指导，旨在帮助读者从零开始系统地学习并掌握Java算法的核心技能。
java实现策略模式-设计模式
06-14
策略模式通过定义一组可互换的算法（即策略），将每个算法封装成相应的策略类。这样客户端可以根据需要选择不同的策略，并且能够灵活地切换和扩展策略，而不需要修改原有的代码逻辑。策略模式能够提高代码的灵活性、...
Java设计模式入门闲谈
06-28
### Java设计模式入门详解 #### 一、设计模式概述 设计模式是软件工程领域中一种通用的解决方案，它描述了在特定情况下解决常见问题的方法。《设计模式：可复用面向对象软件的基础》（Design Patterns: Elements ...
Java设计模式之禅
04-07
《Java设计模式之禅》是一本深入浅出讲解设计模式的书籍，书中不仅包含23种经典设计模式的案例，还详细介绍了设计模式背后的思想和原则，适合初学者以及对设计模式有一定了解的程序员阅读。本书旨在帮助读者理解如何...
基础算法模板(Java实现)
hzc246的博客
04-27 1008
1 基础算法 1.1 排序 快排： public static void quickSort(int[] q, int l, int r) { if (l >= r) return; int i = l - 1, j = r + 1, x = q[l + r >> 1]; while (i < j) { do i++; while (q[i] < x); do j--
14.常用10大算法
Korbin的博客
07-21 677
目录 1.二分查找算法(非递归) 2.分治算法 3.动态规划算法 4.KMP算法 5.贪心算法 6.普利姆算法 7.克鲁斯卡尔算法 8.迪杰斯特拉算法 9.弗洛伊德算法 10.马踏棋盘算法 1.二分查找算法(非递归) 二分查找算法介绍： 二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找。 代码实现（JAVA）： package algorithm; public class BinarySearch { public static void main(St
浅析五种最常用的Java加密算法，以后可以直接拿来用了
Java鱼仔的博客
03-14 6269
再也不会不懂加密了
数据结构与算法_韩顺平14十大算法
weixin_30808693的博客
08-09 604
14.1 14.1 二分查找（非递归） package com.atguigu.binarysearchnorecursion; public class BinarySearchNoRecur { public static void main(String[] args) { //测试 int[] arr = {1,3, 8, ...
Java算法基础学习笔记
测试领域专家，多领域测试技术、管理、工具都略懂，略懂一二
08-29 396
目录 数组排序 冒泡排序 选择排序 找出最大值/最小值 升序排列（从小到大） 逆序输出 复制排序 数组查找算法（搜索） 二分查找 数组插入排序 快速排序 设计模式 单例模式（懒汉、饿汉） 数组排序 代码里标记重点的要记住 冒泡排序 数组最基本的操作算法（这里演示从小到...
java的设计模式
B__B_B的博客
10-10 52
运行（Runnable）状态 -> 计时等待（Timed Waiting）状态：线程调用了sleep()方法、带有超时参数的Object类的wait()方法、Thread类的join()方法，或者是LockSupport类的parkNanos()、parkUntil()方法，导致线程进入计时等待状态。好的哈希算法可以尽量减少碰撞的发生，提高存取效率。因此，在自定义的类作为HashMap的键时，需要重写hashCode()和equals()方法，以保证不同的键对象产生不同的哈希码，并正确判断键对象的相等性。
Java中常用算法及示例-分治、迭代、递归、递推、动态规划、回溯、穷举、贪心
BADAO_LIUMANG_QIZHI的博客
04-11 2524
1、分治算法的基本思想是将一个计算复杂的问题分成规模较小、计算简单的小问题求解，然后综合各个小问题，得到最终答案。2、穷举(又称枚举)算法的基本思想是从所有可能的情况中搜索正确的答案。3、迭代法(Iterative Method) 无法使用公式一次求解，而需要使用重复结构(即循环)重复执行一段代码来得到答案。4、递归调用是一个方法在其方法体内调用其自身方法。5、递推算法是一种理性思维模式的代表，其根据已有的数据和关系，逐步推导而得到结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值