数组

数组的声明

第一种方式：数据类型 [] 数组名称 = new 数据类型[数组长度];

这里 [] 可以放在数组名称的前面，也可以放在数组名称的后面，我们推荐放在数组名称的前面，这样看上去 数据类型 [] 表示的很明显是一个数组类型，而放在数组名称后面，则不是那么直观。

第二种方式：数据类型 [] 数组名称 = {数组元素1，数组元素2，……}

这种方式声明数组的同时直接给定了数组的元素，数组的大小由给定的数组元素个数决定。
//声明数组1,声明一个长度为3，只能存放int类型的数据
int [] myArray = new int[3];
//声明数组2,声明一个数组元素为 1,2,3的int类型数组
int [] myArray2 = {1,2,3};

实现用类封装数组实现数据结构

public class MyArray {
       private Object[] objArray;
       private int elems;// 有效长度
       private int length;// 最大长度

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

       // 构造函数，初始化一个长度为length 的数组
       public MyArray(int length) {
               elems = 0;
               this.length = length;
               objArray = new Object[length];
       }

       // 获取数组的有效长度
       public int getSize() {
               return elems;
       }

       // 遍历显示元素
       public void display() {
               for (int i = 0; i < elems; i++) {
                       System.out.print(objArray[i] + " ");
               }
       }

       /**
        * 添加元素
        *
        * @param value
        * @return添加成功返回true,添加的元素超过范围了或者元素已存在返回false
        */
       public boolean add(Object value) {
               if (elems == length) {
                       return false;
               }
               if (find(value) >= 0) {
                       return false;
               } else {
                       objArray[elems] = value;
                       elems++;
                       return true;
               }
       }

       /**
        * 根据下标获取元素
        *
        * @param i
        * @return查找下标值在数组下标有效范围内，返回下标所表示的元素 查找下标超出数组下标有效值，提示访问下标越界
        */
       public Object get(int i) {
               if (i < 0 || i > elems) {
                       System.out.println("访问下标越界");
               }
               return objArray[i];
       }

       /**
        * 查找元素
        *
        * @param searchValue
        * @return查找的元素如果存在则返回下标值，如果不存在，返回 -1
        */
       public int find(Object searchValue) {
               int i;
               for (i = 0; i < elems; i++) {
                       if (null != searchValue && searchValue.equals(objArray[i])) {
                               break;
                       }
               }
               return i == elems ? -1 : i;
       }

       /**
        * 删除元素
        *
        * @param value
        * @return如果要删除的值不存在，直接返回 false;否则返回true，删除成功
        */
       public boolean delete(Object value) {
               int k = find(value);
               if (k == -1) {
                       return false;
               }
               if (k != elems - 1) {
                       for (int i = k; i < elems - 1; i++) {
                               objArray[i] = objArray[i + 1];// 在元素所在位置之后数据前移
                       }
               }
               objArray[elems] = null;
               elems--;
               return true;
       }

       /**
        * 修改数据
        *
        * @param oldValue原值
        * @param newValue新值
        * @return修改成功返回true，修改失败返回false
        */
       public boolean modify(Object oldValue, Object newValue) {
               int i = find(oldValue);
               if (i == -1) {
                       System.out.println("需要修改的数据不存在");
                       return false;
               } else {
                       objArray[i] = newValue;
                       return true;
               }
       }
}