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;
}
}
}
4.可见性修饰符
private 修饰符：同一个类的能访问
default修饰符：同一个包能访问
protected修饰符：同一个包或任何包中的子类
public修饰符：公开的
5.防止扩展和重写
使用 final 修饰符表明一个类是最终的 ， 是不能作为父类的。
也可以定义一个方法为最终的 ， 最终方法不能被它的子类重写 。
