数据结构---------数组

1.Java数组介绍

概念：同一种类型的集合，其实数组就是一个容器
使用优点：可以自动给数组中的元素从0开始编号，方便操作这些元素。
声明的方式：
1. 元素类型[] 数组名=new 元素类型[元素个数或数组长度]
  例：int[] arr=new int[5];
2. 元素类型[] 数组名 =new 元素类型[]{元素，元素，......}
  例：int[] arr=new int[]{3,5,8,6};
  int[] arr={3,5,6,8};
3. 数组的遍历
```
public static void main(String[] args) {

    int[] x = { 1, 2, 3 };

    for (int y = 0; y < x.length; y++) {

        System.out.println(x[y]);
    
        // System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

    } // 那么这就是数组的第一个常见操作.遍历
 
}
```
4. 常见异常
  1. NullPointerException 空指针异常
    引发原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法
  2. ArrayIndexOutOfBoundsException 索引值越界
    引发原因：访问了不存在的索引值。
5. 内存分析

2.自己手写一个数组代码测试，具备以下功能

插入一条新的数据项
寻找特定数据项
删除某一特定数据项
迭代的访问各个数据项，以便进行显示或其他操作

MyArray类
ps:假设操作人是不会添加重复元素的，这里没有考虑重复元素，如果添加重复元素了，后面的查找，删除，修改等操作只会对第一次出现的元素有效。

package com.lsl.array;

public class MyArray {
    //定义一个数组intArray,数组的实际长度elems,数组的最大长度。
    private int[] intArray;
    private int elems;
    private int length;

    //默认构造一个长度为50的数组
    public MyArray(){
        elems=0;
        length=50;
        intArray=new int[length];
    }

    //构造函数传参时创建一个长度为length的数组
    public MyArray(int length){
        elems=0;
        this.length=length;
        intArray=new int[length];
    }

    //1.创建获得数组有效长度的方法
    public int getSize(){
        return elems;
    }

    //2.遍历元素,打印元素值
    public void display(){
        for (int i=0;i<elems;i++){
            System.out.print(intArray[i]+" ");
        }
        System.out.println();
    }

    //3.添加元素
    public boolean add(int value){
        if (elems==length){
            return false;
        }else{
            intArray[elems]=value;
            elems++;
        }
        return true;
    }

    //4.根据下标获取元素
    public int get(int i){
        if (i<0||i>elems){
            System.out.println("访问下标越界！");
        }
        return intArray[i];
    }

    //5.查找元素下标
    public int find(int searchValue){
        int i;
        for (i=0;i<elems;i++){
            if (intArray[i]==searchValue){
                break;
            }
        }
        if (i==elems){
            return -1;
        }
        return i;
    }

    //6.删除元素
    public boolean delete(int value){
        int k=find(value);
        if (k!=-1){
            if (k==elems-1){
                elems--;
            }else{
                for(int i=k;i<elems-1;i++){
                    intArray[i]=intArray[i+1];
                }
                elems--;
            }
        }else{
            return false;
        }
        return true;
    }

    //7.修改数据
    public boolean modify(int oldValue,int newValue){
        int k=find(oldValue);
        if (k!=-1){
            intArray[k]=newValue;
        }else{
            System.out.println("修改的数据不存在！");
            return false;
        }
        return true;
    }
}

MyArrayTest类

package com.lsl.array;

public class MyArrayTest {
    public static void main(String[] args){
        //创建自定义封装数组结构，数组大小为4
        MyArray array = new MyArray(4);
        //添加4个元素分别是1,0,2,4
        array.add(1);
        array.add(0);
        array.add(2);
        array.add(4);
        //显示数组元素
        array.display();
        //根据下标为0的元素
        int i = array.get(0);
        System.out.println(i);
        //删除4的元素
        array.delete(0);
        //将元素3修改为33
        array.modify(2, 345);
        array.display();
    }
}

运行结果

3.分析总结

数组能实现数据结构所有功能，那为什么实际中我们不用它进行所有数据存储呢？

数据局限性：

①、插入快，对于无序数组，上面我们实现的数组就是无序的，即元素没有按照从大到小或者某个特定的顺序排列，只是按照插入的顺序排列。无序数组增加一个元素很简单，只需要在数组末尾添加元素即可，但是有序数组却不一定了，它需要在指定的位置插入。

②、查找慢，当然如果根据下标来查找是很快的。但是通常我们都是根据元素值来查找，给定一个元素值，对于无序数组，我们需要从数组第一个元素开始遍历，直到找到那个元素。有序数组通过特定的算法查找的速度会比无需数组快，后面我们会讲各种排序算法。

③、删除慢，根据元素值删除，我们要先找到该元素所处的位置，然后将元素后面的值整体向前面移动一个位置。也需要比较多的时间。

④、数组一旦创建后，大小就固定了，不能动态扩展数组的元素个数。如果初始化你给一个很大的数组大小，那会白白浪费内存空间，如果给小了，后面数据个数增加了又添加不进去了。

　　很显然，数组虽然插入快，但是查找和删除都比较慢，而且扩展性差，所以我们一般不会用数组来存储数据，那有没有什么数据结构插入、查找、删除都很快，而且还能动态扩展存储个数大小呢，答案是有的，但是这是建立在很复杂的算法基础上，后面会详细讲述。

https://me.csdn.net/qq_39657909