P513-

1.集合框架的概述：
1）集合、数组都是对多个数据进行存储操作的结构，简称Java容器
说明：此时的存储，主要是指内存方面的存储，不涉及到持久化的存储（.txt、.jpg、.avi、数据库中）

2）数组在存储多个数据方面的特点：
一旦初始化以后，其长度就确定了
数组一旦定义好，其数据类型就确定了，我们也就只能操作指定类型的数据了。

3）数组在存储多个数据方面的缺点：
一旦初始化以后，其长度不可修改。
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素个数的需求，数组中没有现成的属性或方法可用。
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不可满足。

2.集合框架：
——Collection接口：单列集合，用来存储一个一个的对象 （动态数组
——List接口：存储有序的、可重复的数据
——ArrayList、LinkedList、Vector

——Set接口：存储无序的、不可重复的数据 （高中讲的集合
——HashSet、LinkedHashSet、Treeset

——Map接口：双列集合，用来存储一对（key-value）一对的数据 （函数
————HashMap、LinkedHashMap、TreeMap、Hashtable、properties

3.Collecton接口中常用的方法：
1）add（Object e）：将元素e添加到集合coll中
Collection coll=new ArrayList（）；
coll.add（“AA”）;
coll.add（123）;
coll.add（new Date（））;

2）size（）：获取添加的元素个数
System.out.println(coll.size());

3）addAll（Collection coll1）：将coll1集合中的元素添加到当前的集合中
Collection coll1=new ArrayList（）；
coll1.add（456）;
coll1.add（“CC”）;
coll.add（coll1）；

4）clear（）：清空集合元素

5）isEmpty（）：判断当前集合是否为空

6）contains（Object obj）：判断当前集合中是否包含obj
我们在判断时会调用obj对象所在类的equals（）
向Collection接口的实现类中添加数据obj时，要求obj所在类要重写equals（）

7）containsAll（Collection coll1）：判断形参coll1中所有元素是否都存在与当前集合中
Collection coll1=Arrays.asList（123，456）；
System.out.println(coll.containsAll（coll1）);

8）remove（Object obj）：从当前集合中移除obj元素

9）removeAll（Collection coll1）：差集：从当前集合中移除coll1中所有元素

10）retainAll（Collection coll1）：交集：获取当前集合中和coll1集合的交集，并返回给当前集合

11)equals（Object obj）：要想返回true，需要当前集合和形参集合的元素都相同

12）hashCode（）：返回当前对象的哈希值

13）集合——>数组：toArray（）
Object[] arr=coll.toArray（）；
for（int i=0；i<arr.lenth；i++）{
System.out.println(arr[i]);
}

14）拓展：数组——>集合：调用Arrays类的静态方法asList（）
List list=Arrays.asList(new String[]{“AA”,“BB”,“CC”});
System.out.println(list);

List arr1=Arrays.asList(new int[]{123,456});
System.out.println(arr1.size()); //1

List arr2=Arrays.asList(new Integer[]{123,456});
System.out.println(arr2.size()); //2

15）iterator（）：返回Iterator接口的实例，用于遍历集合元素，放在Iterator.java中测试
Iterator iterator=coll.iterator（）；
System.out.println(iterator.next（）);

while（iterator.hasNext（））{
System.out.println(iterator.next（）);
}

集合元素的遍历操作，使用迭代器Iterator接口
内部的方法：hasNext（）和next（）
集合对象每次调用iterator（）方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
内部定义了remove（），可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove（）

4.jdk5.0新增了foreach循环，用于遍历集合、数组
for（集合元素的类型 局部变量：集合对象）
内部仍然调用了迭代器
Collection coll=new ArrayList（）；
for（Object obj：coll）{
System.out.println(obj);
}

5.ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
Vector：作为List接口的古老实现类；线程安全，效率低；底层使用Object[] elementData存储

相同点：三个类都实现了List接口，存储数据的特点相同，都是存储有序、可重复的数据

6.void add(int index,Object ele):在index位置插入ele元素
boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index,Object ele):设置指定index位置的元素为ele
List sublist(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的集合

总结：常用方法
增：add(Object obj)
删：remove(int index)/remove(Object obj)
改：set(int index,Object ele)
查：get(int index)
插：add(int index,Object ele)
长度：size()
遍历：Iterator迭代器方式
增强for循环
普通for循环

for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}

7.HashSet:作为set接口的主要实现类；线程不安全；可以存储null值
LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
TreeSet：可以按照添加对象的指定属性，进行排序

Set：存储无序的、不可重复的数据
以HashSet为例说明：
无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值添加
不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一次

添加元素的过程：以HashSet为例：
我们向HashSet中添加元素a，首先调用元素a所在类的hashCode（）方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为索引位置），判断数组此位置上是否已有元素
如果此位置上没有其他元素，则元素a添加成功
如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a和元素b的hash值
如果hash值不相同，则元素a添加成功
如果hash值相同，进而需要调用元素a所在类的equals（）方法
equals（）返回true，元素a添加失败
equals（）返回false，元素a添加成功

对于添加成功的情况而言，元素a与已经存在指定索引位置上数据以链表方式存储
jdk7：元素a放到数组中，指向原来的元素
jdk8：原来的元素在数组中，指向元素a
总结：七上八下

Set接口中没有额外定义新的方法，使用的都是Collection中声明过多的方法
要求：向Set中添加的数据，其所在类一定要重写hashCode（）和equals（）
重写的hashCode（）和equals（）尽可能保持一致性：相等的对象必须具有相等的散列码
重写两个方法的小技巧：对象中用作equals（）方法比较的Field，都应该用来计算hashCode值。

8.Map：双列数据，存储key-value对的数据，类似于函数
HashMap：作为Map类的主要实现类，线程不安全，效率高，存储null的key和value
LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序遍历
原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap
TreeMap：保证按照添加的key-value进行排序，实现排序遍历。此时考虑key的自然排序或定制排序，底层使用红黑树
Hashtable：作为古老的实现类，线程安全，效率低，不能存储null的key和value
Properties：常用来处理配置文件，key和value都是String类型

HashMap底层：数组+链表（jdk7及以前）
数组+链表+红黑树（jdk8）

9.Map结构的理解：
Map中的key：无序的、不可重复的，使用set存储所有的key——>key所在的类要重写equals（）和hashCode（）（HashMap为例）
Map中的value：无序的、可重复的，使用Collection存储所有的value——>value所在类要重写equals（）
一个键值对：key-value构成了一个Entry对象
Map中的entry：无序的、不可重复的，使用Set存储所有的entry

10.Map中定义的方法：
添加、删除、修改操作：
Object put（Object key，Object value）：将指定的key-value添加到（或修改）当前map对象中
void putAll（Map m）：将m中所有key-value对存放到当前map中
Object remove（Object key）：移除指定key的key-value对，并返回true
void clear（）：清空当前map中所有数据

元素查询操作：
Object get（Object key）：获取指定key对应的value
boolean containsKey（Object key）：是否包含指定的key
boolean containsValue（Object value）：是否包含指定的value
int size（）：返回map中key-value对的个数
boolean isEmpty（）：判断map是否为空
boolean equals（Object obj）：判断当前map和参数对象obj是否相等

元视图操作方法：
Set KeySet（）：返回所有key构成的set集合
Collection values（）：返回所有value构成的Collection集合
Set entrySet（）：返回所有key-value对构成的Set集合

总结：常用方法：
添加：put（Object key，Object value）
删除：remove（Object key）
修改：put（Object key，Object value）
查询：get（Object key）
长度：size（）
遍历：keySet（）/values（）/entrySet（）

Map map=new HashMap（）；
//遍历所有的key集：KeySet（）
Set set=map.KeySet（）；
Iterator iterator=set.iterator（）；
while（iterator.hasNext（））{
System.out.println（iterator.next（））；
}

//遍历所有的value集：values（）
Collection values=map.values（）；
for（Object obj：values）{
System.out.println（obj）；
}

//遍历所有的key-value
方式一：entrySet（）
Set entrySet=map.entrySet（）；
Iterator iterator1=entrySet.iterator（）；
while（iterator1.hasNext（））{
Object obj=iterator1.next（）；
Map.Entry entry=（Map.Entry）obj；
System.out.println（entry.getKey（）+"——>"+entry.getValue（））；
}

方式二：
Set set=map.KeySet（）；
Iterator iterator2=set.iterator（）；
while（iterator2.hasNext（））{
Object key=iterator2.next（）；
Object value=map.get（key）；
System.out.println（key+"===="+value）；
}