MyArray --手写集合

package com.chixing.selfclass;

import java.util.Arrays;

/**
 * 1. 自定义一个集合工具类MyArray：(假设默认该集合存放int类型数据)
 *         初始默认数组，长度为10，添加到第11个元素时，需要扩容，（2n+1倍）
 *
 *         实现添加数据 public void add(int data){...}
 *         删除数据 public void remove(){...}
 *         根据下标获得数据public  int getData(int index){...}
 *         判断集合中是否包含该元素public boolean contains(int data){..}
 *         获得集合中元素的个数public int getSize(){...}
 *         返回该元素所在数组的下标，若该元素不存在，则返回-1 , public int indexOf(int data){...}
 *         清除集合中所有的元素public void clear(){...}
 *         按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组
 * public int[] toArray(){...}
 *
 *
 *         注意: new MyArray() 表示 创建了一个容器对象，可以在该容器中添加元素、删除元素等操作
 */
public class MyArray<T>{
    private int a = 10;
    //初始化数组，长度为10
    private Object myArray[] = null;//默认容器
    //计数器
    private static int count = 0;//容器中元素的个数
    public MyArray(){
        this(10);
    }

    /**
     * 构造函数
     * @param capacity 指定该容器的初始容量
     */
    public MyArray(int capacity){
       myArray = new Object[capacity];
    }

    /**
     * 添加数据
     * @param data 要添加的数据
     */
    public void add(T data){
        //容量为10的数组完成赋值，此时count = 数组的长度;进行扩容，防止继续调用add方法
        //先判断，防止删除元素
        if (count >= myArray.length){
            //扩容大小
            //再添加元素需要扩容
            //将原数组中的值逐个赋给扩容后的数组
            //最后把扩容过的新数组引用给原来的数组,覆盖掉源数组
            myArray =  Arrays.copyOf(myArray,myArray.length * 2 + 1);
        }
        //从0开始添加数据，调用一次添加方法，count++
        //这样下一次可以从未赋值处继续赋值
        myArray[count++] = data;

    }

    public void add(int index,T data){
        if (index <0 || index > count)
            throw new IndexOutOfBoundsException();
        //如果不需要扩容
        if (count < myArray.length){
            //索引后的元素依次后移
            System.arraycopy(myArray,index,myArray,index+1,count-index);
        }else {
            //需要扩容
            Object[] newArray = new Object[myArray.length * 2 +1];
            System.arraycopy(myArray,0,newArray,0,index);//复制旧数组的前半部分
            System.arraycopy(myArray,index,newArray,index+1,count-index);//复制旧数组的后半部分
            myArray[index] = data;
            myArray = newArray;
        }
    }


    /**
     * 删除数据(数组中所有出的data元素)
     * @param data 待删除的数据
     */
    public void removeAll(T data){
        //防止元素清空
        if (count == 0)
            throw new NullPointerException();//对象清空，则抛出空指针异常
        //将要删除的数据和数组中的数据进行比较
        for (int i = 0; i < count ;i++){
            while (myArray[i] == data) {
                //循环前移
                System.arraycopy(myArray, i + 1, myArray, i, myArray.length - i - 1);
                count--;
            }
        }
    }

    /**
     * 删除指定索引的数据
     * @param index 指定索引
     */
    public void removeIndexOf(int index){
        //防止元素清空
        if (count == 0)
            throw new NullPointerException();//对象清空，则抛出空指针异常
        if (index >= count || index < 0)
            throw new IndexOutOfBoundsException();
        //将要删除的数据和数组中的数据进行比较
        for (int i = 0; i < count ;i++){
            if (myArray[i] == myArray[index]) {
                //循环前移
                System.arraycopy(myArray, i + 1, myArray, i, myArray.length - i - 1);
                count--;
                break;
            }
        }
    }

    /**
     * 获取指定索引出的元素
     * @param index 给定索引
     * @return 返回索引对应的元素p
     */
    public  Object getData(int index){
/*        //防止元素清空
        if (count == 0 )
            throw new ArrayIndexOutOfBoundsException();*/
        //循环和数组中的元素进行比较，如果有，输出
                return myArray[index];
    }

    /**
     * 判断集合中是否包含该元素
     * @param data 要判断的数据
     * @return 返回结果，有true无false
     */
    public boolean contains(T data){
        //防止元素清空
        if (count == 0 )
            throw new NullPointerException();//对象清空，则抛出空指针异常
        //循环和数组中的元素进行比较，如果有返回true
        for (int i =0; i< count;i++)
                return myArray[i] == data;
        return false;
    }

    /**
     * 获得集合中元素的个数
     * @return 集合元素的个数
     */
    public int getSize(){
        return count;
    }

    /**
     *  返回该元素第一次出现所在数组的下标，若该元素不存在，则返回-1
     * @param data 要判断的元素
     * @return 返回结果或者-1
     */
    public int indexOf(T data){
        //防止元素清空
        if (count == 0)
            throw new NullPointerException();
        //循环和数组中的元素进行比较，如果有，输出
        for (int i =0; i< count;i++){
            if (myArray[i] == data)
                return i;
        }
        return -1;
    }

    /**
     *找出数组中所有该元素的索引
     * @param data 要找的元素
     */
    public void indexOfAll(T data){
        //防止元素清空
        if (count == 0)
            throw new NullPointerException();
        //循环和数组中的元素进行比较，如果有，输出
        for (int i =0; i< count;i++){
            if (myArray[i] == data)
                System.out.print(i+" ");
        }
    }

    /**
     * 清空集合中的所有元素
     */
    public void clear(){
        for (int i = 0; i < count;i++)
            myArray[i] = null;
        count = 0;
    }

    /**
     * 按照从小到大为集合中的元素排序
     * @return 已经排序的数组
     */
/*    public int[] sort(){
        if (count == 0)
            throw new NullPointerException();
        //快速排序
        quickSort(myArray,0,count-1);
        return myArray;
    }*/

    /**
     * 快速排序
     * @param array 要排序的数组
     * @param low 最小索引
     * @param high 最小索引
     */
    private static void quickSort(int[] array,int low,int high){
        if (low < high) {
            //首先获得找到的中位值
            int middle = getMiddle(array, low, high);
            //排序中位左边
            quickSort(array, low, middle - 1);
            //排序中位右边
            quickSort(array, middle + 1, high);
        }
    }

    /**
     * 获取快速排序每次需要的中位值
     * @param array 要排序的数组
     * @param low 最小索引
     * @param high 最大索引
     * @return 中位值
     */
    private static int getMiddle(int[] array,int low,int high){
        //存储最小索引出元素用于基数
        int temp = array[low];
        while (low < high){
            while (low < high && array[high] > temp){
                high--;
            }
            array[low] = array[high];
            //防止出现重复元素，加=
            while (low < high && array[low] <= temp){
                low++;
            }
            array[high] = array[low];
        }
        array[low] = temp;
        return low;
    }

    /**
     * 遍历数组
     */
    public  void printArr(){
        if (count == 0)
            throw new NullPointerException();
        int temp = 0;
        for (int i = 0 ; i <count;i++){
            System.out.print(myArray[i] + "\t");
            temp++;
            if (temp == 10){
                System.out.println();
                temp =0;
            }
        }
        System.out.println();
    }
}