数据结构-数组（Array）

偏执的太偏执、 2021-09-23 10:58 378阅读 0赞

# 一、什么是数组 #

在某些情况下，虽然可以使用单个变量来存储信息，但是如果需要存储的信息较多（例如存储 50 名学生的成绩），这时再依次创建变量声明并赋值显得非常麻烦。随着处理的信息量越来越大，工作也就越来越烦琐，这时可以使用数组或集合来存储信息。通过使用数组，可以在很大程度上缩短和简化程序代码，从而提高应用程序的效率。数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

# 二、自定义数组图解 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70]  
**图示中：  
data：数组，默认为10的数组空间；  
size：表示在数组中的元素的个数，当数组中没有元素是指向0的位置；  
capacity：数组中的数组空间；**

# 三、自定义数组MyArray #

package lcy.Array;
    
    
    //自定义数组类 使用泛型
    public class MyArray<E> { 
    
        //成员变量
        private E[] data;
        private int size;  //有效的元素的个数
    
        // 构造函数 传入数组的容量capacity构造Array
        public MyArray(int capacity) { 
    
            //Object是所有类的子类 Java不支持new一个泛型 只能先new一个Object 然后再强制转换
            data = (E[]) new Object[capacity];
            size = 0;
        }
    
        // 无参构造函数 默认数组的容量为10
        public MyArray() { 
            this(10);
        }
    
        // 获取数组中元素的个数
        public int getSize() { 
            return size;
        }
    
        // 获取数组的容量
        public int getCapacity() { 
            return data.length;
        }
    
        //返回数组是否为空
        public boolean isEmpty() { 
            return size == 0;
        }
        
        //获取index索引位置的元素
        public E get(int index) { 
            if (index < 0 || index > size) { 
                throw new IllegalArgumentException("Get failed. index is illegal");
            }
            return data[index];
        }
        //获取数组的最后一个元素
        public E getLast() { 
    
            return get(size - 1);
        }
        //获取数组的第一个元素
        public E getFirst() { 
    
            return get(0);
        }
        @Override
        public String toString() { 
            StringBuffer res = new StringBuffer();
            res.append(String.format("MyArray:size=%d,capacity=%d\n", size, data.length));
            res.append('[');
            for (int i = 0; i < size; i++) { 
                res.append(data[i]);
                if (i != size - 1) { 
                    res.append(", ");
                }
            }
            res.append(']');
            return res.toString();
        }
    
        //实现动态数组
        private void resize(int newCapacity) { 
            E[] newData = (E[]) new Object[newCapacity];
            for (int i = 0; i < size; i++) { 
                newData[i] = data[i];
            }
            data = newData;  //将data指向新的数组
        }
    }

# 四、MyArray中增删改查接口 #

## 4.1 在数组中增加元素 ##

//向所有元素前添加一个新元素e
        public void addFirst(E e) { 
            add(0, e);
        }
    
        //向所有元素后添加一个新元素e
        public void addLast(E e) { 
            add(size, e);
        }
    
        //在第index个位置插入一个新元素e
        public void add(int index, E e) { 
    
            if (index < 0 || index > size) { 
                throw new IllegalArgumentException("Add failed. Require index>=0 or Require index>size");
            }
            if (size == data.length) { 
                resize(2 * data.length);
            }
            for (int i = size - 1; i >= index; i--) { 
                data[i + 1] = data[i];
            }
            data[index] = e;
            size++;
        }

## 4.2 在数组中删除元素 ##

//在数组中删除index位置的元素 返回删除的元素
        public E remove(int index) { 
    
            if (index < 0 || index >= size) { 
                throw new IllegalArgumentException("Remove failed. index is illegal");
            }
            E ret = data[index];
            for (int i = index + 1; i < size; i++) { 
                data[i - 1] = data[i];
            }
            size--;
            data[size] = null;
    
            if (size == data.length / 4 && data.length / 2 != 0) { 
                resize(data.length / 2);
            }
            return ret;
        }
    
        //在数组中删除第一个元素 返回删除的元素
        public E removeFirst() { 
            return remove(0);
        }
    
        //在数组中删除最后一个元素 返回删除的元素
        public E removeLast() { 
            return remove(size - 1);
        }
    
        //在数组中删除元素e
        public void removeElement(E e) { 
            int index = find(e);
            if (index != -1) { 
                remove(index);
            }
        }

## 4.3 修改数组中的元素 ##

//修改index索引位置的元素为e
        public void set(int index, E e) { 
            if (index < 0 || index > size) { 
                throw new IllegalArgumentException("Get failed. index is illegal");
            }
            data[index] = e;
        }

## 4.4 查找数组中的元素 ##

//查看数组中元素e所在的索引 如果不存在元素e 则返回-1
        public int find(E e) { 
            for (int i = 0; i < size; i++) { 
                if (data[i].equals(e)) { 
                    return i;
                }
            }
            return -1;
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMjI5NTQz_size_16_color_FFFFFF_t_70]: /images/20210923/467bd56c34ef48d3bee39fa3cbb2f508.png