java 容器实现_java 容器类的实现

/*1. 它能支持字符串数据类型的存储与操作。也即把容器看成一个集合，集合内的元素是整数。

2. 容器的大小可以任意设置。因为数组一旦定义长度，不能更改，可以通过一个计数器变量count标识数组的大小。

1)在初始化一个容器时指定包含元素的个数。

2)使用“直接插入排序”对容器内数组进行升序排列。

3)使用“冒泡排序”对容器内数组进行升序排列。

4)使用“快速排序”对容器内数组进行升序排列。

5)通过给定元素下标来删除某一元素。

6)删除某一给定的元素。

7)通过给定元素下标，在该下标之后插入一元素。

8)数组升序排列后，给定某值，通过查找到该值元素，进行删除。(使用顺序查找)

9)数组升序排列后，给定某值，通过查找到该值元素，在该元素后插入新元素。(使用二分查找)

10)清空容器内的数组。

3.根据以上要求，编写出该容器类的实现代码。再编写测试代码，将10个功能逐一测试，显示出来。*/

public class MyContainer {

private static final long serialVersionUID = 8683452581122892189L;

private transient Character[] elementData;

private int count;

public MyContainer(int initialCapacity) {

super();

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);

this.elementData = new Character[initialCapacity];

}

public int count() {

return count;

}

public boolean isEmpty() {

return count == 0;

}

public boolean contains(Object o) {

return indexOf(o) >= 0;

}

public int indexOf(Object o) {

if (o == null) {

for (int i = 0; i < count; i++)

if (elementData[i]==null)

return i;

} else {

for (int i = 0; i < count; i++)

if (o.equals(elementData[i]))

return i;

}

return -1;

}

public int lastIndexOf(Object o) {

if (o == null) {

for (int i = count-1; i >= 0; i--)

if (elementData[i]==null)

return i;

} else {

for (int i = count-1; i >= 0; i--)

if (o.equals(elementData[i]))

return i;

}

return -1;

}

// Positional Access Operations

@SuppressWarnings("unchecked")

E elementData(int index) {

return (E) elementData[index];

}

public E get(int index) {

rangeCheck(index);

return elementData(index);

}

public E set(int index, E element) {

rangeCheck(index);

E oldValue = elementData(index);

elementData[index] = element;

return oldValue;

}

public boolean add(E e) {

elementData[count++] = e;

return true;

}

public void add(int index, E element) {

rangeCheckForAdd(index);

System.arraycopy(elementData, index, elementData, index + 1,count - index)

elementData[index] = element;

count++;

}

public E remove(int index) {

E oldValue = elementData(index);

int numMoved = count - index - 1;

if (numMoved > 0)

System.arraycopy(elementData, index+1, elementData, index,numMoved);

elementData[--count] = null; // Let gc do its work

return oldValue;

}

public boolean remove(Character o) {

if (o == null) {

for (int index = 0; index < count; index++)

if (elementData[index] == null) {

fastRemove(index);

return true;

}

} else {

for (int index = 0; index < count; index++)

if (o.equals(elementData[index])) {

fastRemove(index);

return true;

}

}

return false;

}

private void fastRemove(int index) {

int numMoved = count - index - 1;

if (numMoved > 0)

System.arraycopy(elementData, index+1, elementData, index,numMoved);

elementData[--count] = null; // Let gc do its work

}

public void clear() {

// Let gc do its work

for (int i = 0; i < count; i++)

elementData[i] = null;

count = 0;

}

private void rangeCheck(int index) {

if (index >= count)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}

private void rangeCheckForAdd(int index) {

if (index > count || index < 0)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}

private String outOfBoundsMsg(int index) {

return "Index: "+index+", Size: "+count;

}

public void InsertSort(){

//直接插入排序

for (int i = 1; i < elementData.length; i++) {

//待插入元素

char temp = elementData[i];

int j;

for (j = i-1; j>=0; j--) {

//将大于temp的往后移动一位

if(elementData[j]>temp){

elementData[j+1] = elementData[j];

}else{

break;

}

}

elementData[j+1] = temp;

}

}

public void BubbleSort(){

//冒泡排序

for (int i = 0; i < elementData.length; i++) {

for(int j = 0; j

//这里-i主要是每遍历一次都把最大的i个数沉到最底下去了，没有必要再替换了

if(elementData[j]>elementData[j+1]){

char temp = elementData[j];

elementData[j] = elementData[j+1];

elementData[j+1] = temp;

}

}

}

}

public void quick() {

if(elementData.length>0){

quickSort(elementData,0,elementData.length-1);

}

}

private static void quickSort(Character[] elementData2, int low, int high) {

if(low

int middle = getMiddle(elementData2,low,high);

quickSort(elementData2, 0, middle-1);

quickSort(elementData2, middle+1, high);

}

}

private static int getMiddle(Character[] elementData2, int low, int high) {

Character temp = elementData2[low];//基准元素

while(low

//找到比基准元素小的元素位置

while(low=temp){

high--;

}

elementData2[low] = elementData2[high];

while(low

low++;

}

elementData2[high] = elementData2[low];

}

elementData2[low] = temp;

return low;

}

}