（二）Java数据结构和算法——数组

一、数组的实现

• 上一篇博客我们介绍了一个数据结构必须具有以下基本功能：

　　①、如何插入一条新的数据项

　　②、如何寻找某一特定的数据项

　　③、如何删除某一特定的数据项

　　④、如何迭代的访问各个数据项，以便进行显示或其他操作

package arrays;

import java.util.Arrays;

public class MyArray {

    private int[] intArray;

    private int elems;

    private int length;

    /**
     * 默认创建一个长度为50的素组
     */
    public MyArray(){
        elems = 0;
        length = 50 ;
        intArray = new int[length];

    }

    /**
     * 自定义数组长度
     * @param length
     */
    public MyArray(int length){
        elems = 0;
        this.length = length;
        intArray = new int[length];
    }

    public int getSize(){
        return elems;
    }

    /**
     * 遍历数组
     */
    public void display(){
        for(int i=0;i<elems;i++){
            System.out.println(intArray[i]);
        }
    }

    /**
     * 添加元素，
     * 添加成功返回true，添加的元素超过范围了返回false
     * @param value
     * @return
     */
    public boolean add(int value){

        if(elems == length){
            return false;
        }
        intArray[elems] = value;
        elems++;
        return  true;

    }

    /**
     * 根据下标获取元素
     *
     * @param index
     * @return
     */
    public int get(int index)  {
        if(index<0 || index>elems){
            System.out.println("数组元素越界");

        }

        return intArray[index];
    }

    /**
     * 查找元素
     *
     * @return 如果找到则返回元素下标，如果不存在则返回-1
     */
    public int search(int value){

        for(int i=0;i<elems;i++){
            if(intArray[i] == value){
                return i;
            }
        }
        return -1;
    }

    /**
     * 删除元素
     * @param value
     * @return 删除成功返回true，删除的值不存在返回false
     */
    public boolean delete(int value){

      int index =   search(value);

      if(index != -1){

        if(index == elems-1){
            //刚好是最后一个元素
            elems--;
        }else{
            //将目标元素索引之后的元素全部往前移一位
            for(int i=index;i<elems;i++){
                intArray[i] = intArray[i+1];
            }
            elems--;
        }

        return true;
      }else{
          System.out.println("该值不存在");
          return false;
      }

    }

    /**
     * 修改值
     * @param oldValue
     * @param newValue
     * @return 修改成功返回true，失败返回false
     */
    public boolean modify(int oldValue ,int newValue){

       int index =  search(oldValue);
       if(index == -1){
           System.out.println("修改失败：该值不存在");
           return false;
       }else{
            intArray[index] =  newValue;
            return true;
       }

    }

}

测试：

  public static void main(String[] args) {
        MyArray myArray = new MyArray(7);
        myArray.add(1);
        myArray.add(10);
        myArray.add(15);
        myArray.add(20);
        myArray.add(25);
        myArray.display();

        System.out.println("第0个元素为="+myArray.get(0));
        myArray.delete(1);
        System.out.println("删除后的数组为");
        myArray.display();

        myArray.modify(15,1555);
        System.out.println("修改后的数组为");
        myArray.display();
    }

结果：

二、数组的优缺点

数组的局限性分析：

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

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

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

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

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