集合框架
用于存储数据的容器
1. 特点
1> 对象封装数据 对象多了也需要存储 集合用于存储对象
2> 对象的个数确定可以使用数组 不确定可以用集合 集合长度是可变的
2. 集合和数组的区别
1> 数组是固定长度的, 集合可变长度的
2> 数组可以存储基本数据类型 也可以存储引用数据类型, 集合只能存储引用数据类型
3> 数组存储的元素必须是同一个数据类型, 集合存储的对象可以是不同数据类型
3. 数据结构
就是容器中存储数据的方式
4. 单列集合
1> Collection(接口)
--> List
--> Set
常用方法
a. 添加
add(object): 添加一个元素
addAll(Collection): 添加一个集合中的所有元素
b. 删除
clear(): 将集合中的元素全删除 清空集合
remove(obj): 删除集合中指定的对象 注意 删除成功 集合的长度会改变
removeAll(collection): 删除部分元素 部分元素和传入Collection一致
c. 判断
boolean contains(obj): 集合中是否包含指定元素
boolean containsAll(Collection): 集合中是否包含指定的多个元素
boolean isEmpty(): 集合中是否有元素
d. 获取
int size(): 集合中有几个元素
e. 取交集
boolean retainAll(Collection): 对当前集合中保留和指定集合中的相同的元素 如果两个集合元素相同 返回flase 如果retainAll修改了当前集合 返回true
f. 获取集合中所有元素
Iterator iterator(): 迭代器
g. 将集合变成数组
toArray()
2> Iterator 接口
迭代器作用: 用于取集合中的元素
hasNext(): 如果有元素可以迭代 则返回ture
next(): 返回迭代的下一个元素
remove(): 从迭代器指向的collection中移除迭代器返回的最后一个元素
每一个集合都有自己的数据结构 都有特定的取出自己内部元素的方式 为了便于操作所有的容器 取出元素 将容器内部的取出方式按照一个统一的规则向外提供 这个规则就是Iterator接口 只要通过该接口就可以取出Collection集合中的元素 至于每一个具体的容器依据自己的数据结构 如何实现的具体取出细节 这个不用关心 这样就降低了取出元素和具体集合的耦合性
public static void main(String[] args) { Collection coll = new ArrayList(); coll.add("abc0"); coll.add("abc1"); coll.add("abc2"); //--------------方式1---------------------- Iterator it = coll.iterator();//获取容器中的迭代器对象 至于这个对象是是什么不重要 这对象肯定符合一个规则Iterator接口 while(it.hasNext()) { System.out.println(it.next()); } //---------------方式2用此种---------------------- for(Iterator it = coll.iterator(); it.hasNext(); ){ System.out.println(it.next()); } }
3> List(接口) 有序集合(存与取顺序一致) 可以放重复元素 元素都有索引
--> ArrayList(底层数组) 实现不同步 多线程不安全 查询快
--> LinkedList(底层链表) 实现不同步 多线程不安全 增删快
--> Vector(底层数组) 实现同步 多线程安全 效率低
--> Stack(堆栈) 先进后出(特有方法实现)
List本身是Collection接口的子接口 具备了Collection的所有方法 List的特有方法都有索引 这是该集合最大的特点
常用方法
a. 添加
add(index, element): 在指定的索引位插入元素
addAll(index, collection): 在指定的索引位插入一堆元素
b. 删除
remove(index): 删除指定索引位的元素 返回被删的元素
c. 获取
Object get(index): 通过索引获取指定元素
int indexOf(obj): 获取指定元素第一次出现的索引位 如果该元素不存在返回-1 通过-1 可以判断一个元素是否存在
int lastIndexOf(Object o): 反向索引指定元素的位置
List subList(start, end): 获取子列表
d. 修改
Object set(index, element): 对指定索引位进行元素的修改
e. 获取所有元素
ListIterator listIterator(): list集合特有的迭代器
List集合因为角标有了自己的获取元素的方式 遍历
for(int x=0; x<list.size(); x++) {
System.out.println("get:" + list.get(x));
}
在进行list列表元素迭代的时候 如果想要在迭代过程中 想要对元素进行操作的时候 比如满足条件添加新元素 会发生ConcurrentModificationException并发修改异常
导致的原因是: 集合引用和迭代器引用在同时操作元素 通过集合获取到对应的迭代器后 在迭代中 进行集合引用的元素添加 迭代器并不知道 所以会出现异常情况
解决办法: 既然是在迭代中对元素进行操作 找迭代器的方法最为合适 可是Iterator中只有hasNext, next, remove方法 通过查阅的它的子接口 ListIterator 发现该列表迭代器接口具备了对元素的增, 删, 改, 查的动作 ListIterator是List集合特有的迭代器 ListIterator it = list.listIterator; //取代Iterator it = list.iterator;
注意: 对于list集合 底层判断元素是否相同 其实用的是元素自身的equals方法完成的 所以建议元素都要复写equals方法 建立元素对象自己的比较相同的条件依据
LinkedList的特有方法
addFirst(): 获取链表中的第一个元素 如果链表为空 抛出NoSuchElementException
addLast();
offerFirst();
offerLast();
peekFirst(): 获取链表中的第一个元素 如果链表为空 返回null
peekLast();
removeFirst(): 获取链表中的第一个元素 但是会删除链表中的第一个元素 如果链表为空 抛出NoSuchElementException
removeLast();
pollFirst(): 获取链表中的第一个元素 但是会删除链表中的第一个元素 如果链表为空 返回null
pollLast();
4> Set(接口) 无序集合(存与取顺序不一致) 集合内部按照某种顺序排序 不可以存重复元素 必须保证元素唯一性
--> HashSet(底层哈希表) 实现不同步 多线程不安全 效率高
使用HashSet集合(或底层是哈希表的集合) 需要重写HashCode()与equals()方法保证数据的唯一性
--> LinkedHashSet(底层哈希表加链表) 有序集合(存与取顺序一致) 不能存重复元素 HashSet子类
--> TreeSet(底层二叉树) 实现不同步 多线程不安全 效率高
使用元素的自然顺序对元素进行排序或根据创建Set集合时提供的Comparator比较器进行排序 具体取决于使用的构造方法
Set接口中的方法和Collection中方法一致的 Set接口取出方式只有一种: 迭代器
哈希表的原理
a. 对对象元素中的关键字(对象中的特有数据) 进行哈希算法的运算 并得出一个具体的算法值 这个值 称为哈希值
b. 哈希值就是这个元素的位置
c. 如果哈希值出现冲突 再次判断这个关键字对应的对象是否相同 如果对象相同 就不存储 因为元素重复 如果对象不同 就存储 在原来对象的哈希值基础 +1顺延
d. 存储哈希值的结构 我们称为哈希表
e. 既然哈希表是根据哈希值存储的 为了提高效率 最好保证对象的关键字是唯一的 这样可以尽量少的判断关键字对应的对象是否相同 提高了哈希表的操作效率
对于ArrayList集合 判断元素是否存在 或者删元素底层依据都是equals方法
对于HashSet集合 判断元素是否存在 或者删除元素 底层依据的是hashCode方法和equals方法
TreeSet:
用于对Set集合进行元素的指定顺序排序 排序需要依据元素自身具备的比较性
如果元素不具备比较性 在运行时会发生ClassCastException异常 所以需要元素实现Comparable接口 强制让元素具备比较性 复写compareTo方法 依据compareTo方法的返回值 确定元素在TreeSet数据结构中的位置
TreeSet方法保证元素唯一性的方式 就是参考比较方法的结果是否为0 如果return 0 视为两个对象重复 不存
注意: 在进行比较时 如果判断元素不唯一 比如 同姓名, 同年龄, 才视为同一个人 在判断时 需要分主要条件和次要条件 当主要条件相同时 再判断次要条件 按照次要条件排序
TreeSet集合排序有两种方式 Comparable和Comparator区别:
a. 让元素自身具备比较性 需要元素对象实现Comparable接口 覆盖compareTo方法
b. 让集合自身具备比较性 需要定义一个实现了Comparator接口的比较器 并覆盖compare方法 并将该类对象作为实际参数传递给TreeSet集合的构造函数 第二种方式较为灵活
5. 双列集合(键值对)
1> Map(接口)<K,V> 键 不能重复 值 可以重复
--> HashMap(存取不一致) 底层是哈希表数据结构 可以存null键null值 实现不同步 多线程不安全 效率高
需要重写HashCode()与equals()方法保证数据(键)的唯一性
--> TreeMap(存取不一致) 底层是二叉树结构 根据指定规则排序 只可以存null值 实现不同步 多线程不安全 效率高
需要使用自然排序接口Comparable或比较器接口Comparator保证键的唯一性
--> Hashtable(存取不一致) 底层是哈希表数据结构 可以存任何非null键null值 实现同步 多线程安全 效率低
2> Map集合存储和Collection有着很大不同
Collection一次存一个元素, Map一次存一对元素
Collection是单列集合, Map是双列集合
Map中的存储的一对元素: 一个是键, 一个是值 键与值之间有对应(映射)关系
特点: 要保证map集合中键的唯一性
3> 常用方法
a. 添加
put(key,value): 当存储的键相同时 新的值会替换老的值 并将老值返回 如果键没有重复 返回null
void putAll(Map);
b. 删除
void clear(): 清空
value remove(key): 删除指定键
c. 判断
boolean isEmpty();
boolean containsKey(key): 是否包含key
boolean containsValue(value): 是否包含value
d. 取出
int size(): 返回长度
value get(key): 通过指定键获取对应的值 如果返回null 可以判断该键不存在 当然有特殊情况 就是在HashMap集合中 是可以存储null键null值的
Collection values(): 获取map集合中的所有的值
e. 获取map中的所有元素
原理: map中是没有迭代器的 collection具备迭代器 只要将map集合转成Set集合 可以使用迭代器了 之所以转成set 是因为map集合具备着键的唯一性 其实set集合就来自于map set集合底层其实用的就是map的方法
把map集合转成set的方法:
Set keySet();
Set entrySet(); //取的是键和值的映射关系
Entry就是Map接口中的内部接口 entry是访问键值关系的入口 是map的入口 访问的是map中的键值对
//取出map集合中所有元素的方式一: keySet()方法 //可以将map集合中的键都取出存放到set集合中 对set集合进行迭代 迭代完成 再通过get方法对获取到的键进行值的获取 Set keySet = map.keySet(); Iterator it = keySet.iterator(); while(it.hasNext()) { Object key = it.next(); Object value = map.get(key); System.out.println(key + ":" + value); } //取出map集合中所有元素的方式二: entrySet()方法 Set entrySet = map.entrySet(); Iterator it = entrySet.iterator(); while(it.hasNext()) { Map.Entry me = (Map.Entry)it.next(); System.out.println(me.getKey() + ":" + me.getValue()); }
6. 使用集合的技巧
看到Array就是数组结构: 有角标 查询速度很快
看到Link就是链表结构: 增删速度快 而且有特有方法 addFirst, addLast, removeFirst(), removeLast(), getFirst(), getLast()
看到hash就是哈希表: 就要想要哈希值 就要想到唯一性 就要想到存入到该结构的中的元素必须覆盖hashCode, equals方法
看到tree就是二叉树: 就要想到排序 就想要用到比较
比较的两种方式:
一个是Comparable 覆盖compareTo方法
一个是Comparator 覆盖compare方法
LinkedHashSet, LinkedHashMap: 这两个集合可以保证哈希表有存入顺序和取出顺序一致 保证哈希表有序
集合什么时候用？
当存储的是一个元素时 就用Collection, 当存储对象之间存在着映射关系时 就使用Map集合
保证唯一 就用Set, 不保证唯一 就用List
7. Collections
它的出现给集合操作提供了更多的功能 这个类不需要创建对象 内部提供的都是静态方法
Collections.sort(list); //list集合进行元素的自然顺序排序
Collections.sort(list, new ComparatorByLen()); //按指定的比较器方法排序
class ComparatorByLen implements Comparator<String> {
public int compare(String s1, String s2) {
int temp = s1.length() - s2.length();
return temp == 0 ? s1.compareTo(s2) : temp;
}
}
Collections.max(list); //返回list中字典顺序最大的元素
int index = Collections.binarySearch(list, "zz"); //二分查找 返回角标
Collections.reverseOrder(); //逆向反转排序
Collections.shuffle(list); //随机对list中的元素进行位置的置换
将非同步集合转成同步集合的方法 Collections中的 XXX synchronizedXXX(XXX);
List synchronizedList(list);
Map synchronizedMap(map);
原理: 定义一个类 将集合所有的方法加同一把锁后返回
Collection 和 Collections的区别
Collections是个java.util下的类 是针对集合类的一个工具类 提供一系列静态方法 实现对集合的查找, 排序, 替换, 线程安全化(将非同步的集合转换成同步的) 等操作
Collection是个java.util下的接口 它是各种集合结构的父接口 继承于它的接口主要有Set和List 提供了关于集合的一些操作 如插入, 删除, 判断一个元素是否其成员, 遍历等
9. Arrays
用于操作数组对象的工具类 里面都是静态方法
1> 将数组转换成list集合
String[] arr = {"abc", "kk", "qq"};
List<String> list = Arrays.asList(arr); //将arr数组转成list集合
将数组转换成集合 可以通过list集合中的方法来操作数组中的元素: isEmpty(), contains, indexOf, set
注意(局限性): 数组是固定长度 不可以使用集合对象增加或者删除等 会改变数组长度的功能方法 比如add, remove, clear (会报不支持操作异常UnsupportedOperationException)
如果数组中存储的引用数据类型 直接作为集合的元素可以直接用集合方法操作
如果数组中存储的是基本数据类型 asList会将数组实体作为集合元素存在
2> 集合变数组
用的是Collection接口中的方法 toArray();
如果给toArray传递的指定类型的数据长度小于了集合的size 那么toArray方法 会自定再创建一个该类型的数据 长度为集合的size
如果传递的指定的类型的数组的长度大于了集合的size 那么toArray方法 就不会创建新数组 直接使用该数组即可 并将集合中的元素存储到数组中 其他为存储元素的位置默认值null
所以 在传递指定类型数组时 最好的方式就是指定的长度和size相等的数组
将集合变成数组后 限定了对集合中的元素进行增删操作 只要获取这些元素即可