数组(Array)

1.数据结构概述

      1.1 什么是数据结构

• 计算机中数据存储和组织的方式

      1.2 数据结构的分类

• 线性结构: 数组 链表 栈 队列 哈希表
• 树形结构: AVL数 红黑数 B树 堆 Trie 哈夫曼数 并查集
• 图形结构: 邻接矩阵 领接表

2.线性表–数组

      2.1 什么是线性表

• n个相同类型元素的有限序列

      2.2 线性表由什么?

• 数组
• 队列
• 链表
• 栈
• 哈希表

      2.3 什么是数组

• 是一种顺序存储的线性结构,所有的元素地址空间是连续的
• 随机访问速度快 因为访问地址编译器可以直接计算出 ele[ i ] 的 地 址= index + i*每个数据占用字节大小

      2.2 数组的内存分布

• int[ ] arr=new int[ ]{1,2,3 };
  

      2.4 数组缺点

• 不能动态扩容

      2.5 数组升级–动态数组

• 2.5.1 泛型数组和和基本类型的数组空有什么区别?
  • 基本类型数组中存储的是基本类型的值 而泛型数组中存储的对象的地址
  • 假如数组中存储对象,在数组初始化还没有add时,数组占用的空间大小依然为对象的空间 这样会浪费掉空间。
    
• 2.5.2 代码实现

/**
 * 自定义可以存放任何类型的动态数组 所以需要定义:泛型
 * 泛型:new 对象根据传入的类型,确定类中泛型所表示的具体类型
 * 泛型的本质:类型占位符
 * 泛型的好处:扩展类中(属性 方法参数 返回值)类型 提高类的通用性  如果没有泛型需要在定义类属性 参数 返回值类型。
 */
public class DynamicArray2<T> {
   
    // ------------1.属性-------------
    private T[] elements;
    private int size;
    // 数组默认容量 常数定值只有一份 不用变
    private static final int DEFAULT_CAPACITY = 10;
    // 元素不存在
    private static final int ELEMENT_NOT_FOUND = -1;
   // 记录扩容次数 只是为了方便显示而已
    private static int sumCampacity=0;
    // ------------2.构造器-------------
    /**
     * 默认构造10的大小
     */
    public DynamicArray2() {
   
        this(DEFAULT_CAPACITY);
    }
    /**
     * 传入其他长度的构造函数
     *
     * @param capacity
     */
    public DynamicArray2(int capacity) {
   
        elements = (T[]) new Object[capacity];
    }

    // ------------3.方法-------------

    /**
     * 元素的数量
     * @return
     */
    public int size() {
   
        return size;
    };

    /**
     * 是否为空
     *
     * @return
     */
    public boolean isEmpty() {
   
        return size == 0;
    } ;

    /**
     * 是否包含某一个元素
     *  查找元素的角标只要不是-1 即有这个元素
     *
     * @param ele
     * @return
     */
    public boolean contains(T ele) {
   
        return indexOf(ele) != ELEMENT_NOT_FOUND;
    };
    /**
     * 某一个位置添加一个具体的元素
     *
     * @param index
     * @param ele
     */
    public void add(int index,  T ele) {
   
        //1. 判断index是否合法
       rangeCheckForAdd(index);
        //2. 扩容后添加
        if (size == index) {
   
            // 位运算效率高 扩容1.5倍
            int newCampacity=size+(size>>1);
            T[] newElements = (T[])new Object[newCampacity];
            for (int i = 0; i < size; i++) {
   
                newElements[i]=elements[i];
            }
            elements=newElements;
            for (int i = size-1; i < index; i--) {
   
                elements[i]=elements[i-1];
            }
            size++;
            elements[index]=ele;

        }else {
   
            //3.不需要扩容添加
            for (int i = size; i > index; i--) {
   
                elements[i]=elements[i-1];
            }
            size++;
            elements[index]=ele;  }
    };

    /**
     * 添加元素到数组尾部
     *
     * @param ele
     */
    public void add(T ele) {
   
        add(size, ele);
    }


    public T get(int index) {
   
        if(index<0||index >=size) throw new IllegalArgumentException