本文主要介绍的有List接口下的ArrayList集合和LinkedList集合，还有Set接口下的HashSet集合和Map接口下的HashMap集合，以及泛型的使用。
目录
一、Collection类
这是Set集合和List集合的总类，以下介绍其中的常用方法在Set和List集合中也同样适用。
1.简单方法
// 创建集合对象
Collection c = new ArrayList();
// 测试Collection接口中的常用方法
c.add(100);// 自动装箱(java5的新特性。),实际上是放进去了一个对象的内存地址。Integer x = new Integer;
c.add(1.1);
c.add("a");
// 获取集合中元素
System.out.println("集合中元素个数为："+c.size());
// 清空集合
c.clear();
System.out.println("集合中元素个数为："+c.size());
// 判断集合中是否包含1.1
boolean retValue = c.contains(1.1);
System.out.println(retValue);
// 删除集合中某个元素
c.remove(1.1);
System.out.println(c.contains(1.1));
// 判断集合是否为空
System.out.println(c.isEmpty());
// 将集合转换成数组
Object obj[] = c.toArray();
for(int i = 0;i<obj.length;i++){
System.out.print(obj[i]+" ");
}2.用迭代器遍历集合
Collection c = new ArrayList();
c.add("ab");
c.add(100);
c.add(new Object());
// 第一步：获取集合的迭代对象Iterator
Iterator iterator = c.iterator();
// 第二步：通过以上获取的迭代器对象开始迭代/逦历集合。
// 以下两个方法是迭代器对象Iterator中的方法:
// booLean hasNext()如果仍有元素可以迭代，则返回true。
// object next()返回迭代的下一个元素。
// 判断是否有下一个元素
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);
}二、ArrayList集合
ArrayList集合是有序可重复的，即存进去的元素和取出来的元素顺序相同，每一个元素都有下标
并且存储进去的元素可以相同。
ArrayList底层是一个数组，这造就了这个集合检索效率较高，但是增删元素效率较低。
由于ArrayList集合中元素下标，所以可以有三中方式遍历集合。
1.for循环遍历（利用下标）
// 准备数据：创建5个NewsTitle类对象
NewsTitle nt1 = new NewsTitle(1001, "三亚新增本土480+774", "百度");
NewsTitle nt2 = new NewsTitle(1002, "中国成功发射一箭十六星", "中国航天");
NewsTitle nt3 = new NewsTitle(1003, "男子救落水5人后遇难 同伴讲述经过", "民间观察");
NewsTitle nt4 = new NewsTitle(1004, "苏氏祖祠：苏炳添是苏东坡第29代孙", "生活观察");
NewsTitle nt5 = new NewsTitle(1005, "家长花200万给娃集奥特曼卡没集齐", "合肥观察");
// 准备容器：创建集合对象，创建ArrayList对象
ArrayList a1 = new ArrayList();
// 将数据存储到集合中，向集合中添加元素不是通过元素下标来赋值，而是通过集合对象调用方法实现
a1.add(nt1);
a1.add(nt2);
a1.add(nt4);
a1.add(nt3);
a1.add(nt4);
for(int i = 0;i<a1.size();i++){
Object obj = a1.get(i);
// 将元素存入集合中会将其向上转型变为Object，所以将元素取出时需要向下转型
// NewsTitle ntw = (NewsTitle) obj;
System.out.println(obj);
}2.增强for循环遍历
for (Object obj : a1) {
System.out.println(obj);
}3.迭代器遍历
Iterator it = a1.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
三、LinkedList集合
LinkedList集合也是有序可重复的，所以也可以使用和ArrayList集合相同的三种遍历方法。
但是该集合底层是一个链表，这造就了它增删元素效率更高，但遍历效率较低。
LinkedList中有一些特有的方法
LinkedList link = new LinkedList();
//获取集合中的第一个元素和最后一个元素
System.out.println(link.getFirst());
System.out.println(link.getLast());
System.out.println("-------------------------");
//删除集合中的第一个元素和最后一个元素
link.removeFirst();
link.removeLast();
for (Object object : link) {
System.out.println(object);
}
四、HashSet集合
HashSet集合底层是一个HashMap，放到HashSet中的元素相当于放到了HashMap集合中的key部分。且HashSet集合是无序不可重复的，遍历集合只能使用增强for循环或者迭代器的方法。
五、HashMap集合
HashMap集合底层是一个哈希表，是数组于链表的集合体，其中的元素是以键值对(key，value)的形式进行存储的，其中的key值不可以重复，value值可以重复。
HashMap<String,String> map = new HashMap<String,String>();
// 存储元素
map.put("CN","中华人民共和国");
map.put("JP","日本国");
map.put("RU","俄罗斯联邦");
map.put("USA","美利坚共和国");
map.put("UK","大不列颠及北爱尔兰联合王国");
// 获取集合键值对个数
System.out.println(map.size());
// 根据键获取值
System.out.println(map.get("CN"));
System.out.println(map.get("CNN"));
// 删除集合中的元素
String s1 = (String) map.remove("JP");
System.out.println(s1);
System.out.println(map.size());
// 获取所有的key值
Set set = map.keySet();
for (Object obj : set) {
System.out.println(obj);
}
System.out.println("-----------------------");
// 获取HashMap集合中对应键的值
Collection c = map.values();
for(Object obj : c){
System.out.println(obj);
}
System.out.println("-----------------------");
// 查询集合中是否存在指定键对应的键值对
System.out.println(map.containsKey("CN"));
// 遍历键值对的第一种方法
// 获取键的集合，然后再遍历键的集合过程中调用get()方法获取值
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key+"-->"+map.get(key));
}
System.out.println("-----------------------");
// 方法二：获取键的集合，然后再遍历键的集合过程中调用get()方法获取值
Set<String> keys1 = map.keySet();
Iterator<String> it1 = keys1.iterator();
while(it1.hasNext()){
String key = it1.next();
System.out.println(key+"-->"+map.get(key));
}
System.out.println("-----------------------");
/*
使用entrySet()方法将map集合中的键值对整体取出来放在Set集合中
然后使用增强for循环或者迭代器取出Set集合中的键值对元素，取出来的是object类型，实际上键值对的真正类型是Map.Entry类型
所以将取出来的元素强制转换为Map.Entry类型，Map.Entry类中有getKey()方法获取键值对的键，有getValue()方法获取键值对的值
*/
// 方法三：键值对遍历：将map集合中的键值对整体取出来后放入Set集合
Set<Map.Entry<String,String>> keyValues = map.entrySet();
for(Map.Entry<String,String> me : keyValues){
System.out.println(me.getKey()+"-->"+me.getValue());
}
System.out.println("*****************************");
// 方法四：键值对遍历，把Map集合整体取出来放入Set集合，
// 获取集合的迭代对象it2，然后进行迭代
// it2.hasNext()判断是否有迭代对象，如果有则可以迭代，若没有则退出循环
// it2.next()返回迭代的元素为Object类型，再强转为Map.Entry类型
// Map.Entry类中有getKey()方法获取键值对的键，有getValue()方法获取键值对的值
Set <Map.Entry<String,String>> ketValue2 = map.entrySet();
Iterator<Map.Entry<String,String>> it2 = ketValue2.iterator();
while(it2.hasNext()){
Map.Entry<String,String> me = it2.next();
System.out.println(me.getKey()+"-->"+me.getValue());
}六、泛型
泛型好处：
第一：集合中存储的元素统一了
第二：从集合中取出来的元素类型是泛型指定的类型，不需要进行大量向下转型
缺点：会导致缺乏多样性
public static void main(String[] args) {
// 使用泛型List<Animal>之后，表示List集合中只允许存储Animal类型的数据。用泛型来指定集合中存储的数据类型。
List list = new ArrayList<Animal>();
// 使用泛型后使得集合中元素更加统一了
Cat c = new Cat();
Bird b = new Bird();
list.add(c);
list.add(b);
// 迭代器迭代的都是Animal类型
Iterator<Animal> it1 = list.iterator();
while(it1.hasNext()){
// 使用泛型之后每一次迭代返回数据都是Animal类型
Animal a = it1.next();
a.move();
}
}class Animal{
public void move(){
System.out.println("动物在移动");
}
}
class Cat extends Animal{
public void move(){
System.out.println("猫在走猫步");
}
}
class Bird extends Animal{
public void move(){
System.out.println("鸟在飞翔");
}
}引用泛型后使得整个集合只能存储Animal类型数据，让集合使用起来更简单了。
七、Collections类
Collections是集合工具类，其中提供了一些操作集合的方法。
// list不是线程安全的
List<String> list = new ArrayList<>();
// 变成线程安全的
Collections.synchronizedList(list);
// 排序
list.add("abc");
list.add("acy");
list.add("aah");
list.add("aoa");
list.add("aba");
Collections.sort(list);
for (String s : list) {
System.out.println(s);
}
//对Set集合进行排序
Set<String> set = new HashSet<>();
set.add("abc");
set.add("aac");
set.add("aca");
set.add("abd");
// Set集合转换成list集合
List<String> list1 = new ArrayList<>(set);
3333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
