复习笔记 一

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

一、集合

1.1 数组和集合的区别

数组：长度必须声明指定，不能更改，数组内的元素类型需要和数组声明的数据类型一致

集合：可以动态存储任意多个元素，增删元素有提供的方法，都实现了Collection或Map接口

1.2 数组动态扩容示例
//首先申明一个Persion类数组 长度为1
Persion[] persions = new Persion[1];
persions[0] = new Persion();
//扩容persions数组，并中添加一个persion元素
Persion[] persioncopy = new Persion[persions.length+1];
for(int i=0;i<=persions.length-1;i++){
  persioncopy[i]=persions[i];
}
persioncopy[persions.length]=new Persion();
//或者
persions=Arrays.copyOf(persions,(persions.length+1)<<1);
1.3 常见集合关系继承实现类图

在这里插入图片描述

1.3.1 单列集合

指的是集合中存储的元素是单个的，Collection接口的实现子类都是单列集合

1.3.2 双列集合

指的是集合中存储的元素是以key/value的形式存储在集合中的，Map接口的实现子类都是双列集合

1.4 源码解析

  1. ArrayList扩容实现

        private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

  2. LinkedList核心代码

    //元素实现    
private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
}
//末尾添加元素
 void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

    ​

  3. Vector核心代码

      /**
   ** initialCapacity 初始化数组长度
   ** capacityIncrement 扩容时的增量长度
   **/
  public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
  /**
   ** 遍历元素时生成一个新的Enumeration对象，通过count自增遍历数组内的元素
   **/
   public Enumeration<E> elements() {
        return new Enumeration<E>() {
            int count = 0;

            public boolean hasMoreElements() {
                return count < elementCount;
            }

            public E nextElement() {
                synchronized (Vector.this) {
                    if (count < elementCount) {
                        return elementData(count++);
                    }
                }
                throw new NoSuchElementException("Vector Enumeration");
            }
        };
    }

    Vector和ArrayList类似都是用一个数组去维护，扩容机制和ArrayList类型类似,当capacityIncrement=0时每次扩容为当前数组长度的2倍，否则扩容capacityIncrement长度

  4. HashSet核心代码

    //初始化一个Collection接口实现类的对象，该对像的值的4/3+1和16比较，取最大值初始化一个HashMap
public HashSet(Collection<? extends E> c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
} 
  /**
   ** initialCapacity 初始化大小
   ** loadFactor 扩容时除的系数
   **/
public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
}

  5. TreeSet与TreeMap核心代码解析

    /**
 **TreeSet实例化的过程中可以传递自定义的Comparator排序规则
 **否则使用泛型的Comparator实现
 **/
    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }
/**
 ** TreeMap内部实现了一个二叉树
 **/
    static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;
        V value;
        Entry<K,V> left;
        Entry<K,V> right;
        Entry<K,V> parent;
        boolean color = BLACK;

        /**
         * Make a new cell with given key, value, and parent, and with
         * {@code null} child links, and BLACK color.
         */
        Entry(K key, V value, Entry<K,V> parent) {
            this.key = key;
            this.value = value;
            this.parent = parent;
        }
    }
/**
 ** TreeSet内部维护了一个TreeMap实例
 ** 下面是TreeMap添加元素的实现
 **/
    public V put(K key, V value) {
        Entry<K,V> t = root;
        //第一次添加
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // 初始化的比较器
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                //使用比较器和key比较
                cmp = cpr.compare(key, t.key);
                //key小于t.key时向左遍历
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                  //去重
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
       //给二叉树添加元素                                                                                                                                                                                                                                                                               
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        //维持红黑树的平衡
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

二、设计模式

1.1 前言

一个好的设计模式可以提高工作的效率，更加利于维护，可读性更高，下面就几种常用的设计模式进行学习

1.2 设计模式的种类

在这里插入图片描述

1.3 创建者模式

创建者模式指的就是构造对象的方法,下面主要说下单例模式和工厂模式

  1. 单例模式

    public class Singleton {

    public static Singleton instance = null；
      
    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null)
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        return instance;
    }

  2. 静态工厂方法模式

    //接口
public interface Call {
    /**
     * 拨打电话
     * @param telnumber
     */
    Boolean makeACall(String telnumber);

}
//实现类1
public class FixedTelephone implements Call {
    @Override
    public Boolean makeACall(String telnumber) {
        if (telnumber.length() != 7) {
            System.out.println("请呼叫固话号码！");
            return false;
        }
        System.out.println("呼～ 等待接通中：" + telnumber);
        return true;
    }
}
//实现类2
public class TelPhone  implements Call{

    @Override
    public Boolean makeACall(String telnumber) {
        if(telnumber.length()!=11){
            System.out.println("请呼叫移动手机号码！");
            return false;
        }
        System.out.println("为您呼叫："+telnumber);
        return true;
    }

}
/**
 ** 静态工厂
 **/
public class DataFactory {

    public static Call getTelPhone() {
        return new TelPhone();
    }

    public static Call getFixedTelePhone() {
        return new FixedTelephone();
    }

    public static void main(String[] args) {
        DataFactory.getTelPhone().makeACall("6233212");
    }
}
1.4 结构型模式

  1. 适配器模式

    适配器模式的思想就是通过对接口的方法通过适配器去做适配以此达到兼容其他的接口或类

    //原实现
public class Source {
    public  String name = this.getClass().getSimpleName();
  
    public void method1() {
        System.out.println(name+" runing method1");
    }
}
//目标接口
public interface Targetabl{
  
  void method1();
  
  void method2();
}
//适配器
public class BaseAdapter extends Source implements Targetabl{
    @Override
    public void method2() {
        System.out.println("BaseAdapter runing method2");
    }
}

    public static void main(String[] args) {
        Targetabl targetabl = new BaseAdapter();
        targetabl.method1();
        targetabl.method2();
    }

    ​

  2. 装饰者模式

    装饰者模式就是装饰者类和被装饰者实现同一个接口，装饰者类获取接口实现类的对象，而后可以对接口的实现进行修改

    //接口
public interface Sourceable {
	public void method();
}
//被装饰者
public class Source implements Sourceable {
 
	@Override
	public void method() {
		System.out.println("the original method!");
	}
}
//装饰者
public class Decorator implements Sourceable {
 
  //接口的实现对象	
  private Sourceable source;
	
	public Decorator(Sourceable source){
		super();
		this.source = source;
	}
	@Override
	public void method() {
		System.out.println("before decorator!");
		source.method();
		System.out.println("after decorator!");
	}
}
	public static void main(String[] args) {
		Sourceable source = new Source();
		Sourceable obj = new Decorator(source);
		obj.method();
	}

    ​

    ​

  3. 代理模式

    让调用者只能通过代理去执行被代理对象的方法，调用者无法直接获取被代理对象和对该对象进行修改

    ​

    //接口
public interface Sourceable {
	public void method();
}
//被装饰者
public class Source implements Sourceable {
 
	@Override
	public void method() {
		System.out.println("the original method!");
	}
}
//装饰者
public class Proxy implements Sourceable {
 
  //安全
  private Sourceable source;
	
	public Proxy(){
		this.source = new Source();
	}
	@Override
	public void method() {
		System.out.println("before proxy!");
		source.method();
		System.out.println("after proxy!");
	}
}
	public static void main(String[] args) {
		Sourceable obj = new Decorator();
		obj.method();
	}

  4. 享元模式

    不每次重复创建对象，而是在第一次初始化的时候创建多个对象放入池中，需要的时候取出，用完放回连接池中。

    public class ConnectionPool {
	
	private Vector<Connection> pool;
	
	/*公有属性*/
	private String url = "jdbc:mysql://localhost:3306/test";
	private String username = "root";
	private String password = "root";
	private String driverClassName = "com.mysql.jdbc.Driver";
 
	private int poolSize = 100;
	private static ConnectionPool instance = null;
	Connection conn = null;
 
	/*构造方法，做一些初始化工作*/
	private ConnectionPool() {
		pool = new Vector<Connection>(poolSize);
 
		for (int i = 0; i < poolSize; i++) {
			try {
				Class.forName(driverClassName);
				conn = DriverManager.getConnection(url, username, password);
				pool.add(conn);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
 
	/* 返回连接到连接池 */
	public synchronized void release() {
		pool.add(conn);
	}
 
	/* 返回连接池中的一个数据库连接 */
	public synchronized Connection getConnection() {
		if (pool.size() > 0) {
			Connection conn = pool.get(0);
			pool.remove(conn);
			return conn;
		} else {
			return null;
		}
	}
}
1.5 行为型模型

  1. 策略模式

    对接口分别实现，然后根据不同的需求使用对应的实现类

  2. 观察者模式

    被观察者的改变会通知观察者

    //首先定义一个更新通知接口
public interface Observer{
  void update()
}
//定义观察者
public class Observer1 implements Observer{
  public void update(){
    sout("收到通知了")
  }
}
//定义一个被观察者接口
public interface Subject{
  //注册观察者
  void registerObserver(Observer observer);
  //取消绑定观察者
  void unbindObserver(Observer observer);
  
 //通知所有的观察者*/
  void notifyObservers();

}

//定义一个实现了Subject的抽象类，让其他的要被注册的观察者继承它
public abstract class AbstractSubject implements Subject{
  
  //使用Vector存储Observer队列，防止重复
  private Vector<Observer> vector = new Vector<Observer>();
   
  public void registerObserver(Observer observer){
    vector.add(observer);
  }
  
  public void unbindObserver(Observer observer){
    vertor.remove(observer);
  }
  //通知调用时触发每个Observer的update
  public void notifyObservers(){
   Enumeration<Observer> elems=vector.elements();
    while(elems.hasMoreElements()){
      elems.nextElement().update();
    }
  }

}

//定义一个类去继承AbstractSubject
public class Person extends AbstractSubject {
  
  //为了方便定义在初始化的直接注册观察者
  public Person(Observer... observers[]){
    for(Observer observer : Observers) 
       regiserObserver(observer);
  }
  private int age = 0;
  
  //每年年龄增长通知观察者
  public void addage(){
    age++;
    //发送通知
    notifyObservers();
  }
  
}

  3. 责任链模式

责任链模式核心思想指把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。

FaviconCode
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
离散数学期末复习笔记【精华版】
林大夕可的博客
04-02 14万+
文章目录前言一、????理逻辑1. 命题逻辑2. 等值演算3. 主合取范式、主析取范式4. 【题】推理证明5. 辖域、自由变元、约束变元二、????合1. 环和、环积，幂集，笛卡尔乘积三、 ????????关系1. 自反、对称、传递2&3. 合成运算，逆关系、闭包4. 哈斯图、上下界、偏序5. 等价关系、划分四、????1. 幺元（么元、单位元）、零元、逆元，半群、群、阿尔贝群、独异点、循环独异点2. 【题】由表判断3. 【题】证明五、????论1. 简单图、平凡图、多重图、子图、补图、出度、入度、
数据结构复习笔记1
Assasin_lucky的博客
06-13 47
【代码】数据结构复习笔记。
《计算机网络》复习笔记
热门推荐
hushhw的博客
01-05 14万+
《计算机网络》复习笔记 本复习笔记基于谢希仁的《计算机网络》第五版教材整理。 计算机网络复习笔记 绪论 1 计算机网络 2 因特网概述 3 互联网的组成 P8 4 计算机网络的类别 P17 5 计算机网络的体系结构 P25 物理层 1 物理层下的传输媒体 2 关于信道的几个基本概念 3 信道复用技术 数据链路层 1 使用点对点信道的数据链路层 2点对点协议 PPP P70 3...
软件工程学复习笔记
weixin_51277037的博客
06-01 3444
软件工程期末考试复习笔记
通信原理复习笔记一
小段的博客
11-30 472
##参考 樊昌信,曹丽娜《通信原理》第七版
软件构造复习笔记1
EZ_Darker的博客
06-07 107
本章为软件构造第一章到第四章的复习笔记，因为习惯纸质资料，所以写到本子上，懒得再打一遍，用图片形式呈现，字丑见谅。
复习笔记1-Mysql
ab_empty的博客
08-03 77
复习笔记(一) Mysql部分 https://note.youdao.com/s/VKsCJCTc
离散数学复习笔记
索半斤的博客
08-18 201
hcia复习笔记
m0_74978504的博客
03-18 76
计算机组成原理复习笔记
Annaaaaa1的博客
06-08 1720
就是按照考试的题型写的总结 非常应试版。
复习笔记1
08-03
这篇复习笔记主要涵盖了软件构造和开发过程中的关键概念，包括软件的质量指标、开发过程模型、版本控制系统以及面向对象编程的基础知识。以下是这些知识点的详细说明： 1. **软件质量指标**：软件质量包括内部质量...
机器学习复习笔记1
08-08
考试时间：2018.12.27 7:00 PM-9:00 PM考试地点：A1-302 A1-304第一章Basic Concept机器学习基础（3）Linear
计算机视觉复习笔记1
08-03
"计算机视觉复习笔记1" 计算机视觉是一门交叉学科，它将计算机科学、数学、物理、生物学和工程学结合起来，以研究如何使计算机能够像人一样看到和理解视觉世界。计算机视觉的应用非常广泛，包括图像处理、物体识别...
OS复习笔记1
08-03
这篇复习笔记将深入探讨操作系统的基本概念，包括操作系统的定义、特性和功能，以及在Linux系统中的应用。 1. **操作系统的定义与特性** - **定义**：操作系统（Operating System，简称OS）是管理和控制计算机硬件...
python复习笔记1
08-03
例如，`my_list = [1, 2, 3]`创建了一个包含整数的列表。列表支持多种操作，如`append()`用于在列表末尾添加元素，`extend()`用于合并两个列表，`insert()`用于在指定位置插入元素，`remove()`用于删除指定元素，`...
Java爬虫之Jsoup爬Html网页链接
withme977的博客
06-20 462
Java爬虫Jsoup
日常工作记录目录
与海
06-21 468
EasyExcel实现二维码下载与展示
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 974
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
【C#】找不到属性集方法。get只读属性用了反射设置setValue肯定报错
最新发布
小5聊的博客
06-26 920
找不到属性集方法。get只读属性用了反射设置setValue肯定报错
python复习笔记
12-08
以下是Python复习笔记： 1. Python是一种高级编程语言，它的语法简单易懂，适合初学者入门学习。 2. Python可以用于多种用途，例如Web开发、数据分析、人工智能等。 3. Python的基本数据类型包括整型、浮点型、布尔型、字符串和列表等。 4. Python支持各种运算符，例如算术运算符、比较运算符和逻辑运算符等。 5. Python的控制流语句包括if语句、for循环和while循环等。 6. Python的函数是一段可重用的代码块，可以接受参数并返回值。 7. Python的模块是一个包含Python代码的文件，可以被其他程序导入和使用。 8. Python的标准库包含大量有用的模块和函数，例如math、random和datetime等。 9. Python的第三方库可以扩展Python的功能，例如NumPy、Pandas和TensorFlow等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值