09.第十一章：继承和多态（2）

1.ArrayList 类

可以创建一个数组存储对象，但是这个数组一旦创建，它的大小就固定了。 Java 提供 ArrayList 类来存储不限定个数的对象。

2.Arrays类

数组转为数组列表

String[ ] array = {"red","green","blue"};
ArrayList<String> list=new ArrayList<>(Arrays.asList(array));

数组列表转为数组

String[] arrary=new String(list.size);
list.toArray(array)

3.Collection类

排序

Intege  [ ] array = { 3 , 5 , 95 , 4 , 15 , 34 , 3 , 6 , 5 } ;
ArrayList < Integer > list = new ArrayList<>( Arrays . asList ( array )) ;
java . util . Collections . sort ( list ) ;
System . out . println ( list )

返回最大最小值

Integer [ ] array « { 3 , 5 , 95 , 4 , 15 , 34 , 3 , 6 , 5 } ;
ArrayLi st < Integer > list=new ArrayList<> ( Arrays . asLi st ( array )) ;
System . out . println ( java . util . Collections . max ( list ) ) ;
System . out . println ( java . util . Collections . min ( list )) ;

随机打乱列表元素

Integer [ ] array={ 3 , 5 , 95 , 4 , 15, 34 , 3, 6 , 5} ;
ArrayList < Integer > list = new ArrayLi st<>( Arrays . asList ( array )) ;
java . util . Collection . shuffle ( list ) ;
System . out . println ( list )

4.自定义栈类

用ArrayList实现

public class MylistStack {
    private ArrayList<Object> list=new ArrayList<>();
    public boolean isEmpty(){
        return list.isEmpty();
    }
    public int getSize(){
        return list.size();
    }
    public Object peek(){
        return list.get(getSize()-1);
    }
    public Object pop(){
        Object o=list.get(getSize()-1);
        list.remove(getSize()-1);
        return o;
    }
    public  void push(Object o){
        list.add(o);
    }
}

用数组实现

public class MyStack {
    private int []elements;
    private int top=-1;
    //设置默认的数组大小
    private static final int DEFAULT_CAPACITY=16;

    public MyStack(){
        elements=new int[DEFAULT_CAPACITY];
    }
    public boolean isEmpty(){
        return top==-1;
    }
    public int getsize(){
        return ++top;
    }
    public Object peek(){
        return elements[top];
    }
    public Object pop(){
        int value=elements[top];
        top--;
        return value;
    }
    public void  push(int value) {
        if (getsize() >= DEFAULT_CAPACITY) {
            //如果size>=数组的大小，就将数组的大小扩容
            int[] temp = new int[elements.length * 2];
            System.arraycopy(elements, 0, temp, 0, elements.length);
            elements = temp;
        }
    }

}