Java superArray2

还是那个仿照Vector数组，完善了一些功能，但是输出格式感觉。。。。昂

package com.zmz.work;

/**
 * 长度可变的数组
 * 
 * @author zmz
 *
 */
public class SuperArray {

	/**
	 * 容量（容器的大小）
	 */
	private int capacity;

	/**
	 * 大小（元素的个数）
	 */
	private int size = 0;

	/**
	 * 数据
	 */
	private double[] data;

	/**
	 * 容量的增量（步长）默认为0
	 */
	private int increment = 0;

	/**
	 * 容量为 8 线性表
	 */
	public SuperArray() {
		this(8);
	}

	/**
	 * 创建指定大小的容器
	 * 
	 * @param capacity
	 *            默认的容量
	 */
	public SuperArray(int capacity) {
		this.capacity = capacity;
		data = new double[capacity];
	}

	// 构造器模式
	// public SuperArray(int increment) {
	//
	// }

	/**
	 * 创建变长数组
	 * 
	 * @param capacity
	 *            容量
	 * @param increment
	 *            扩容的增长因子
	 */
	public SuperArray(int capacity, int increment) {
		this(capacity);
		this.increment = increment;
	}

	/**
	 * 获得容器的大小（存储的元素的个数）
	 * 
	 * @return int 小于等于容量
	 */
	public int getSize() {
		return size;
	}

	/**
	 * 获得容器的容量
	 * 
	 * @return int 容器的容量
	 */
	public int getCapacity() {
		return capacity;
	}

	/**
	 * 往容器中（末尾）添加一个元素
	 * 
	 * @param n
	 *            int 要存入容器的元素
	 */
	public void add(double e) {
		// 检查容量与元素的数量
		// 设计模式、重构、架构模式设计
		increaseCapacity();
		data[size++] = e;
	}

	/**
	 * 在指定位置添加信息元素
	 * 
	 * @param index
	 *            新元素的位置（索引、0为起点）
	 * @param n
	 *            添加的新元素
	 */
	public boolean add(int index, double e) {
		if (index > size) {
			return false;
		}
		size++;
		increaseCapacity();
		double[] newData4 = new double[capacity];
		for(int i = 0; i < index; i++) {
			newData4[i] = data[i];
		}
		newData4[index] = e;
		for(int i = index; i < data.length-1; i++) {
			newData4[i+1] = data[i];
		}
		data = newData4;
		return true;
	}

	/**
	 * 获得指定位置的元素
	 * 
	 * @param index
	 * @return
	 */
	public double get(int index) {
		// TODO
		return data[index];
	}

	/**
	 * 删除特定位置的元素
	 * 
	 * @param index 位置
	 * @return
	 */
	public double remove(int index) {
		// TODO
		double[] newData2 = new double[capacity];
		double getRemove = data[index];
		for(int i = 0; i < index; i++) {
			newData2[i] = data[i];
		}
		for(int i = index; i < data.length-1; i++) {
			newData2[i] = data[i+1];
		}
		data =newData2;
		System.out.printf("删除成功,删除的元素位置是%d(下标从0开始),值是%f\n",index,getRemove);
		return getRemove;		
	}
	
	/**
	 * 删除从索引位置开始的 n 个元素
	 * @param index 位置 
	 * 		  n 元素个数
	 *  void
	 */
	void remove(int index,int n) {
		double[] newData3 = new double[capacity];
		for(int i = 0; i < index-1; i++) {
			newData3[i] = data[i];
	}
		for(int i = index; i < data.length-n; i++) {
			newData3[i] = data[i+n];
	}
		data = newData3;
		System.out.println();
		System.out.println("删除n个元素成功");
	}
	
	/**
	 * 扩容
	 */
	private void increaseCapacity() {
		if (size == capacity) {
			// 扩容
			if (increment == 0) {
				capacity *= 2;
			} else {
				capacity += increment;
			}
			double[] newData = new double[capacity];
			for (int i = 0; i < data.length; i++) {
				newData[i] = data[i];
			}
			data = newData;
			System.out.println();
			System.out.println("扩容为：" + capacity);
		}
	}
	public void show() {
		System.out.printf("\n容量：%d, 大小：%d\n", capacity, size);
		for (int i = 0; i < size; i++) {
			System.out.print(data[i] + ",");
		}
		System.out.println();
	}

}

package com.zmz.work;

public class Test {

	// alt + /
	public static void main(String[] args) {
		
		//test1
		SuperArray a1 = new SuperArray();
		for(int i = 0; i < 5; i++) {
			a1.add(i);
			
		}
		a1.show();
		a1.add(2, 100.0);
		a1.show();
		
		//test2
		SuperArray a2 = new SuperArray(10,5);
		for (int i = 0; i < 12; i++) {
			a2.add(i);	
		}
		a2.remove(5);
		a2.show();
		a2.remove(1,2);
		a2.show();
				
	}
}

输出：

容量：8, 大小：5
0.0,1.0,2.0,3.0,4.0,

容量：8, 大小：6
0.0,1.0,100.0,2.0,3.0,4.0,

扩容为：15
删除成功,删除的元素位置是5(下标从0开始),值是5.000000

容量：15, 大小：12
0.0,1.0,2.0,3.0,4.0,6.0,7.0,8.0,9.0,10.0,11.0,0.0,

删除n个元素成功

容量：15, 大小：12
0.0,3.0,4.0,6.0,7.0,8.0,9.0,10.0,11.0,0.0,0.0,0.0,