一、常用方法
- boolean add(E e)
确保此集合包含指定的元素（可选操作）。 - int size()
返回此集合中的元素数。 - void clear()
从此集合中删除所有元素（可选操作）。 - Object[ ] toArray()
返回一个包含此集合中所有元素的数组。 - boolean isEmpty()
如果此集合不包含元素，则返回 true 。
import java.util.ArrayList;
import java.util.Collection;
class Customer{
String name;
int age;
Customer(String name,int age){
this.age = age;
this.name = name;
}
public String toString(){
return "Customer[name="+name+"age="+age+"]";
}
}
public class CollectionTest01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//1.创建集合
//Collection c = new Collection(); 写法错误，接口不能new，需借助实现类
Collection c = new ArrayList(); //利用多态
//2.添加元素
c.add(1); //自动装箱
c.add(new Integer(100));
Object o = new Object();
c.add(o); //Collection集合只能单个存储元素
Customer cust = new Customer("张三",20);
c.add(cust);
//3.将集合转换成Object类型数组
Object[] objs = c.toArray();
//遍历该数组
for(int i=0;i<objs.length;i++){
System.out.println(objs[i]);
}
//4.获取元素的个数
System.out.println(c.size()); //4
System.out.println(c.isEmpty()); //false
//5.清空元素
c.clear();
System.out.println(c.size()); //0
System.out.println(c.isEmpty()); //true
}
}
- Iterator iterator()
返回此集合中的元素的迭代器。
通过迭代器中方法完成集合的迭代（遍历）。
在之前的这张图中左上角部分描述过迭代器
注意：这种方式是所有的集合通用的便利方式。
import java.util.*;
public class CollectionTest02 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建集合对象
Collection<Comparable> c = new LinkedList<Comparable>();
//添加元素
c.add(10);
c.add(3.14);
c.add(true);
//迭代
//1.获取迭代对象
Iterator<Comparable> it = c.iterator();
System.out.println(it); //java.util.AbstractList$Itr是ArrayList集合所依赖的迭代器
//java.util.LinkedList$ListItr是LinkedList集合所依赖的迭代器
//Itr 、ListItr是内部类
//迭代器是面向接口编程，it是引用，保存了内存地址，指向堆中的"迭代器对象"
//2.遍历集合调用Collection内部方法
while(it.hasNext()){
Object element = it.next();
System.out.println(element);
}
/*
boolean b = it.hasNext(); 判断是否有更多的元素
Object element = it.next(); 将迭代器下移一位，并且取出指向的元素
原则：it.next()之前必须先调用it.hasNext()方法，防止出现空指针异常
*/
/*for(Iterator<Comparable> it1 = c.iterator();it.hasNext();){
Object element1 = it.next();
System.out.println(element1);
}
*/
}
}
-
boolean contains(Object o)
如果此集合包含指定的元素，则返回 true 。 -
boolean remove(Object o)
从该集合中删除指定元素的单个实例（如果存在）（可选操作）。 -
存储在集合中的元素应该去重写equals方法
import java.util.*;
public class CollectionTest03 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建集合
Collection c = new ArrayList();
//创建Integer类型的对象
Integer i1 = new Integer(10);
//添加对象
c.add(i1);
//判断集合中是否包含对象i1
System.out.println(c.contains(i1)); //true
//再创建一个Integer对象
Integer i2 = new Integer(10);
//删除
c.remove(i2);
System.out.println(c.size()); //0
//判断集合中是否包含对象i2
System.out.println(c.contains(i2)); //true
//这就涉及到之前学的整型常量池，所以i1就是i2
//并且contains方法底层调用的是equals方法
//创建Manager对象
Manager m1 = new Manager(100,"张三");
//添加对象
c.add(m1);
//判断集合中是否存在对象m1
System.out.println(c.contains(m1)); //true
//再添加一个Manager对象
Manager m2 = new Manager(100,"张三");
//判断集合中是否存在对象m2
System.out.println(c.contains(m2));
//删除
c.remove(m2);
System.out.println(c.size()); //0
//重写equals方法之前
//System.out.println(c.contains(m2)); false
//重写equals方法之后
//System.out.println(c.contains(m2)); true
}
}
class Manager{
int no;
String name;
Manager(int no,String name){
this.no = no;
this.name = name;
}
//重写equals方法
public boolean equals(Object o){
if(this==o) return true;
if(o instanceof Manager){
Manager m = (Manager)o;
if(m.no==this.no && m.name.equals(this.name)){
return true;
}
}
return false;
}
}
二、深入remove方法
1.迭代器的remove方法
2.集合本身的remove方法
import java.util.*;
public class CollectionTest04 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建一个集合
Collection c = new ArrayList();
//添加元素
c.add(1);
c.add(2);
c.add(3);
//获取迭代器遍历
Iterator it = c.iterator();
while(it.hasNext()){
//推荐使用迭代器自身的remove方法
it.next();
//删除
it.remove();
/*
//使用集合本身的remove方法删除
Object element = it.next();
//删除
c.remove(element);
这种方式需要在每一次删除后重新获取新的迭代器
*/
}
System.out.println(c.size()); //0
}
}
三、Collection与Collections的比较
java.util.Collections; 集合工具类
java.util.Collection; 集合接口
1.Collections 是集合工具类，用来对集合进行操作。部分方法如下
-public static <T> boolean addAll(Collection<T>c,T...elements)//往集合中添加一些元素
-public static void shuffle(List<?> list) //打乱集合顺序
-public static <T> void sort(List<T> list) //对集合进行排序，默认为升序
注意：
- sort使用前提：被排序的集合里边存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序的规则
- sort使用范围
适用于List，若为其他类型，需要将其强制类型转换
2.Comparable接口的排序规则：
// 自己(this)-参数:升序
public static <T>void sort(List<T> list, Comparator<? super T>):
//将集合中元素按照指定规则排序
3.Comparator和Comparable的区别
Comparable:自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判，比较两个
Comparator定义排序规则： o1-o2 升序，反之降序
import java.util.*;
public class CollectionsTest01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//使用Collections工具完成集合的排序
List l = new ArrayList();
//添加元素
l.add(10);
l.add(60);
l.add(20);
l.add(40);
l.add(30);
//遍历
for(int i = 0; i < l.size(); i++){
System.out.println(l.get(i));
}
System.out.println("=================");
//完成集合的排序
Collections.sort(l);
//遍历
for (int i = 0; i < l.size(); i++) {
System.out.println(l.get(i));
}
System.out.println("=================");
//给定一个set集合
Set s = new HashSet();
//添加元素
s.add(15);
s.add(35);
s.add(55);
s.add(25);
s.add(45);
/*
Collections.sort(s);
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The method sort(List<T>) in the type Collections is not applicable for the arguments (Set)
*/
//进行强制类型转换
List lists = new ArrayList(s);
Collections.sort(lists);
//遍历
Iterator it = lists.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("=================");
//将ArrayList集合转化成线程安全的
List mylist = new ArrayList();
Collections.synchronizedList(mylist);
}
}
