数据结构数组的泛型改造

在我们上一篇数组中我们数组只能放数值型数据，我们要对他进行改造，使之能放别的数据类型的值，但是我们这里的数据类型不可以是基本数据类型，必须是类对象。

boolean,byte,char,short,int long float,double是我们的八种基本数据类型

但是我们的Java为我们提供了包装类

Boolean,Byte,Char,Short,Int,Long,Float,Double

package www.zxx;

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

	//带参构造函数
	public Array(int capacity) {
		//不支持new一个泛型数组
		//先建立一个object类再进行强转
		date = (E[])new Object[capacity];
		size = 0;
	}

	//无参构造函数输入的数据实际上是capacity的值
	public Array() {
		this(10);
	}

	//获得数组的size
	public int getSize() {
		return size;
	}

	//获得数组的容量
	public int getCapacity() {
		return date.length;
	}

	//通过已经写好的add函数写一个在开头添加e值的函数
    //好处是add函数已经处理过index数值的溢出问题
	public void addFirst(E e) {
		add(0, e);
	}

	//通过已经写好的add函数写一个在末尾添加e值的函数
	//好处是add函数已经处理过index数值的溢出问题
	public void addLast(E e) {
		add(size, e);
	}

	//在index位置加入e数值的数
	//要进行index数值的输入控制
	public void add(int index, E e) {
		if (size == date.length) {
			throw new IllegalArgumentException("Add failed,Array is full");
		}
		if (index < 0 || index > size) {
			throw new IllegalArgumentException("Add failed,Index beyond brode");
		}
		for (int i = size - 1; i >= index; i--) {
			date[i + 1] = date[i];
		}
		date[index] = e;
		size++;
	}

	//判断e数值在不在数组内
	public boolean contains(E e) {
		for (int i = 0; i < size; i++) {
			if (date[i].equals(e))
				return true;
		}
		return false;
	}

	//找数组中为e数值的位置，如果没有输出-1
	public int find(E e) {
		for (int i = 0; i < size; i++) {
			//值比较
			if (date[i].equals(e))
				return i;
		}
		return -1;
	}

	@Override
	//重写tostring方法让System.out.println（）能直接输出我们指定的类型
	public String toString() {
		StringBuilder res = new StringBuilder();
		res.append(String.format("Array : size = %d,capacity = %d\n", size, date.length));
		res.append('[');
		for (int i = 0; i < size; i++) {
			res.append(date[i]);
			if (i != size - 1) {
				res.append(',');
			} else {
				res.append(']');
			}
		}
		return res.toString();

	}

	// 获得index位置的数
	E get(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		return date[index];
	}

	// 设置index位置的数为e
	void set(int index, E e) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		date[index] = e;
	}

	//删除index位置的元素
	//返回删除的元素
	E remove(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("Get failed.Index beyond brode.");
		E rec = date[index];
		for(int i = index ; i < size ;i++) {
			date[i] = date[i+1];
		}
		//我们的int类型的数组size指向的值不需要被删除，因为我们在后面插入的时候能覆盖
		//在泛型中我们使用的是类对象，我们应该删除它
		size--;
		//loitering objects!=memory leak(内存泄漏)
		date[size]=null;
		return rec;
	}
	
	//删除第一个元素
	public E removeFirst() {
		return remove(0);
	}
	
	//删除最后一个元素
	public E removeLast() {
		return remove(size-1);
	}
	
	//从数组中寻找e数值的值，如果找到删除它
	public void removeElement(E e) {
		int index = find(e);
		if(index != -1) {
			remove(index);
		}
	}
	
	//主方法
	public static void main(String[] args) {
		Array<Integer> arr = new Array<Integer>(20);
		
		for (int i = 0; i < 10; i++) {
			arr.addLast(i);
		}
		System.out.println(arr);

		arr.add(1, 100);
		System.out.println(arr);

		arr.addFirst(-1);
		System.out.println(arr);
		
		arr.remove(0);
		System.out.println(arr);
		
		arr.removeElement(0);
		System.out.println(arr);
	}
}

 

对数组的泛型改造使得我们对数组的使用更加灵活~下面还会添加数组的更多功能