数据结构（数组）

数组：

一、数组基础

  1、概念：用来存储一组相同数据类型的数据；

  2、在内存中分配连续的空间，数组创建时要指定容量（大小）；

  3、初始化：

         数据类型[] 数组名  = new int[6];

         数据类型[] 数组名  = {1,2,3,4,5,6};

  4、索引--访问数组时通过索引进行操作

  5、索引从0开始，最大为array.length-1

  6、常见的数组：字符串、对象数组、哈希表

  7、空指针：nullPoint  NullPointException

  8、数组越界:outofindex   ArrayIndexOutOfBoundsException

二、使用数组时，最重要的就是数组的索引，通过索引可以对数组进行改和查操作。

    索引：可以有语义，也可以没有语义（理解），

          数组最好运用于索引有语义的情况；

          数组最大的优点：快速查询。

四、产生的问题：

五、基于java中的数组，进行二次封装，创建可变数组：

1、创建数组：
public class MyselfArray {

    //数据容器
    private int[] data;
    //实际保存数据个数  size表示数组中有效元素的个数
    private int size;

    //指定数组容积
    MyselfArray(){
        this(20);
    }

    //定义数组容积
    MyselfArray(int capacity){
        this.size = 0;
        data = new int[capacity];
    }

    //数据容器
    public int[] getData() {
        return data;
    }

    public void setData(int[] data) {
        this.data = data;
    }

    //获取数组中实际保存元素的个数
    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    //判断数组是否为空
    public boolean isEmpty() {
        return this.size == 0;
    }
}

2、在数组指定位置添加元素

    

public void add(int index,int ele){

        //判断数组是否已满
        if(this.size == data.length) {
            throw new IllegalArgumentException("this array is full");
        }

       //判断索引是否有效
        if(index < 0 || index > size){
            throw new IllegalArgumentException("index is error");
        }
        for (int i = size-1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = ele;
        this.size++;
    }

3、在数组尾部添加元素

    //调用“在指定位置添加元素”方法
    public void addTail(int ele){
        add(this.size,ele);
    }

    //直接添加
    public void addTail(int ele){
        if(this.size >= data.length){
            throw new IllegalArgumentException("index our of arrayRange");
        }
        data[size] = ele;
        this.size += 1;
    }

4、在数组头部添加元素

    //调用“在指定位置添加元素”方法
    public void addHead(int ele){
        add(0,ele);
    }

5、获取指定位置元素

    public int getEleByIndex(int index) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index is error");
        }
        return data[index];
    }

6、修改指定位置的元素

    public void updateNuIndex(int index,int ele) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index is error");
        }
        data[index] = ele;
    }

7、是否包含指定元素内容 返回索引

    public int isContains(int ele) {
        for (int i = 0; i < size; i++) {
            if(this.data[i] == ele){
                return i;
            }
        }
        return -1;
    }

8、删除指定位置的元素

   

    public int remove(int index){
        //判断索引的有效性
        if(index < 0 || index >= index){
            throw new IllegalArgumentException("index is invalid");
        }
        //前移操作
        int result = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        this.size--;
        data[size] = 0;
        return result;
    }

9、删除指定元素

    public int removeEle(int ele){
        //判断元素是否存在
        int index = isContains(ele);
        if(index != -1) {
            remove(index);
        }
        return index;
    }

    //删除头部元素
    public int removeHead(){
        return remove(0);
    }

    //删除尾部元素
    public int removeTail(){
        return remove(this.size - 1);
    }

10、方法重写
  

@Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < this.size; i++) {
            sb.append(data[i]);
            if(i != this.size -1){
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }

11、动态数组  修改数组容积

    public void resize(int newCapacity){
            T[] newData = (T[]) new Object[newCapacity];
            for (int i = 0; i < this.size; i++) {
                newData[i] = data[i];
            }
            this.data = newData;
        }

        //进行缩容操作
        if(this.size == data.length / 2 && data.length / 2 > 0) {
            resize(data.length / 2);
        }

        //如果数组已满，进行扩容操作
        if(this.size == data.length) {
            resize(2 * data.length);
        }

12、使用泛型  （任意类型的数组）

      不能是基本数据类型，只能是类对象

      基本数据类型：8种

           byte  char  boolean  int  short  float  double  long

      每种基本数据类型都有一个对应的包装类。

//使用泛型
public class MyselfArrays<T> {
    //数据容器
    private T[] data;
    //实际保存数据个数  size表示数组中有效元素的个数
    private int size;

    MyselfArrays(){
        this(20);
    }

    //capacity  数组容积
    MyselfArrays(int capacity){
        this.size = 0;
        data = (T[]) new Object[capacity];
    }

    //数据容器
    public T[] getData() {
        return data;
    }

    public void setData(T[] data) {
        this.data = data;
    }

    //获取数组中实际保存元素的个数
    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    //判断数组是否为空
    public boolean isEmpty() {
        return this.size == 0;
    }

    //向数组尾部添加元素
    public void addTail(T ele){
        add(this.size,ele);
/*        if(this.size >= data.length){
            throw new IllegalArgumentException("index our of arrayRange");
        }
        data[size] = ele;
        this.size += 1;*/
    }

    //向指定位置添加元素
    public void add(int index,T ele){
        //判断数组是否已满
        //如果数组已满，进行扩容操作
        if(this.size == data.length) {
            resize(2 * data.length);
        }
        //判断索引是否有效
        if(index < 0 || index > size){
            throw new IllegalArgumentException("index is error");
        }
        for (int i = size-1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = ele;
        this.size++;
    }

    //在数组头部添加
    public void addHead(T ele){
        add(0,ele);
    }

    //获取指定位置的元素
    public T getEleByIndex(int index) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index is error");
        }
        return data[index];
    }

    //修改指定位置的元素
    public void updateNuIndex(int index,T ele) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index is error");
        }
        data[index] = ele;
    }

    //是否包含指定元素内容 返回索引
    public int isContains(T ele) {
        for (int i = 0; i < size; i++) {
            if(this.data[i].equals(ele)){
                return i;
            }
        }
        return -1;
    }


    //删除指定位置的元素
    public T remove(int index){
        //判断索引的有效性
        if(index < 0 || index >= index){
            throw new IllegalArgumentException("index is invalid");
        }
        //前移操作
        T result = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        this.size--;
        data[size] = null;

        //进行缩容操作
        if(this.size == data.length / 2 && data.length / 2 > 0) {
            resize(data.length / 2);
        }
        return result;
    }

    //删除指定元素
    public int removeEle(T ele){
        //判断元素是否存在
        int index = isContains(ele);
        if(index != -1) {
            remove(index);
        }
        return index;
    }

    //删除头部元素
    public T removeHead(){
        return remove(0);
    }

    //删除尾部元素
    public T removeTail(){
        return remove(this.size - 1);
    }


    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < this.size; i++) {
            sb.append(data[i].toString());
            if(i != this.size -1){
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }


    //动态数组 修改数组容积
    public void resize(int newCapacity){
            T[] newData = (T[]) new Object[newCapacity];
            for (int i = 0; i < this.size; i++) {
                newData[i] = data[i];
            }
            this.data = newData;
    }
}