数据结构--数组

一、数组的介绍

数组：数据结构中最基本的一个结构就是线性结构，而线性结构又分为连续存储结构和离散存储结构。所谓的连续存储结构其实就是数组。
优点： 查询较快如果知道坐标可以快速去地存取
缺点： 删除慢,大小固定

二、封装数组

二次封装数组的增删改查

1. 基类的定义

定义一个工具类名称-Array
接受的参数包括基本类型和自定义类型（用泛型来接受，基本类型用包装类）
自定义属性两个：size用来表示数组的大小，data用来表示一个准确的集合
概念区分：size表示数组的大小，capacity表示数组容量的大小
构造函数：有参构造，接受一个int值，用来初始化数组容量；无参构造：给容量一个默认值
toString()方法，输出数组的大小和数组容量的大小，以及数组中的值
getSize()方法，调用方通过方法来获取数组的大小
getCapacity()方法，调用方通过方法来获取数组容量的大小
isEmpty()方法，调用方通过方法来判断数组是否为空(指的是数组中是否有值，没值就为空)

2. 增：添加的方法

add()方法，两个参数，添加元素的索引位置，和元素的值
addFirst()方法，在所有元素的最前面添加
addLast()方法，在所有元素的最后面添加

3. 改：添加的方法

set，两个参数，修改的元素的索引位置，和将要修改的值

4. 查：添加的方法

get()方法，一个参数，索引值，根据索引返回对应的值
contains()方法，一个参数，判断数组中是否包含某个元素
find()方法，一个参数，查找数组中是否包含param，如果包含返回索引值，不包含返回-1
findAll()方法，一个参数，查找数组中是否包含param，返回包含的索引数组

5. 删：添加的方法

remove()方法，数组中删除index位置的元素，并且返回对应的值
removeFirst()方法，删除第一位元素
removeLast()方法，删除最后一位元素
removeElement()方法，查看某个值是否在数组中存在，如果存在,删除并返回true，如果不存在返回false、
removeAllElement()方法，查找所有元素，获取所有相等的索引，遍历移除

6. 扩容的方法

resize()方法，定义为私有，调用方不能通过方法来调用，去修改，否则容易造成BUG
扩容倍数，如果用固定值，不好抉择。比如：100容量，扩容10个，没有意义，很快就满了；100容量，扩充1000个，太多了，容易早证浪费。最好选择倍数，都在同一个单位级别，这里代码选择的是2倍
添加的时候需要判断扩容，删除的时候需要删除容量，减少资源浪费
删除的时候，当元素减少到容量的1/4的时候开始缩，缩减到容量的1/2
如果选择1/2的时候开始缩减，然后缩减到1/2会有一定的问题，例如：容量10，现在容量满了，来了一个元素，需要扩容，按照设置的扩容机制，会扩容2倍，也就是20容量，如果删除了一个元素，元素达到了容量的1/2，我们开始进行缩减，缩减1/2，容量又变为10。如果一直在这个临界值，那么元素会一直进行扩容缩减扩容缩减，性能影响太大。
如果选择1/4的时候开始缩减，然后缩减到1/2，这样能够较好的避开以上问题，例如：容量10，容量满了，来了一个元素，扩容容量到了20，如果删除一个元素，还不到容量的1/4，所以还不会进行缩减，如果真的到了容量的1/4的时候，我们选择缩减1/2，容量也需要一定的元素，才会进行扩容，防止了容量一直扩容或者缩减

代码如下

public class Array{
    private E[] data;
    private Integer size;
　　/**
　　 * 无参构造器
　　 */
    public Array(){
          this(10);
    }
    public Array(int capacity){
          data = (E[])new Object[capacity];
          size = 0;
    }
　　/**
     * 获取数组中的元素个数
     * @return
     */
    public Integer getSize(){
        return size;
    }
    /**
     * 获取数组的容量
     * @return
     */
    public Integer getCapacity(){
        return data.length;
    }

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

　　// 增：添加代码

　　//指定位置添加内容
　　public void add(int index, E param){
　　　　if(index < 0 || index >= size){
　　　　　　throw new IllegalArgumentException("Add fail, Because index is illegal");
　　　　}
　　　　//当内容大小size等于数组长度length，进行扩容处理
　　　　if(size == data.length){ 
　　　　　　resize(data.length * 2);
　　　　]
　　　　for(int i = size-1; i >= index; i--){
　　　　　　data[i + 1] = data[i];
　　　　}
　　　　data[index] = param;
　　　　size ++;
　　}
　　//在首位添加
　　public void addFirst(E param){
　　　　add(0,E param);
　　}
　　//在尾部添加
　　public void addLast(E param){
　　　　add(size - 1, param);
　　}
　　
　　//改：修改代码

　　//修改指定位置的内容
　　public void set(int index, E param){
　　　　if(index < 0 || index >= size ){
　　　　　　throw new IllegalArgumentException("Set Fail, Because index is illegal.");
　　　　}
　　　　data[index] = param;
　　}
　　
　　//查：查询代码
　　　
　　//返回指定位置的内容
　　public E get(int index){
　　　　if(index < 0 || index >= size){
　　　　　　throw new IllegalArgumentException("Get Fail, Because index is illegal");
　　　　}
　　　　return data[index];
　　}
　　//是否包含指定元素
　　public boolean contains(E param){
　　　　for(int i=0; i< size; i++){
　　　　　　if(Objects.equals(data[i],param)){
　　　　　　　　return true;
　　　　　　}
　　　　}
　　　　return false;
　　}
　　//返回指定内容第一个索引值
　　public Integer find(E param){
　　　　for(int i=0; i< size; i++){
　　　　　　if(Objects.equals(data[i],param)){
　　　　　　　　return i;
　　　　　　}
　　　　}
　　　　return -1;
　　}
　　//返回指定内容的所有索引值
　　public Integer[] findAll(E param){
　　　　int temp = 0;
　　　　Integer[] indexs = new Integer[size];
　　　　for(int i=0; i< size; i++){
　　　　　　if(Objects.equals(data[i],param)){
　　　　　　　  index[temp] = i;
　　　　　　　  temp ++;
　　　　　　}
　　　　}
　　　　return indexs;
　　}

　　//删：删除代码

　　//指定位置删除内容
　　public E remove(int index){
　　　　if(index < 0 || index >= size){
　　　　　　throw new IllegalArgumentException("Remove fail. Because index is illegal");
　　　　}
　　　　E delResult = data[index];
　　　　//将索引index之前的内容，统一向前移动一个位置
　　　　for(int i = index; i< size - 1; i++){
　　　　　　data[i] = data[i + 1];
　　　　}
　　　　size --;
　　　　//当内容长度小于等于data长度的四分之一，且data.length大于0，进行减容处理
　　　　if(size <= data.length/4 && data.length > 2){
　　　　　　　resize(data.length / 2);
　　　　}
　　　　return delResult;
　　}
　　//删除第一位
　　public E removeFirst(){
　　　　return remove(0);
　　}
　　//删除最后一位
　　public E removeLast(){
　　　　return remove(size - 1);
　　}
　　//移除指定内容.如果存在 删除成功，否则失败
　　public boolean removeElement(E param){
　　　　int paramIndex = find(param);
　　　　if(paramIndex != -1){
　　　　　　remove(paramIndex);
　　　　　　return true;
　　　　}
　　　　return false;
　　}
　　//移除所有，遍历删除
　　public void removeAllElement(E param){
　　　　for(int i = 0; i< size; i++){
　　　　　　removeElement(param);
　　　　}
　　}

　　//数组容积处理
　　public void resize(int newCapacity){
　　　　E[] newData = (E[])new Object[newCapacity];
　　　　for(int i=0; i< size; i++){
　　　　　　newData[i] = data[i];
　　　　}
　　　　data = newData;
　　}

　　@Override
　　public String toString(){
　　　　StringBuffer bf = new StringBuffer();
　　　　bf.append(String.format("Array:size = %d,capacity = %d\n ", size, data.length));
　　　　for(int i=0; i<size; i++){
　　　　　　bf.append(data[i]);
　　　　　　if(i != size-1){
　　　　　　　　bf.append(", ");
　　　　　　}
　　　　}
　　　　bf.append("]");
　　　　return bf.toString();
　　}
}

posted @ 2019-11-06 17:13 王大军阅读(235) 评论(0) 编辑收藏举报

刷新页面返回顶部