java黑皮书24.1----（在MyList中实现操作）

问题描述

这里主要是针对addAll,removeAll,retainAll,toArray.toArray(T[])的实现

问题分析：

提示：其实可以直接看ArrayList的源码：

这里addAll其实就是在求并集，

这里removeAll相当于在求差集,

这里retainAll相当于在求交集,

这里toArray.toArray(T[])将线性表转化为数组

addAll()	添加集合中的所有元素到 arraylist 中
removeAll()	删除存在于指定集合中的 arraylist 里的所有元素
toArray()	将 arraylist 转换为数组
retainAll()	保留 arraylist 中在指定集合中也存在的那些元素
containsAll()	查看 arraylist 是否包含指定集合中的所有元素
trimToSize()	将 arraylist 中的容量调整为数组中的元素个数

---

代码：

提示：尽量调用自己写过的方法，代码量会少很多：

/* You have to use the following template to submit to Revel.
   Note: To test the code using the CheckExerciseTool, you will submit entire code.
   To submit your code to Revel, you must only submit the code enclosed between
     // BEGIN REVEL SUBMISSION

     // END REVEL SUBMISSION
*/

import java.sql.Array;
import java.util.*;

public class Lab24_1 {
    public static void main(String[] args) {
        new Lab24_1();
    }

    public Lab24_1() {
        Scanner input = new Scanner(System.in);
        String[] name1 = new String[5];
        String[] name2 = new String[5];
        String[] name3 = new String[2];
        System.out.print("Enter five strings for array name1 separated by space: ");
        for (int i = 0; i < 5; i++) {
            name1[i] = input.next();
        }

        System.out.print("Enter five strings for array name2 separated by space: ");
        for (int i = 0; i < 5; i++) {
            name2[i] = input.next();
        }

        System.out.print("Enter two strings for array name3 separated by space: ");
        for (int i = 0; i < 2; i++) {
            name3[i] = input.next();
        }

        MyList<String> list1 = new MyArrayList<>(name1);
        MyList<String> list2 = new MyArrayList<>(name2);
        System.out.println("list1: " + list1);
        System.out.println("list2: " + list2);
        list1.addAll(list2);
        System.out.println("After addAll: list1 is " + list1 + "\n");

        list1 = new MyArrayList<>(name1);
        list2 = new MyArrayList<>(name2);
        System.out.println("list1: " + list1);
        System.out.println("list2: " + list2);
        list1.removeAll(list2);
        System.out.println("After removeAll: list1 is " + list1 + "\n");

        list1 = new MyArrayList<>(name1);
        list2 = new MyArrayList<>(name2);
        System.out.println("list1: " + list1);
        System.out.println("list2: " + list2);
        list1.retainAll(list2);
        System.out.println("After retainAll: list1 is " + list1 + "\n");

        list1 = new MyArrayList<>(name1);
        list2 = new MyArrayList<>(name2);
        System.out.println("list1: " + list1);
        System.out.println("list2: " + list2);
        list1.retainAll(list2);
        System.out.println("list1 contains all list2? " + list1.containsAll(list2) + "\n");

        list1 = new MyArrayList<>(name1);
        list2 = new MyArrayList<>(name3);
        System.out.println("list1: " + list1);
        System.out.println("list2: " + list2);
        System.out.println("list1 contains all list2? " + list1.containsAll(list2) + "\n");

        Object[] name4 = list1.toArray();
        System.out.print("name4: ");
        for (Object e : name4) {
            System.out.print(e + " ");
        }

        String[] name5 = new String[list1.size()];
        String[] name6 = list1.toArray(name5);
        System.out.print("\nname6: ");
        for (Object e : name6) {
            System.out.print(e + " ");
        }

//        System.out.println(name6 == name5);
    }
}

class MyArrayList<E> implements MyList<E> {
    public static final int INITIAL_CAPACITY = 16;
    private E[] data = (E[]) new Object[INITIAL_CAPACITY];
    private int size = 0; // Number of elements in the list

    /**
     * Create an empty list
     */
    public MyArrayList() {
    }

    /**
     * Create a list from an array of objects
     */
    public MyArrayList(E[] objects) {
        for (int i = 0; i < objects.length; i++)
            add(objects[i]); // Warning: don’t use super(objects)!
    }

    @Override
    /** Add a new element at the specified index */
    public void add(int index, E e) {
        ensureCapacity();

        // Move the elements to the right after the specified index
        for (int i = size - 1; i >= index; i--)
            data[i + 1] = data[i];

        // Insert new element to data[index]
        data[index] = e;

        // Increase size by 1
        size++;
    }

    /**
     * Create a new larger array, double the current size + 1
     */
    private void ensureCapacity() {
        if (size >= data.length) {
            E[] newData = (E[]) (new Object[size * 2 + 1]);
            System.arraycopy(data, 0, newData, 0, size);
            data = newData;
        }
    }

    @Override
    /** Clear the list */
    public void clear() {
        data = (E[]) new Object[INITIAL_CAPACITY];
        size = 0;
    }

    @Override
    /** Return true if this list contains the element */
    public boolean contains(Object e) {
        for (int i = 0; i < size; i++)
            if (e.equals(data[i])) return true;

        return false;
    }

    @Override
    /** Return the element at the specified index */
    public E get(int index) {
        checkIndex(index);
        return data[index];
    }

    private void checkIndex(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException
                    ("Index: " + index + ", Size: " + size);
    }

    @Override
    /** Return the index of the first matching element
     *  in this list. Return -1 if no match. */
    public int indexOf(Object e) {
        for (int i = 0; i < size; i++)
            if (e.equals(data[i])) return i;

        return -1;
    }

    @Override
    /** Return the index of the last matching element
     *  in this list. Return -1 if no match. */
    public int lastIndexOf(E e) {
        for (int i = size - 1; i >= 0; i--)
            if (e.equals(data[i])) return i;

        return -1;
    }

    @Override
    /** Remove the element at the specified position
     *  in this list. Shift any subsequent elements to the left.
     *  Return the element that was removed from the list. */
    public E remove(int index) {
        checkIndex(index);

        E e = data[index];

        // Shift data to the left
        for (int j = index; j < size - 1; j++)
            data[j] = data[j + 1];

        data[size - 1] = null; // This element is now null

        // Decrement size
        size--;

        return e;
    }

    @Override
    /** Replace the element at the specified position
     *  in this list with the specified element. */
    public E set(int index, E e) {
        checkIndex(index);
        E old = data[index];
        data[index] = e;
        return old;
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder("[");

        for (int i = 0; i < size; i++) {
            result.append(data[i]);
            if (i < size - 1) result.append(", ");
        }

        return result.toString() + "]";
    }

    /**
     * Trims the capacity to current size
     */
    public void trimToSize() {
        if (size != data.length) {
            E[] newData = (E[]) (new Object[size]);
            System.arraycopy(data, 0, newData, 0, size);
            data = newData;
        } // If size == capacity, no need to trim
    }

    @Override
    /** Override iterator() defined in Iterable */
    public java.util.Iterator<E> iterator() {
        return new ArrayListIterator();
    }

    @Override
    /** ArrayList transform Array */
    public Object[] toArray() {
        return Arrays.copyOf(data, size);
    }

    @Override
    /** 将链表转换为数组，传递给指定的数组 */
    public <T> T[] toArray(T[] a) {
        for (int i = 0; i < size; i++)
            a[i] = (T) data[i];

//        a = (T[]) toArray();
        return a;
    }

    /**
     * Add a new element
     */
    @Override
    public boolean add(E e) {
        ensureCapacity();
        add(size, e);
        return true;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    /**
     * 添加集合中的所有元素到 arraylist 中
     */
    @Override
    public boolean addAll(Collection<? extends E> c) {
        Iterator iterator = c.iterator();
        while (iterator.hasNext())
            data[size++] = (E) iterator.next();
        return true;
    }

    /**
     * 删除存在于指定集合中的 arraylist 里的所有元素
     */
    @Override
    public boolean removeAll(Collection<?> c) {
        Iterator iterator = c.iterator();
        while (iterator.hasNext()) {
            E temp = (E) iterator.next();
            if (contains(temp))
                remove(indexOf(temp));
        }
        return true;
    }

    /**
     * 保留 arraylist 中在指定集合中也存在的那些元素
     */
    @Override
    public boolean retainAll(Collection<?> c) {
        E[] temp = (E[]) new Object[size];
        int index = 0;
        for (int i = 0; i < size; i++) {
            if (c.contains(data[i]))
                temp[index++] = data[i];
        }
        data = Arrays.copyOf(temp, index);
        size = index;
        return true;
    }

    private class ArrayListIterator
            implements java.util.Iterator<E> {
        private int current = 0; // Current index

        @Override
        public boolean hasNext() {
            return (current < size);
        }

        @Override
        public E next() {
            return data[current++];
        }

        @Override
        public void remove() {
            if (current == 0) // next() has not been called yet
                throw new IllegalStateException();
            MyArrayList.this.remove(--current);
        }
    }

    @Override
    /** Return the number of elements in this list */
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }
}

// BEGIN REVEL SUBMISSION
interface MyList<E> extends java.util.Collection<E> {
    /**
     * Add a new element at the specified index
     */
    void add(int index, E e);

    /**
     * Return the element at the specified index
     */
    E get(int index);

    /**
     * Return the index of the first matching element
     * in this list. Return -1 if no match.
     */
    int indexOf(Object e);

    /**
     * Return the index of the last matching element
     * in this list. Return -1 if no match.
     */
    int lastIndexOf(E e);

    /**
     * Remove the element at the specified position
     * in this list. Shift any subsequent elements to the left.
     * Return the element that was removed from the list.
     */
    E remove(int index);

    /**
     * Replace the element at the specified position
     * in this list with the specified element.
     */
    E set(int index, E e);
    // WRITE YOUR CODE HERE
}
// END REVEL SUBMISSION