關於如何在自己定義的數據結構實現迭代器,請看這篇文章:https://www.cnblogs.com/xujian2014/p/5846128.html
下面附上我的代碼:
package DataStructure;
/**
* Created with IntelliJ IDEA
* User:12089
* Date:2019/2/28
* Time:21:28
* Description:基於數組實現的順序表
**/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
interface Sequence<T>{
/**
* 向線性表中添加元素
* @param newdata 要存儲的元素
* @return 插入成功,返回true
*/
boolean add(T newdata);
/*
* 在指定索引出插入一個元素
* @param index 指定位置處索引 newdata 要插入的元素
*/
void insert(int index,T newdata);
/**
* 線性表中刪除元素
* @param index 要刪除的元素下標
* @return 是否刪除成功
*/
T remove(int index);
/*
* 在指定索引處添加新元素
* @param index 指定的位置處的索引 newdata 要添加的元素
*/
T set(int index,T newData);
/**
* 在線性表中查找指定索引的元素
* @param index 要查找的索引
* @return
*/
T get(int index);
/*
* 對原數組進行擴容操作
* @param newCapacity 要擴容的大小
*/
void ensureCapacity(int newCapacity);
/*
* 判斷該順序表是否爲空
* @param
* @return 爲空返回true,否則返回false
*/
boolean isEmpty();
/*
* 返回指定元素的所有
* @param obj 指定元素
* @return 返回索引值
*/
int IndexOf(Object obj);
/**
* 判斷線性表中是否有指定元素
* @param obj 要查找的元素內容
* @return
*/
boolean contains(Object obj);
/*
* 獲得該順序表元素的個數
* @param
* @return 返回元素的個數值
*/
int getSize();
/*
* 將該順序錶轉換爲一個泛型數組
* @param
* @return 返回一個泛型數組
*/
T[] toArray();
/*
* 清空該順序表
* @param
* @return
*/
void clear();
}
public class SequenceList<T> implements Sequence<T>,
Iterable<T> {
private int size;
private static final int DEFAULT_CAPACITY=20;
private static final Object[] EMPTY_ELEMENTDATA = {};
public transient T[] elementData;
public SequenceList() {
this.elementData=(T[]) new Object[DEFAULT_CAPACITY];
}
public SequenceList(int InitCapacity){
if(InitCapacity>0){
this.elementData=(T[])new Object[InitCapacity];
this.size=0;
}else if(InitCapacity==0){
this.elementData=(T[])EMPTY_ELEMENTDATA;
}else {
throw new IllegalArgumentException();
}
}
@Override
public void ensureCapacity(int newCapacity) {
int cur=elementData.length;
if(cur<newCapacity){
elementData= Arrays.copyOf(elementData,newCapacity);
}
}
private void CheckRange(int index){
if(index<0||index>getSize()-1){
throw new IndexOutOfBoundsException();
}
}
@Override
public boolean add(T newdata) {
if(size==elementData.length){
ensureCapacity(elementData.length*2+1);
}
elementData[size++]=newdata;
return true;
}
@Override
public void insert(int index, T newdata) {
CheckRange(index);
if(elementData.length==size){
ensureCapacity(elementData.length*2+1);
}
System.arraycopy(elementData,index,elementData,index+1,size-index);
elementData[index]=newdata;
size++;
}
@Override
public T remove(int index) {
CheckRange(index);
int movedsize=size-index-1;
T oldData=elementData[index];
if(movedsize>0){
System.arraycopy(elementData,index+1,
elementData,index,movedsize);
}
//如果是數組最後一個元素
elementData[--size]=null;
return oldData;
}
@Override
public T set(int index, T newData) {
CheckRange(index);
T oldData=elementData[index];
elementData[index]=newData;
return oldData;
}
@Override
public T get(int index) {
return elementData[index];
}
@Override
public boolean isEmpty() {
return this.size==0;
}
@Override
public int IndexOf(Object obj) {
int len=elementData.length;
if(obj==null){
for(int i=0;i<len;i++){
if(elementData[i]==null){
return i;
}
}
}else{
for(int i=0;i<len;i++){
if(obj.equals(elementData[i])){
return i;
}
}
}
return -1;
}
@Override
public boolean contains(Object obj) {
return IndexOf(obj)!=-1;
}
@Override
public int getSize() {
return this.size;
}
@Override
public T[] toArray() {
return Arrays.copyOf(elementData,size);
}
@Override
public void clear() {
for(int i=0;i<elementData.length;i++){
elementData[i]=null;
}
size=0;
}
@Override
public Iterator<T> iterator() {
return new SeqListItr();
}
private class SeqListItr implements Iterator<T>{
private int cur=0;
@Override
public boolean hasNext() {
return cur<size;
}
@Override
public T next() {
return elementData[cur++];
}
@Override
public void remove() {
SequenceList.this.remove(--cur);
}
}
public static void main(String[] args) {
SequenceList sequence=new SequenceList();
sequence.add(1);
sequence.add(3);
sequence.add(5);
sequence.add(7);
sequence.add(9);
sequence.insert(3,0);
sequence.remove(2);
System.out.println(sequence.isEmpty());
System.out.println(sequence.getSize());
System.out.println(sequence.contains(5));
Iterator itr=sequence.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
}
}