目录
集合的概述
为什么出现集合类？ 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。 数组和集合类同是容器，有何不同？ 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象(引用数据类型)。 集合类的特点 集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象
集合类的关系图
1、Collection接口
Collection接口概述
Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
Collection接口成员方法
boolean add(E e)//将指定的元素追加到此列表的末尾
例:
List arrayList = new ArrayList();
arrayList.add(I);
System.out.println(arrayList);
boolean remove(Object o)//删除此列表中指定位置的元素
例:
List arrayList = new ArrayList();
arrayList.add(I);
arrayList.add(love);
arrayList.remove(1);// 删除此列表中索引位置为 1 的元素
arrayList.remove("love");//删除此列表中第一次出现的 love 元素
System.out.println(arrayList);
void clear()//清除集合中所有的元素
例:
List arrayList = new ArrayList();
arrayList.add(I);
arrayList.clear();
System.out.println(arrayList);
boolean contains(Object o)//判断是否包含指定的元素，则返回 true，否则返回 false
例:
List arrayList = new ArrayList();
arrayList.add(I);
arrayList.add(love);
boolean s = arrayList.contains("I");
System.out.println(s);
boolean isEmpty()//如果此 collection 不包含元素(此集合为null)，则返回 true
例:
boolean s = s.isEmpty();//判断该集合是否为空集合，如果为空集合（null）返回true，不为空返回false
System.out.println(s);
boolean addAll(Collection c)//添加所有元素
例:
List arrayList1 = new ArrayList();
arrayList1.add(I);
List arrayList2 = new ArrayList();
arrayList2.add(love);
arrayList2.addAll(arrayList1);
System.out.println(arrayList1);
System.out.println(arrayList2);
boolean removeAll(Collection c)//删除集合中所有元素
boolean containsAll(Collection c)//判断集合A中是否包含集合B中的元素
boolean retainAll(Collection c)//移除此 collection 中未包含在指定 collection 中的所有元素仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
例:
List arrayList1 = new ArrayList();
arrayList1.add(I);
arrayList1.add(love);
arrayList1.add(love);
List arrayList2 = new ArrayList();
arrayList2.add(love);
arrayList2.add(I);
arrayList2.add(I);
boolean s = arrayList2.containsAll(arrayList1);
System.out.println(s);
boolean s2 = arrayList2.retainAll(arrayList1);
System.out.println(s2);
int size()//集合的长度
例:
List arrayList1 = new ArrayList();
arrayList1.add(I);
arrayList1.add(love);
arrayList1.add(love);
int s = arrayList.size();
System.out.println(s);Collection集合的遍历
Object[] toArray() 把集合转成数组，可以实现集合的遍历
Collection<String> arr = new ArrayList<String>();
arr.add("a");
arr.add("b");
arr.add("c");
System.out.println(arr);
String[] obj1 = arr.toArray(new String[arr.size()]);
System.out.println(obj1);//输出结果为:[Ljava.lang.String;@1c4af82c(如果觉得遍历很麻烦，可以重写toString方法)Iterator iterator() 迭代器，集合的专用遍历方式
Collection<String> arr = new ArrayList<String>();
arr.add("a");
arr.add("b");
arr.add("c");
Iterator<String> it = arr.iterator();
// System.out.println(it.next());输出集合中的第一个元素
while(it.hasNext()) {//获取集合的所有元素
System.out.println(it.next());
}Iterator接口概述
Iterator接口概述 对 collection 进行迭代的迭代器 依赖于集合而存在
成员方法 :
boolean hasNext() :判断是否还有下一个元素
E next() : 获取下一个元素
2、List及其子类
List接口概述
有序的Collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。 与 set 不同，列表通常允许重复的元素。
List的常用子类：
ArrayList
底层是数组结构，查询快，增删慢
LinkedList
底层结构是链表，查询慢，增删快
如何选择使用不同的集合？
如果查询多，增删少，则使用ArrayList
如果查询少，增删多，则使用LinkedList
如果你不知道使用什么，则使用ArrayList
List接口成员方法
void add(int index,E element)//把指定元素插入到指定位置
例:
List arr = new ArrayList();
arr.add("a");
arr.add("b");
arr.add("c");
arr.add(1,"b");
System.out.println(arr);
E remove(int index)//清除指定元素
例:
List arr = new ArrayList();
arr.add("a");
arr.add("b");
arr.add("c");
arr.remove(1);
System.out.println(arr);
E get(int index)//查询元素
例:
List arr = new ArrayList();
arr.add("a");
arr.add("b");
arr.add("c");
for (int i = 0; i < arr.size(); i ++) {
System.out.println("索引位置" + i + "的元素为" + arr.get(i));
}
E set(int index,E element)//修改元素
例:
List arr = new ArrayList();
arr.add("a");
arr.add("b");
arr.add("c");
arr.set(1,"s");
System.out.println(arr);
ListIterator listIterator()//List集合特有的迭代器
例:
List<String> arr = new ArrayList();
arr.add("a");
arr.add("b");
arr.add("c");
ListIterator<String> iter = arr.listIterator();
while(iter.hasNext())
{
String array = iter.next();
System.out.println(array);
}
List集合常用方法
ListIterator接口的成员方法
E next() 返回列表中的下一个元素。可以重复调用此方法来迭代此列表，或混合调用 previous 来前后移动boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true....
ArrayList概述和使用
底层数据结构是数组，查询快，增删慢 线程不安全，效率高
ArrayList案例:
存储字符串并遍历
存储自定义对象并遍历
Vector类概述及使用
底层数据结构是数组，查询快，增删慢 线程安全，效率低
Vector类特有功能
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()
例:
Vector v = new Vector();
v.addElement("a");
v.addElement("b");
v.addElement("c");
v.addElement("d");
Enumeration en = v.elements(); //获取枚举
while(en.hasMoreElements()) { //判断集合中是否有元素
System.out.println(en.nextElement()); //获取集合中的元素
}LinkedList概述和使用
底层数据结构是链表，查询慢，增删快 线程不安全，效率高
LinkedList类特有功能
public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()
例:
LinkedList list = new LinkedList();
list.add("a");
list.addFirst("b");
list.addlast("c");
System.out.println(list. getFirst());
System.out.println(list. getLast());
System.out.println(list. removeFirst());
System.out.println(list. removeLast());
//getFist get Fist 懂（￣︶￣）↗ 3、泛型以及增强for
泛型概述
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。
泛型的应用
泛型类
把泛型定义在类上
格式:public class 类名<泛型类型1,…>
注意:泛型类型必须是引用类型
泛型方法
把泛型定义在方法上
格式:public <泛型类型> 返回类型 方法名(泛型类型 .)
泛型接口
把泛型定义在接口上
格式:public interface 接口名<泛型类型1…>
泛型高级(通配符)
泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E
向下限定，E及其子类
? super E
向上限定，E及其父类
增强for
增强for概述
简化数组和Collection集合的遍历
格式：
for(数据类型 变量名 :遍历的目标){ 数据类型 变量名:声明一个变量用来接收遍历目标遍历后的元素
}
增强for循环的适用范围
如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。
增强for循环的缺点增强for循环和iterator遍历的效果是一样的，也就说增强for循环的内部也就是调用iteratoer实现的，但是增强for循环有些缺点，例如不能在增强循环里动态的删除集合内容、不能获取下标等。
注意事项：增强for的目标要判断是否为null 把前面的集合代码的遍历用增强for改进
4、Set及其子类
Set接口概述
一个不包含重复元素的 collection。
HashSet概述
HashSet类概述
HashSet是Java集合Set的一个实现类，Set是一个接口,不保证 Set 的迭代顺序 特别是它不保证该顺序恒久不变
HashSet如何保证元素唯一性
底层数据结构是哈希表(元素是链表的数组)
哈希表依赖于哈希值存储
添加功能底层依赖两个方法
int hashCode()
boolean equals(Object obj)
常用成员方法
boolean add(E e)
boolean contains(Object o)
boolean isEmpty()
Iterator<E> iterator()
boolean remove(Object o)；
int size()
//不详细写了,不懂往上翻,上面有类似例子
LinkedHashSet类概述
元素有序唯一
由链表保证元素有序
由哈希表保证元素唯一
TreeSet类概述
使用元素的自然顺序对元素进行排序
或者根据创建 set 时提供的 Comparator 进行排序
具体取决于使用的构造方法
5、Map集合
Map接口概述
将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值
Map接口和Collection接口的不同
Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构值针对键有效，跟值无关
Collection集合的数据结构是针对元素有效
Map接口成员方法
常用的成员方法
V put(K key,V value)//将指定值与此映射中指定键关联
V remove(Object key)//如果存在，则从此映射中删除指定键的映射
void clear()//从该映射中删除所有映射
boolean containsKey(Object key)//判断集合是否包含指定的键
boolean containsValue(Object value)//判断集合是否包含指定的值
boolean isEmpty()//判断集合是否为空
int size()//返回键值对的对数
获取方法
V get(Object key)//返回指定键映射到的值，如果该映射不包含键的映射，则返回 null
//map.get("波波");//返回18
Set<K> keySet()//返回此映射中包含的键的结合
Collection<V> values()//返回此映射中包含的集合
Set<Map.Entry<K,V>> entrySet()//返回此映射中包含的映射的集合
例:
//创建集合对象
Map<String, Integer> map = new HashMap<String, Integer>();
//添加元素
map.put("波波", 18);
map.put("杰哥", 20);
map.put("生哥", 17);
//获取所有键的集合
Set<String> set = map.keySet();
//遍历键的集合，获取到每一个键
for(String key :set){
//根据键去找值
String value = map.get(key);
System.out.println(key + " "+ value);
}
例:
//创建集合对象
Map<String, Integer> map = new HashMap<String, Integer>();
//添加元素
map.put("波波", 18);
map.put("杰哥", 20);
map.put("生哥", 17);
//获取所有键值对对象的集合Set<Map.Entry<K, V>> entrySet();
Set<Entry<String, Integer>> set = map.entrySet();
//遍历键值对对象的集合，得到每一个键值对对象
for(Map.Entry<String, Integer> me : set){
//根据键值对对象，获取键和值
String key = me.getKey();
Integer value = me.getValue();
System.out.println(key + " "+ value);
}
Map集合遍历
一.在 for 循环中使用 entries 实现 Map 的遍历
//创建集合对象
Map<String, Integer> map = new HashMap<String, Integer>();
//添加元素
map.put("波波", 18);
map.put("杰哥", 20);
map.put("生哥", 17);
for (Map.Entry<String, String> entry : map.entrySet()) {
String mapKey = entry.getKey();
String mapValue = entry.getValue();
System.out.println(mapKey + "=" + mapValue);
}
二.使用 for-each 循环遍历 key 或者 values，一般适用于只需要 Map 中的 key 或者 value 时使用。性能上比 entrySet 较好
//创建集合对象
Map<String, Integer> map = new HashMap<String, Integer>();
//添加元素
map.put("波波", 18);
map.put("杰哥", 20);
map.put("生哥", 17);
// 打印键集合
for (String key : map.keySet()) {
System.out.println(key);
}
// 打印值集合
for (Integer value : map.values()) {
System.out.println(value);
}
三.使用迭代器（Iterator）遍历
//创建集合对象
Map<String, Integer> map = new HashMap<String, Integer>();
//添加元素
map.put("波波", 18);
map.put("杰哥", 20);
map.put("生哥", 17);
Iterator<Entry<String, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Entry<String, Integer> entry = entries.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
}
四.通过键找值遍历
//创建集合对象
Map<String, Integer> map = new HashMap<String, Integer>();
//添加元素
map.put("波波", 18);
map.put("杰哥", 20);
map.put("生哥", 17);
for(String key : map.keySet()){
Integer value = map.get(key);
System.out.println(key+":"+value);
}
HashMap类概述
HashMap是java.util.Map接口最常用的一个实现类，前面所学的HashSet底层就是通过HashMap来实现的，HashMap允许使用null键和null值。键是哈希表结构，可以保证键的唯一性
LinkedHashMap类概述
Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。记录了元素保存的顺序，因此在遍历的时候可以按照当时的顺序读取。
TreeMap类概述
TreeMap 的底层实现了红黑树的结构，是一个可以比较元素大小的 Map 集合，默认会根据元素的 key 值进行自然排序（前提是 key 值实现了 Comparable 接口），我们也可以自己定义比较器来进行排序。
- 日常使用 HashMap;
- 需要记录元素保存顺序时使用 LinkedHashMap;
- 需要排序时使用 TreeMap。
6.Collections
Collections类概述
Collections 类是java提供的一个操作 Set、List 和 Map 等集合的工具类。
Collection 和 Collections的区别
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口。 List， Set就是继承自Collection接口。
Collections成员方法
http://t.csdn.cn/LBHxf 懂（￣︶￣）↗
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
