关于toString()的一些事情

Java上输出一个数组的时候，不可以直接输出

System.out.println(arr);

 直接输出数据的名称会输出数组的内存地址。换句话说，他的输出是：

getClass().getName() + '@' + Integer.toHexString(hashCode())

toString()是Object类里的一个方法，所以默认java里所有类都继承了这个，所以默认所有对象都具备这个方法。

它通常只是为了方便输出，比如System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法 

当我们直接输出数组名称的时候，会调用到toString()，然后「 [I@53d3d20b 」 这样的数据就被输出了，所以当我们想要可以按照我们的想法，不想使用for循环去打印这个数组，我们可以通过重写数组的toString()方法来实现我们所想。

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append('[');
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i != size - 1)
                res.append(",");
        }
        res.append(']');
        return res.toString();
    }

当然，想使用这个方法需要重写整个数组的代码，所以我们可以写一个数组的泛型的代码：

package Array;

import java.util.Objects;

public class Array<E> {
    private E[] data;
    private int size;

    //构造函数，传入数组容量
    public Array(int capacity) {
//        data = new E[capacity];
        data = (E[]) new Object[capacity];//强制类型转换
        size = 0;
    }

    public Array() {
        this(10);
    }

    public int getSize() {
        return size;
    }

    public int getCap() {
        return data.length;
    }

    public void addLast(E e) {
        add(size, e);
    }

    public void addFirst(E e) {
        add(0, e);
    }

    //是否包含元素e
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
//            if (data[i] == e) //引用比较
            if (data[i].equals(e)) //值比较
                return true;
        }
        return false;
    }

    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e))
                return i;
        }
        return -1;
    }

    public void add(int index, E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed.index is not support.");
        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++;
    }

    //获得index索引位置的元素
    E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index is not support!");
        }
        return data[index];
    }

    void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index is not support!");
        }
        data[index] = e;
    }

    //删除下标位置元素，并返回删除了什么元素
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index is not support!");
        }
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        if (size == data.length/2)
            resize(data.length/2);
        return ret;
    }

    public E removeFirst() {
        return remove(0);
    }

    public E removeLast() {
        return remove(size - 1);
    }

    //从数组中删除元素e
    public boolean removeElement(E e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
            return true;
        } else {
            return false;
        }
    }

    public void removeElementAll(int e) {

    }

    public int findAll(int e) {
        return -1;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size= %d,cap = %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;
        System.out.println("动态扩容了！");
    }
}