一，Collection集合概述：
（1）集合是存储其他对象的特殊对象。可以将集合当做一个容器。
（2）集合的相关接口和类位于java.util包中。
（3）集合中的接口和类是一个整体、一个体系。
集合优点：数据类型不统一，长度不固定。
二，集合接口：
集合框架定义了一些接口，它们决定了集合类的本质特性。具体的集合类只是提供了标准接口的不同实现。
注意：
1、Collection接口中没有提供修改元素的方法。
2、Collection接口的父接口是Iterable接口，实现了Iterable接口的类是可以迭代的。
| 接 口 | 描 述 |
| Collection | 允许操作一组对象，它位于集合层次结构的顶部 |
| List | 扩展Collection，以处理序列(对象列表) |
| Deque | 扩展Queue，以处理双端队列 |
| Set | 扩展Collection，以处理组，组中的元素必须唯一 |
集合类：
| 类 | 描 述 |
| ArrayList | 动态数组 |
| LinkedList | 链表 |
| ArrayDeque | 双端队列 = 队列 + 堆栈 |
| PriorityQueue | 支持基于优先级的队列 |
| HashSet | 使用哈希表存储元素的组 |
| LinkedHashSet | 扩展HashSet类，以允许按照插入的顺序进行迭代 |
| TreeSet | 实现存储于树中的集合。 |
三，Collection常用的子接口：
Collection是集合类最大的父接口，下面是它的子接口（实现类）：
List
List集合：分为Arraylist，Linkedlist与Vector。
ArrayList：
基于数组, 查询效率高, 增加, 删除效率低, 线程不同步。
ArrayList实现了List接口。本质上是元素为对象引用的长度可变的数组。
ArrayList常用方法如下：
package listdemo;
import java.util.List;
import java.util.ArrayList;
public class ArrayListTest {
public static void main(String[] args) {
//泛型：参数化类型==》类型参数化 JDK1.5之后
List<String> list=new ArrayList<String>();
//Element=》元素-E
//向集合中添加数据=>追加 add(元素)
list.add("One"); //Integer
list.add("Two"); //Integer
list.add("Three"); //Integer
//插入 操作 add(插入位置，插入元素);
list.add(1,"我");
//通过下标查找 get(下标) 通过下标找元素
// String string = list.get(2);
//集合元素个数的 size()
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
//删除元素 通过下标删除元素 remove(下标)
// list.remove(2);
//删除元素 通过元素内容进行删除 remove(元素)
System.out.println("============================");
// Integer ii=31;
// list.remove("我");
//修改 set(修改的位置，修改后的内容)
// list.set(2, "WTO");
// for(int i=0;i<list.size();i++){
// System.out.println(list.get(i));
// }
//clear 清空集合
// list.clear();
//isEmpty() 是否为空集合 如果集合中没有元素 返回true
System.out.println(list.size()+"=="+list.isEmpty());
}
}
ArrayList集合的循环遍历,如下：
package cam;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class Demo {
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("One");
list.add("Two");
list.add("Three");
list.add("Four");
//第一种List 集合的循环遍历方法
//1：集合个数，2：get方法
//掌握程度* 最好理解的写法
// for(int i=0;i<list.size();i++){
// System.out.println(list.get(i));
// }
//第二种List 集合的循环遍历方法
//增强for循环 也称之为foreach 循环
//for(元素的数据类型 名：集合/数组对象){}
//写法最简单 ***
// for(String s:list){
// System.out.println(s);
// }
//第三种List 集合的循环遍历方法
//Iterator 迭代器
//生成迭代器 *****
Iterator<String> it=list.iterator();
//it.hasNext() 代表 是否存在下一个 元素
//it.next() 将下一个元素返回 并且指针下一（指针人为定义）
//it.remove() 迭代器 remove方法
while(it.hasNext()){
String str =it.next();
if(str.equals("Three")){
it.remove();
// list.remove("Three");
//break;
//使用迭代器删除操作 不要使用集合的删除 建议使用迭代器的删除，
//如果使用集合的删除操作 必须使用break
}
}
}
LinkedList:
基于链表, 查询效率低, 增加, 删除效率高, 线程不同步。
LinkedList类实现了List、Deque以及Queue接口。
它提供了（双向）链表数据结构。
具体实现就不写了，下面写一些它的常用方法：
注：List 接口中所有的方法 ，LinkedList 也存在。
LinkedList独有的方法：
1，addFirst() 添加到集合的首部
2，addLast() 添加到集合的尾部
3，getFirst(); 获取第一个元素
4，getLast() 获取最后一个元素
5，removeFirst(); 删除第一个元素
6，removeLast() 删除最后一个元素
ArrayList与LinkedList的区别：
1、ArrayList是基于数组结构的集合，有容量的概念；LinkedList是基于链表结构的集合，没有容量的概念
2、对于随机访问（get和set方法），ArrayList优于LinkedList，因为LinkedList要移动指针。
3、对于新增和删除操作（add和remove方法），LinkedList比较占优势，因为ArrayList要移动数据。但是如果只是在末尾追加元素，并且没有超出容量限制，则ArrayList的性能更好。
4、LinkedList 还实现了Queue接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等。
Vector：
限制线程同步的一个线程安全的list集合。Stack是Vector的子类，Stack与Vector一样，是线程安全的，但是性能较差，尽量少用Stack类。如果要实现栈”这种数据结构，可以考虑使用LinkedList。按照原来长度的2倍扩容。
Set
Set集合 ：是一个无序且不可重复的集合：分为HashSet,TreeSet与LinkedHashSet。
HashSet：
基于HashCode 码实现
HashSet类实现了Set接口。该类在内部使用哈希表存储元素。
哈希表使用称之为散列法(hashing)的机制存储信息。
希法的优点是add()、contains()、remove()以及size()方法的执行时间保持不变，即使是对于比较大的集合也是如此。HashSet() //默认容量是16。
HashSet中元素不是按有序的顺序存储的，遍历输出HashSet中的元素时精确的输出可能不同。
HashSet实现测试，如下：
package cbm;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetTest {
public static void main(String[] args) {
//创建Set 集合
//HashSet 是基于HashCode 码 进行排列的
Set set=new HashSet();
//添加 add();
//当出现 重复的元素 返回false 代表不允许添加重复元素
// boolean f1 = set.add("你好");
// boolean f2 = set.add("你好");
// boolean f3 = set.add("你好");
// set.add(" ");
// set.add("");
// set.add(null);
// System.out.println(f1);
// System.out.println(f2);
// System.out.println(f3);
//清空集合 clear()
//contains 是否包含指定元素
// boolean contains = set.contains("你");
// System.out.println(contains);
//是否为空 isEmpty();
//删除元素 remove(元素); Set集合本身是无序所以没有下标
// boolean remove = set.remove("你好");
// System.out.println(set.isEmpty());
// size（） 获取集合元素的个数
// System.out.println(set.size());
// Iterator it = set.iterator();
// while(it.hasNext()){
// Object o=it.next();
// System.out.println(o);
// }
}
}TreeSet：
基于二叉树实现，最大的特点就是元素会按照自然顺序排序。
TreeSet类实现了NavigableSet接口，该类在内部使用树结构存储元素。元素以升序存储，访问和检索相当快。
TreeSet适合于存储大量的、必须能够快速查找到的有序信息。
Set与List的区别：
1、Set中的元素不能重复，List中的元素可以重复。
2、List有索引（下标）的概念，Set没有索引的概念。
3、对于Set表示的集合，通常是遍历操作，没有get()和set()方法。
注意：
TreeSet以升序保存对象，所以TreeSet中保存的对象比较能够比较大小，即TreeSet保存的对象类型必须实现Comparable接口。
package cbm;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class SetTest1 {
public static void main(String[] args) {
Student s1 = new Student(12,"张三");
Student s2 = new Student(14,"李四");
Student s3 = new Student(1,"王五");
Student s4 = new Student(25,"赵六");
//使用TreeSet 添加的元素的数据类型 必须实现Comparable 比较器
Set<Student> set=new TreeSet<Student>();
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
Iterator<Student> it = set.iterator();
while(it.hasNext()){
Student s=it.next();
System.out.println(s);
}
}
}
//学生类
package cbm;
public class Student implements Comparable{
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
@Override
public String toString() {
return "Student [age=" + age + ", name=" + name + "]";
}
//比较器的方法
@Override
public int compareTo(Object o) {
Student s=(Student)o;
if(s.getAge()>this.getAge()){
return -1;
}
return 1;
}
//了解
//Set中 比较相同的方法是equals，HashCode 码是否相同
@Override
public boolean equals(Object obj) {
Student s=(Student)obj;
if(s.getName().equals(this.getName())&&s.getAge()==this.getAge())
return true;
return false;
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return 1;
}
}LinkedHashSet类：
扩展了HashSet类，它没有添加它自己的方法。
LinkedHashSet在内部使用一个链表维护元素添加到集合中的顺序，因此可以按照插入顺序迭代集合。
下面是对一些实现方法：
package cbm;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class SetTest2 {
public static void main(String[] args) {
//LinkedHashSet Set集合中唯一有插入顺序的集合
LinkedHashSet<String> lhs=new LinkedHashSet<String>();
// HashSet<String> lhs=new HashSet<String>();
lhs.add("你好");
lhs.add("我好");
lhs.add("大家好");
lhs.add("都好,都好");
Iterator<String> it = lhs.iterator();
while(it.hasNext()){
String next = it.next();
System.out.println(next);
}
}
}注意：Set类型的集合（实现Set接口的类）称为集，有些资料称为组，其特点是组中的元素必须唯一。
HashSet是无序的，LinkedHashSet和TreeSet是有序的。
四，遗留的集合类与接口
在集合之前，Java提供了特定的类，存储和管理对象组，例如Dictionary、Vector、Stack和Properties。
早期版本的java.util包没有包含集合框架。反而，定义了几个类和接口，提供存储对象的专门方法。当添加集合时(由J2SE 1.2添加)，对几个原始类进行了重新设计，以支持集合接口。因此，从技术上讲它们现在是集合框架的组成部分。
前面介绍的所有现代集合类都不是同步的，但是所有遗留类都是同步的。
1 ，Vector类
现在Vector类实现了动态数组，与ArrayList类似，也实现List接口。但有如下区别：
l Vector实现同步，线程安全。ArrayList没有实现线程安全。
l Vector性能比ArrayList低。
l Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间（2n），而ArrayList每次对原长度增加1.5倍加1（公式：oldLength+oldLength/2+1，即：每一次增加1.5倍）。
2， Hashtable类
Hashtable类也实现了Map接口，与HashMap类似。
主要区别：
1、Hashtable是同步的、线程安全的，而HashMap不是同步的，没有实现线程安全。
2、HashMap允许将null作为一个条目的key或者value，而Hashtable不允许。当然只能有一个条目的键为null。
3、HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
五，比较特殊的集合：Map集合（这里只介绍HashMap）
HashMap基本方法：
package cbm; import java.util.Map; import java.util.HashMap; public class MapTest { public static void main(String[] args) { Map<String,String> map=new HashMap<String,String>(); // 从增删改查xueqi // 增加 put(键，值) // map.put("One", "壹"); //增加 // map.put("Two", "贰"); //查寻 get(键); 通过键找到值 // String s=map.get(11); // System.out.println(s); //删除 remove(键) 通过键删除键与值的映射关系 返回 原有的value的值 // String sss=map.remove("Two"); // System.out.println(sss); // System.out.println(map.get("Two")); // map.put("Two","叁"); //clear() 清空集合 //size() map 集合的键值关系数 //isEmpty() 当前集合是否为空集合 size 是否为0; // System.out.println(map.size()); // map.clear(); // System.out.println(map.size()); //当前集合是否包含某一个键 containsKey // boolean ck = map.containsKey("壹"); // System.out.println(ck); //当前集合是否包含某一个值containsValue // boolean cv = map.containsValue("One"); // System.out.println(map.get("Two")); // System.out.println(cv); } }
Map集合遍历方法：
package cbm;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class MapTest1 {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String> ();
map.put("One", "壹");
map.put("Two", "贰");
map.put("Three", "叁");
map.put("Four", "肆");
//遍历第一种方式
//map 遍历本身没有迭代器 需要一个有迭代器的集合接收 map 对象的元素
//这个set 集合中存放着map 集合的键
//keySet() 将 map 集合对象的键 放入一个新的Set 集合对象中
//*****
// Set<String> set=map.keySet();
// for(String s:set){
// String key=s;
// String value=map.get(key);
// System.out.println(key+"====="+value);
// }
//遍历第二种方式 直接遍历值
//如果单纯遍历值 可以使用 values 方法
//返回的结果 不是Set 集合而是Collection集合
// Collection<String> cl = map.values();
// Iterator<String> it = cl.iterator();
// while(it.hasNext()){
// String value = it.next();
// System.out.println(value);
// }
//遍历第三种方式 将键与值 一次性取出
//**
Set<Entry<String, String>> set = map.entrySet();
Iterator<Entry<String, String>> it = set.iterator();
while(it.hasNext()){
Entry<String, String> en = it.next();
System.out.println(en.getKey()+"========"+en.getValue());
}
}
} 
更多相关Map集合的知识点击进入“映射篇”。
扫一扫
321
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
