Java - 集合
Java - 集合
* 本节要点
1、Java 框架集合
2、Collection 接口API
3、Iterator 迭代器接口
4、Collection 子接口之一：Set接口
> HashSet LinkedHashSet TreeSet
5、Collection 子接口之二：List接口
> ArrayList LinkedList Vector
6、Map 接口
> HashMap TreeMap Hashtable
7、Collections 工具类
一、Java 集合概述
集合可以存储数量不等的多个对象，还可用于保存具有映像关系的关联数组，集合又被简称为容器
1、Java 集合分为两种体系：Collection 和 Map
> Collection 接口
> Set ：元素无序、不可重复的集合
> List ：元素有序、可重复的集合
> Map 接口 ：具有映射关系 "key - value对" 的集合，"key" 是唯一的
二、Collection 接口API
1、Collection 接口继承树
2、Collection 中的方法：
> size() -> 返回集合中的元素个数
> add(Object obj) -> 向集合中添加元素(任何类型的元素)
> addAll(Collection coll) -> 将coll中包含的所有元素添加到当前集合中
Collection coll1 = Arrays.asList(1,2,3);
coll.addAll(coll1);
> isEmpty() -> 判断这个集合是否为空，为空返回 True
> clear() -> 清空集合中的元素
* System.out.println(coll); -> 查看集合中的元素
> contains(Object obj) -> 判断这个集合中是否包含指定的obj元素，如果包含返回 True
如何存入集合中的元素是自定义类的对象，要求：自定义类重写 equals() 方法
> containsAll(Collection coll) -> 判断当前集合中是否包含coll中所有的元素
> retainAll(Collection coll) -> 保留当前集合与coll集合共同的元素，就是求当前集合和coll集合的交集，将结果返回给当前集合
> remove(Object obj) -> 删除集合中的某一个元素，删除成功返回True，如果返回False说明里面没有
> removeAll(Collection coll) -> 删除当前集合中包含coll集合的所有元素，返回Boolean值
> equals(Object obj) ->判断两个集合中的元素是否相同
> hashCode() -> 算一下集合中的hash值，返回一个整数，主要在Set中用的多点,到时候在具体了解这个方法
> toArray() -> 将集合转换成数组
Object[] obj = coll.toArray();
> iterator() -> 用来遍历一个集合，返回一个Iterator接口实现类的对象
Iterator iterator = coll.iterator();
Iterator.hasNext(); // 判断是否有下一次元素
iterator.next(); // 返回集合中的元素，调用几次，返回几个
四、Collection 子接口之一：Set接口
HashSet(主要实现类)、LinkedHashSet、TreeSet
> 存储无序的，Set中常用的方法都是Collection 下定义的 (无序 != 随机，添加的顺序和输出的顺序不一样，但是运行多少次得到的结果是有序的，
真正的无序性指的是元素在底层存储的位置是无序的，底层实现如C语言的链表)
> 不可重复的元素，当向Set中添加进相同的元素的时候，后面的这个不能添加进去
> 说明：要求添加进Set中的元素所在类，一定要重写Object的equals() 方法和hashCode() 方法，进而保证Set中的元素的不可重复性
> Set中添加元素时，采用 Hash算法，添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值决定了此对象在
Set中的存储位置。若此位置之前没有对象存储，则这个对象直接存储到此位置，若此位置已有对象存储，再通过equals()方法比较这两个对象
是否相同。如果相同，后一个对象就不能再添加进来
> 要求：hashCode() 和 equals() 方法属性相同
1、HashSet() 中常用的方法都是Collection 中的方法
2、LinkedHashSet：使用链表维护了一个添加进集合中的顺序，导致当我们遍历LinkedHashSet 集合元素时，是按照添加进去的顺序遍历的
> 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用链表维护元素的次序，这使得元素看起来是以 插入顺序保存的
> 插入性能略低于 HashSet，但在迭代访问Set里的全部元素时，有很好的性能
> 不允许集合元素重复
3、TreeSet
> 只能添加同一类型的数据或对象
> 无法插入相同的元素，并且插入的数据按照从小到大的顺序遍历
当自定义类没有实现 Comparable 接口时，当向TreeSet 中添加对象时，会报 ClassCastException异常错误
> 当向TreeSet 中添加自定义类的对象时，有两种排序方法：①自然排序、②定制排序
> 自然排序：要求自定义类实现java.lang.Comparable 接口并重写其 compareTo(Object obj) 抽象方法，在此方法中，指明按照自定义类的那个属性进行排序
> 向 TreeSet 中添加元素时，首先按照compareTo() 方法进行比较，一旦返回0，虽然仅是两个对象的此属性值相同，但程序会认为这两个对象是相同的，进
而后一个对象就不能添加进来
> compareTo() & hashCode() & equals() 三者之间保持一致
> 定制排序：要实现Comparator类
/*
* TreeSet的定制排序： 见下面的步骤 compare()与hashCode()以及equals()三者保持一致！
*/
@Test
public void testTreeSet2() {
// 1.创建一个实现了Comparator接口的类对象
Comparator com = new Comparator() {
// 向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer
// 的哪个属性排序的。
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
};
// 2.将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(com);
// 3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象。
set.add(new Customer("AA", 1003));
set.add(new Customer("BB", 1002));
set.add(new Customer("GG", 1004));
set.add(new Customer("CC", 1001));
set.add(new Customer("DD", 1001));
for (Object str : set) {
System.out.println(str);
}
}
五、Collection 子接口之二：List接口
1、List新增的方法;
List 的实现类：ArrayList、LinkedList、Verctor
ArrayList : List的主要实现类，List中新增了很多方法：
* 底层还是以数组实现
> void add(int index, Object ele)
在指定的索引位置添加元素 ，这种插入效率很低，如果在前面插入一个元素，后面的所有元素都要移位
> boolean addAll(int index, Collection eles)
在指定的索引位置添加一个eles集合
> Object get(int index)
获取指定索引位置的元素
> int indexOf(Object obj)
返回 obj 在集合中首次出现的位置，没有返回 -1
> int lastIndexOf(Object obj)
返回 obj 在集合中最后一次出现的位置，没有返回 -1
> Object remove(int index)
删除指定索引位置的元素，删除后，后面的数据依次往前挪
> Object set(int index, Object ele)
修改指定索引位置的元素为ele
> List subList(int fromIndex, int toIndex)
返回List中索引从 fromIndex 到 toIndex 的子集
LinkedList 对于频繁的插入删除操作效率比ArrayList 高很多
Verctor 已经被淘汰了
六、Map 接口
> Map 与 Collection 并列存在，用于保存具有映射关系的数据：Key-Value
> Map 中的 Key 和 Value 都可以是任何引用类型的数据
> Map 中的 Key 用 Set 来存放，不允许重复，即同一个 Map 对象所对象的类，须重写 hashCode() 和 equals() 方法
> 常用 String 类作为 Map 的 "Key"
> Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value(Value 可以是重复的，Key是唯一的)。
> 一个 Key-Value 被称为一个 Entry，所有的Entry 是用Set 存放的，是不可重复的
* HashSet 类是 HashMap 类的特殊实现
1、Map 接口继承树
> TreeMap 按照添加进Map中的元素的 Key 的指定属性进行排序
> HashMap (主要实现类)，Key 是用 Set 存放的，不可重复，Value 是用Collection 存放的，可以重复
> 向HashMap 中添加元素时，会调用 Key 所在类的 equals(0 方法，判断两个 Key ***
> Hashtable 已经几乎不用了，
> Properties 比较常用，常用来处理属性文件，Key-Value都是String类型的
> LinkedHashMap 使用链表维护添加进Map中的顺序，故遍历 Map 时是按添加的顺利遍历的
2、Map 方法：
> Object put(Object key, Object value) -> 向Map中添加一个元素
> Object remove(Object key) -> 按照指定的e Key 值删除此 Key-Value
> void putAll(Map t)
> void clear() -> 清空
> Object get(Object key)
> boolean containsKey(Object key)
> boolean containsValue(Object value)
> int size() -> 返回集合的长度
> boolean isEmpty() -> 判断集合是否为空
> boolean equals(Object obj)
> keySet() -> 遍历 Key 集
Set set = map.keySet();
for (Object obj : set){
Ssytem.out.println(obj);
}
> values() -> 遍历 Value 集
Collection values = map.values();
Iterator i = values.iterator();
while (i.hasNext()){
System.out.println(i.next());
}
> entrySet() -> 遍历 Key - Value 对
3、如何遍历 Key - Value 对：
① 方式一
Set set1 = map.keySet();
for (Object obj : set1){
System.out.println("Key : " + obj + "<-->" + "Value: " + map.get(obj));
}
② 方式二
Set set2 = map.entrySet();
for (Object obj : set2){
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry);
}
4、使用Properties处理属性文件
@Test
public void test6() throws FileNotFoundException, IOException{
Properties pros = new Properties();
pros.load(new FileInputStream(new File("jdbc.properties")));
String user = pros.getProperty("user");
System.out.println(user);
String password = pros.getProperty("password");
System.out.println(password);
}
七、Collections 操作集合的工具类
* Collection 和 Collections 是有区别的
> Collections 可以操作 Collection 以及Map
1、常用方法：
> reverse(List)，反转List中元素的顺序
> shuffle(List)，对List 集合元素进行随机排序
> sort(List)，根据元素的自然顺序对指定List 集合元素按升序排序
> sort(List，Comparator)，根据指定的 Comparator 产生的顺序对List 集合元素进行排序
> swap(List, int i, int j)，将指定List 集合中的 i 处元素和 j 处元素进行交换
> Object max(Collection)，根据元素的自然顺序，返回给定集合中的最大元素
> Object max(Collection, Comparator)，根据 Comparator 指定的顺序，返回给定集合中的最大元素
> Object min(Collection)，根据元素的自然顺序，返回给定集合中的最小元素
> Object min(Collection, Comparator)，根据 Comparator 指定的顺序，返回给定集合中的最小元素
> int frequency(Collection, Object)，返回指定集合中指定元素的出现次数
> void copy(List dest, List src)，将 src 中的内容复制到 dest 中
> boolean replaceAll(List list, Object oldVal, Object newVal)，使用新值替换 List 中的旧值
