接口的定义
接口其实简单来讲就是定义一些公共方法的集合,是一种高级的封装
但是说到接口又不得不提到父类,这两者还是有一定的差别:
1、接口是单继承
2、多实现
3、父子关系
a、复用,方法名和参数返回值可以复用
b、接口与实现类是一种扩展的关系:如果要扩展一个已有类的功
能,我们通常不会选择修改该类的源码,而是新建一个类,去继
承该类,并实现扩展接口。
自定义的集合接口(具体可以参考ArrayList类)
/**
* 集合接口
*
* 定义未来该接口下的实现类中公共行为
* 结构根据需要自行定义
* @param <T> 泛型
*/
public interface List<T> {
/**
* 获取集合中元素的实际数量
* @return int
*/
int size();
/**
* 集合是否为空
* 集合中实际元素的数量是否为0
* @return
*/
boolean isEmpty();
/**
* 将集合元素以数组形式返回
* @return Object数组
*/
Object[] roArray();
/**
* 返回参数元素在集合中第一次的实际位置
* @param t
* @return -1 :不存在;否则返回>=0的有效位置
*/
int indexOf(T t);
/**
* 返回参数元素在集合中最后一次的实际位置
* @param t
* @return -1 :不存在;否则返回>=0的有效位置
*/
int lastIndexOf(T t);
/**
* 集合中是否包含参数元素
* @param t
* @return true:包含 false:不包含
*/
boolean contains(T t);
/**
* 向集合中新增一个元素
* @param t
*/
void add(T t);
/**
* 将参数数组中的元素新增到集合中
* @param arr
*/
void add(T[] arr );
/**
* 将参数集合添加到当前集合中
* @param list
*/
void add(List<T> list);
/**
* 删除指定位置的集合元素
* @param index
* @return null:表示位置越界,否则返回该位置的元素
*/
T remove(int index);
/**
* 从集合中删除参数元素
* @param t
* @return true:删除成功 false:表示删除失败(元素不存在)
*/
boolean remove(T t);
}
迭代器接口
/**
* 迭代器的行为定义
* @param <T>
*/
public interface Iterator<T> {
boolean hasNext();
T next();
}
/**
* 需要实现迭代功能的集合
* @param <T>
*/
public interface Iterable<T> {
Iterator<T> iterator();
}
实现类
public class ArrayList<T> implements List<T>,Iterable<T> {
/**
* 默认初始容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 默认源数据的扩容率
*/
private static final float DEFAULT_EXPAND_RATE=1.5F;
/**
* 核心的源数据
*/
private Object[] elementDate;
/**
* 常量空数组
*/
private final Object[] EMPTY_DATA = {};
/**
* 数组拷贝的临时记录点
*/
private Object[] copy = EMPTY_DATA;
/**
* 新元素的起始位置,当前数组中元素的数量
*/
private int size;
public ArrayList(){
this(DEFAULT_CAPACITY);
}
public ArrayList(int initCapacity){
if(initCapacity==0){
elementDate = EMPTY_DATA;
}else if(initCapacity>0){
elementDate = new Object[initCapacity];
}else{
System.err.println("初始化容量错误:initCapacity"+initCapacity);
}
}
private void ensureCapacity(int needCapacity){
int expandCapacity = needExpand(needCapacity);
if(expandCapacity <0){
return;
}
final int newCapacity = (int)Math.ceil((elementDate.length+expandCapacity)*DEFAULT_EXPAND_RATE);
copy = elementDate;
elementDate = new Object[newCapacity];
System.arraycopy(copy,0,elementDate,0,size);
copy = EMPTY_DATA;
}
private int needExpand(int needCapacity){
return needCapacity - (elementDate.length-size);
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size==0;
}
@Override
public Object[] roArray() {
return Arrays.copyOf(elementDate,size);
}
@Override
public int indexOf(T t) {
for (int i = 0; i <size ; i++) {
if(elementDate[i].equals(t)){
return i;
}
}
return -1;
}
@Override
public int lastIndexOf(T t) {
for (int i = size-1; i >0; i--) {
if(elementDate[i].equals(t)){
return i;
}
}
return -1;
}
@Override
public boolean contains(T t) {
return -1 != indexOf(t);
}
@Override
public void add(T t) {
ensureCapacity(1);
elementDate[size++]= t;
}
@Override
public void add(T[] arr) {
ensureCapacity(arr.length);
System.arraycopy(arr,0,elementDate,size,arr.length);
size += arr.length;
}
@Override
public void add(List<T> list) {
add((T[])list.roArray());
}
@Override
public T remove(int index) {
if(index<0 || index>=size){
return null;
}
T t = (T)elementDate[index];
for (int i = index; i <size-1 ; i++) {
elementDate[i] = elementDate[i+1];
}
elementDate[--size] = null;
return t;
}
@Override
public boolean remove(T t) {
int index = indexOf(t);
if(-1==index){
return false;
}
remove(index);
return true;
}
@Override
public Iterator<T> iterator(){
return new Iterator<T>() {
private int index = -1;
@Override
public boolean hasNext() {
return ++index<size;
}
@Override
public T next() {
return (T)elementDate[index];
}
};
}
}