Javase 第六次作业

动态数组：

接口实现

public interface List<E> {
    //元素个数
    int size();

    //是否为空
    boolean isEmpty();

    //添加
    void add(E ele);

    /**
     * 指定位置添加元素
     *
     * @param index
     * @param element
     */
    void add(int index, E element);

    //获取第i个元素
    Object get(int index);

    //删除元素
    void remove(Object element);

    Object remove(int index);

    //是否包含某个元素
    boolean contains(Object element);

    //清空元素
    void clear();

    //更新元素
    Object replace(int index, E element);

    //设置index位置的元素
    Object set(int index, E element);

    //获取指定元素对应的下标
    int indexOf(Object e);
}

public class ArrayList<E> implements List<E>, Iterable<E> {
    //元素个数
    private int size;
    //底层数组
    private E[] elements;
    //没有找到元素返回值-1
    private static final int ELEMENT_NOT_FOUND = -1;
    //默认容量
    private static final int DEFAULT_CAPACITY = 16;

    /**
     * 无参构造方法,
     * 用户没有输入容量，则使用程序的默认容量
     */
    public ArrayList() {
        this(DEFAULT_CAPACITY);
    }

    /**
     * 构造方法
     *
     * @param capacity 初始容量，由用户输入
     */
    public ArrayList(int capacity) {
        //如果用户输入的容量小于0，抛异常，
        if (capacity < 0) {
            throw new IllegalArgumentException("Illegal Capacity:" +
                    capacity);
        }
        this.elements = (E[]) new Object[capacity];
        this.size = 0;
    }

    /**
     * 打印数组内的元素
     *
     * @return
     */
    @Override
    public String toString() {
        StringBuffer stringBuffer = new StringBuffer();
        if (size == 0) {
            stringBuffer.append("[]");
            return stringBuffer.toString();
        }
        stringBuffer.append("size=").append(size).append(",[");
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                stringBuffer.append(", ");
            }
            stringBuffer.append(elements[i]);
            /*if (i != size-1){
                stringBuffer.append(", ");
            }*/
        }
        stringBuffer.append("]");
        return stringBuffer.toString();
    }

    /**
     * @return 返回元素个数
     */
    @Override
    public int size() {
        return size;
    }

    /**
     * 返回元素是否为空
     *
     * @return true表示为空
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * @param ele
     */
    @Override
    public void add(E ele) {
        grow(elements.length);
        elements[size++] = ele;
    }

    /**
     * 检查数组下标是否越界
     *
     * @param index
     */
    private void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("数组下标越界异常-->Index:" + index + "-->Size:" + size);
        }
    }

    /**
     * 插入一个元素
     *
     * @param index
     * @param element
     */
    @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        //index=size为在数组最后添加元素
        if (index == size) {
            add(element);
        } else {
            //数组元素个数加一
            size++;
            grow(elements.length);
            for (int i = size - 1; i > index; i--) {
                elements[i] = elements[i - 1];
            }
            elements[index] = element;
        }
    }

    /**
     * 返回元素下标对应的元素值
     *
     * @param index 元素下标
     * @return
     */
    @Override
    public Object get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("数组下标越界异常-->Index:" + index + "-->Size:" + size);
        }
        return elements[index];
    }

    /**
     * @param element
     */
    @Override
    public void remove(Object element) {
        remove(indexOf(element));
    }

    /**
     * 删除下标为index的元素，并返回该元素值
     *
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("数组下标越界异常-->Index:" + index + "-->Size:" + size);
        }
        E ele = elements[index];
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i + 1];
        }
        //size--;
        //去除最后一个元素并元素个数减一
        elements[--size] = null;
        grow(elements.length);
        return ele;
    }

    /**
     * 是否包含某个元素
     *
     * @param element
     * @return
     */
    @Override
    public boolean contains(Object element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        this.size = 0;
    }

    /**
     * 设置下标index位置的元素
     *
     * @param index   下标
     * @param element 新的元素
     * @return 被覆盖的元素
     */
    @Override
    public E replace(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("数组下标越界异常-->Index:" + index + "-->Size:" + size);
        }
        E oldEle = elements[index];
        elements[index] = element;
        return oldEle;
    }

    /**
     * 设置下标index位置的元素
     *
     * @param index   下标
     * @param element 新的元素
     * @return 被覆盖的元素
     */
    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("数组下标越界异常-->Index:" + index + "-->Size:" + size);
        }
        E oldEle = elements[index];
        elements[index] = element;
        return oldEle;
    }

    /**
     * 没有找到该元素返回-1
     *
     * @param element
     * @return 找到了返回元素下标
     */
    @Override
    public int indexOf(Object element) {
        /**
         * 关于传递null的处理，避免发生空指针异常
         *      如果传递的值为null，则返回第一个为null的元素下标
         */
        if (element == null) {
            for (int i = 0; i < size; i++) {
                elements[i] = null;
                return i;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (elements[i].equals(element))
                    return i;
            }
        }

        return ELEMENT_NOT_FOUND;
    }

    /**
     * 数组的扩容，缩小或者扩大，扩容因子0.5
     * @param oldCapacity
     */
    private void grow(int oldCapacity) {
        int newCapacity = 0;
        if (elements.length == size) {
            //扩容因子0.5
            newCapacity = oldCapacity + oldCapacity >> 1;
            E[] newElements = (E[]) new Object[newCapacity];
            copyOf(elements, newElements);
            return;
        }
        if (size < elements.length / 4 && size > DEFAULT_CAPACITY) {
            //数组缩小，0.5
            newCapacity = oldCapacity >> 1;
            E[] newElements = (E[]) new Object[newCapacity];
            copyOf(elements, newElements);
            return;
        }
    }

    /**
     * 数组的拷贝
     * @param oldArray
     * @param newArray
     */
    private void copyOf(Object[] oldArray, Object[] newArray) {
        for (int i = 0; i < oldArray.length; i++) {
            newArray[i] = oldArray[i];
        }
    }

    /**
     * 返回一个迭代器实现的对象
     *
     * @return
     */
    @Override
    public Iterator<E> iterator() {
        return new AIterator();
    }

    /**
     * 内部类实现迭代器对象
     *
     * @param <E>
     */
    private class AIterator<E> implements Iterator<E> {
        private int n;

        public AIterator() {
            this.n = 0;
        }

        @Override
        public boolean hasNext() {
            //如果n小于元素个数证明还有元素
            return n < size;
        }

        @Override
        public E next() {
            return (E) elements[n++];
        }
    }
}

链表：

public class LinkList<T> {
    //结点定义
    private class Node{
        //数据
        T item;
        //指向下一个结点
        Node next;
        //构造器
        public Node(T item,Node next){
            this.item = item;
            this.next = next;
        }
        public Node(T item){
            this.item = item;
        }
    }
    //头结点
    private Node head;
    //尾结点
    private Node tail;
    //结点个数
    private int size;

    //链表定义
    public LinkList(){
        this.head = new Node(null,null);
        size = 0;
    }    
}

//查找特定位置的链表结点
    public Node get(int index) {
        if (index <0 || index >=this.size){
            return null;
        }else{
            Node temp = this.head;
            for(int i =1;i<=index;i++){
                temp = temp.next;
            }
            return temp;
        }
    }

插入：

//在链表的第i个位置插入一个值为t数据
    public void insert(int index ,T data) throws Exception{
        if(index <0 ||index > this.size){
            throw new Exception("插入超出范围");
        }else{
            Node newNode = new Node(data);
            //在头结点插入元素
            if (index ==0){
                if(this.size >0){
                    Node temp = head;
                    newNode.next = temp;
                }
                head = newNode;
            }
            //在尾结点插入元素
            else if(index == this.size){
                Node temp = tail;
                temp.next = newNode;
                this.tail  = newNode;

            }else{
                //在中间插入元素
                Node preNode = get(index-1);
                Node nextNode = preNode.next;
                newNode.next = nextNode;
                preNode.next = newNode;

            }

        }
        this.size ++;

        if(size == 1){
            tail = head;
        }
    }

删除：

//删除特定位置的数据
    public void del(int index )throws Exception{
        if (index <0 ||index >=this.size){
            throw new Exception("删除超出范围");
        }else{
            //删除头结点
            if (index == 0){
                Node temp = this.head.next;
                this.head = temp;

            }else if(index == this.size-1){    //删除尾结点
                Node preNode = get(index -1);
                this.tail = preNode;
                preNode.next = null;
            }else{
                //删除中间结点
                Node preNode = get(index -1);
                Node nextNode = preNode.next.next;
                preNode.next = nextNode;
            }

        }
        this.size --;

    }

案例实现：

    public static void main(String args[]) throws Exception {
        LinkList linkList = new LinkList();
        linkList.add("2");
        linkList.del(0);
        linkList.printLinkList();
        linkList.insert(0,"a");
        System.out.println("删除的元素为："+linkList.remove());
        linkList.insert(0,"2");
        linkList.insert(1,"3");
        linkList.add("3");
        linkList.printLinkList();
        linkList.del(1);
        linkList.printLinkList();
        linkList.insert(1,"1");

        linkList.insert(0,"0");
        linkList.insert(2,"0");
        linkList.del(2);
        linkList.printLinkList();
        linkList.deleteData(3);
        linkList.printLinkList();



    }

}

栈和对列 存于笔记中