设计模式
代理模式
给某一个对象提供一个代理,并由代理对象控制对原对象的引用
优点
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()));
}
}
排序算法
辅助记忆:
- 时间复杂度记忆
- 冒泡、选择、直接 排序需要两个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);
}