import java.util.Arrays;
import java.util.Random;
//实现一个容器类
class ArrayList<T> implements Cloneable{
protected T[] elementData;
protected int size;
//initialCapacity指定数组初始化大小
@SuppressWarnings("unchecked")
public ArrayList(int initialCapacity){
this.size = 0;
elementData = (T[])new Object[initialCapacity];
}
//默认开辟10个元素空间
public ArrayList(){
this(10);
}
//缩容
public void trimToSize(){
elementData = Arrays.copyOf(elementData, size);
}
//检查空间是否足够,否则开辟1.5倍的内存空间 minCapacity表示当前有没有这么大的内存
public void ensureCapacity(int minCapacity){
if(minCapacity < elementData.length){
return;
}
//Math.ceil()执行向上舍入,即它总是将数值向上舍入为最接近的整数;
//Math.floor()执行向下舍入,即它总是将数值向下舍入为最接近的整数;
//Math.round()执行标准舍入,即它总是将数值四舍五入为最接近的整数(这也是我们在数学课上学到的舍入规则)。
int newLength = (int)(Math.ceil(size * 1.5));
elementData = Arrays.copyOf(elementData, newLength);
}
//元素个数
public int size(){
return size;
}
//检查容器是否为空
public boolean isEmpty(){
return size == 0;
}
//检查是否包含某一个元素
public boolean contains(T o){
for(T val : elementData){
if(val.equals(o)){
return true;
}
}
return false;
}
//从0开始检查元素,返回该元素的index
public int indexOf(T o){
for(int i=0; i<size; ++i){
if(elementData[i].equals(o)){
return i;
}
}
return -1;
}
//从末尾开始检查元素,返回该元素的index
public int lastIndexOf(T o){
for(int i=size-1; i>=0; --i){
if(elementData[i].equals(o)){
return i;
}
}
return -1;
}
//提供该容器的clone方法
@SuppressWarnings("unchecked")
public Object clone(){ // ArrayList.clone();
ArrayList<T> obj = null;
try {
obj = (ArrayList<T>) super.clone();
obj.elementData = elementData.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return obj;
}
//返回该容器的元素到一个数组当中
public T[] toArray(){
T[] array = Arrays.copyOf(elementData, size);
return array;
}
//获取index号位置元素的值
public T get(int index){
return elementData[index];
}
//设置index号元素的值是element 返回该元素位的旧值
public T set(int index, T element){
T oldval = elementData[index];
elementData[index] = element;
return oldval;
}
//末尾添加一个元素
public boolean add(T e){
ensureCapacity(size+1);
elementData[size++] = e;
return true;
}
//在index位置添加一个元素element x x x x x x x x x x 10
public void add(int index, T element){
System.arraycopy(elementData, index, elementData,
index+1, size-index);
elementData[index] = element;
size++;
}
//删除index位置的元素,返回删除元素的值
public T remove(int index){
T val = elementData[index];
System.arraycopy(elementData, index+1, elementData,
index, size-index-1);
size--;
return val;
}
//删除元素
public boolean remove(T o){
int index = indexOf(o);
if(index == -1)
return false;
remove(index);
return true;
}
//清除容器
public void clear(){
size = 0;
}
}
class SqStack<T> extends ArrayList<T>{
public SqStack(int size){
super(size);
}
public void push(T val){
if(full()){
return;
}
add(val);
}
public void pop(){
if(empty())
return;
remove(size-1);
}
public T top(){
return get(size-1);
}
public boolean empty(){
return isEmpty();
}
public boolean full(){
return size == elementData.length;
}
}
class ContainerAlorithm{
//实现一个getContainerMinVal的方法,返回容器ArrayList容器的最小值
public static <E extends Comparable<E>>
E getContainerMinVal(ArrayList<E> list){
int size = list.size();
E val = list.get(0);
for(int i=1; i<size; ++i){
if(val.compareTo(list.get(i)) > 0){
val = list.get(i);
}
}
return val;
}
//实现一个printContainer打印容器的方法,传入一个ArrayList容器,把容器的元素值打印一遍
public static <E> void printContainer(ArrayList<E> list){
int size = list.size();
for(int i=0; i<size; ++i){
System.out.print(list.get(i) + " ");
}
System.out.println();
}
public static void printContainer2(ArrayList<?> list){
int size = list.size();
for(int i=0; i<size; ++i){
System.out.print(list.get(i) + " ");
}
System.out.println();
Object[] array = list.toArray();
for(Object val : array){
System.out.print(val);
}
}
}
public class TestArrayListDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<Integer> list1 = new ArrayList<Integer>();
for(int i=0; i<10; ++i){
list1.add(new Random().nextInt(100));
}
System.out.println(list1); // list1.toString()
}
}
容器类
最新推荐文章于 2019-06-12 21:50:02 发布