文章目录
- 一：集合框架概述
- 二：Collection接口：单列接口，用来存储一个一个的对象
- 1.Collection常用方法
- 2.集合的遍历
- 方式一：迭代器
- 方式二：foreach
- 方式三：Lambda表达式
- 3.list接口：存储有序的、可重复的数据。--->“动态”数组
- 3.1 ArrayList
- 3.2 LinkedList
- 3.3 Vector
- 3.4 List常用方法及遍历
- 4.Set接口：存储无序的、不可重复的数据。--->高中讲的“集合”
- 4.1 HashSet
- 4.2 LinkedHashSet
- 4.3 TreeSet
- 4.4 关于HashSet底层结构的一个小练习
- 三：Map接口：双列接口，用来存储一对（key-value）的数据--->高中函数：y=f(x),x相当于key，y相当于value
- 1.HashMap
- 2.LinkedHashMap
- 3.TreeMap
- 4.Map的常用方法及遍历
- 四：Collections
一：集合框架概述
集合、数组都是对多个数据进行存储操作的结构，简称Java容器
说明：此时的存储，主要指的是内存层的面的存储，不涉及到持久化的存储（.txt，.jpg，.avi，数据库中存储）
集合框架：
Collection接口：单列接口，用来存储一个一个的对象
list接口：存储有序的、可重复的数据。—>“动态”数组
ArrayList、LinkedList、Vector
Set接口：存储无序的、不可重复的数据。—>高中讲的“集合”
HashSet、LinkedHashList、TreeSet
Map接口：双列接口，用来存储一对（key-value）的数据—>高中函数：y=f(x),x相当于key，y相当于value
HashMap、LinkedList、TreeMap、Hashtable、Properties
二：Collection接口：单列接口，用来存储一个一个的对象
1.Collection常用方法
add（object e）：将e添加进集合中
size():获取添加元素的个数
addAll（Collection coll1）：将coll1添加进集合coll中、
clear():删除集合中所有元素
contains(Object obj):判断当前集合中是否包含obj，此方法在判断时会调用obj所在类的equals()
containsAll(Collection coll1):判断参数集合是否去全部存在于当前集合中
remove(Object obj):从当前集合移除一个数据，成功返回true，失败返回false
removeAll(Collection coll1):（把当前集合修改了）从当前集合移除全部coll1中的元素(移除交集)
retainAll(Collection coll1)：求交集，（把当前集合修改了）
equals(Object obj):判断两个集合是否完全相等
hasCode():返回当前对象的哈希值
toArray():集合转换为数组
//拓展：数组-->集合 调用Arrays类的静态方法asList()
List<Object> objects = Arrays.asList(array);
System.out.println(objects);
List<int[]> ints = Arrays.asList(new int[]{123, 456});
System.out.println(ints);//识别为一个元素
System.out.println(ints.size());//1
List ints1 = Arrays.asList(new Integer[]{123, 456});
System.out.println(ints1.size());//2iterator():返回Iterator接口的实例，用于遍历集合元素
2.集合的遍历
方式一：迭代器
集合元素的遍历操作,使用迭代器Iterator接口
hasnext() 与next()混合使用
每次用集合调用iterator()都会得到一个全新的迭代器对象，默认游标都在第一个元素之前。
public class IteratorTest {
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add("aa");
coll.add("bb");
coll.add(123);
coll.add(new Date());
Iterator iterator = coll.iterator();
//方式一：
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
//异常：NoSuchElementException
// System.out.println(iterator.next());
//方式二：不推荐
// for (int i = 0; i < coll.size(); i++) {
// System.out.println(iterator.next());
// }
//方式三：推荐
//hasNext()：判断是否还有下一个元素
while (iterator.hasNext()){
//next()：①指针下移②将下移后集合位置上的元素返回
System.out.println(iterator.next());
}
}
}方式二：foreach
jdk5.0新增了foreach，用于遍历集合和数组。
public class ForTest {
@Test
public void test1() {
Collection coll = new ArrayList();
coll.add("aa");
coll.add("bb");
coll.add(123);
coll.add(new Date());
//for(集合元素的类型 局部变量名：集合对象)
//内部仍然调用了迭代器
for (Object object : coll) {
System.out.println(object);
}
}
@Test
public void test2() {
int[] arr = new int[]{1, 2, 3, 4, 5};
for (int i : arr) {
System.out.println(i);
}
}
@Test
public void test3() {
String[] arr = new String[]{"gg", "gg", "gg"};
//方式一：普通for循环赋值，原数组改变
// for (int i = 0; i < arr.length; i++) {
// arr[i] = "mm";
// }
//方式二：foreach循环赋值，取arr中每一个赋值给String s，对s赋值，原数组不改变
for (String s : arr
) {
s = "mm";
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}方式三：Lambda表达式
list.forEach(s -> System.out.println(s));3.list接口：存储有序的、可重复的数据。—>“动态”数组
list接口：存储有序的、可重复的数据。—>“动态”数组
ArrayList：作为List接口的主要实现类，线程不安全的，执行效率高，底层使用Object[] elementData存储
LinkedList：对于频繁的插入、删除操作，此类效率比ArrayList高，底层使用双向链表存储
Vector：作为List接口的古老实现类，线程安全的，执行效率低，底层使用Object[] elementData存储
3.1 ArrayList
ArrayList：作为List接口的主要实现类，线程不安全的，执行效率高，底层使用Object[] elementData存储。
ArrayList源码分析：
jdk7：
* ArrayList list = new ArrayList();//底层创建一个Object类型的数组，长度为10
* list.add(123);//elementData[0]=new Integer(123);
* ...
* list.add(11)//如果此次添加导致底层elementData数组容量不够，则扩容。
* 默认情况下，扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
* 结论：建议开发中使用带参的构造器ArrayList list = new ArrayList(int Capacity)，避免扩容提高效率
jdk8中ArrayList的变化：
* ArrayList list = new ArrayList();//底层Object类型的数组 elementData初始化为{}，并没有创建长度为10的数组
* add.（123）//第一次调用add()时，底层才创建长度为10的数组，并添加第一个数据
* ...
* 后续添加与扩容与jdk7无异。小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，jdk中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节约内存。
3.2 LinkedList
LinkedList：对于频繁的插入、删除操作，此类效率比ArrayList高，底层使用双向链表存储。
LinkedList源码分析：
LinkedList list = new LinkedList()//内部声明了Node类型的first和last属性，默认值为null
list.add(123)//将123封装到Node中，创建了Node对象。3.3 Vector
作为List接口的古老实现类，线程安全的，执行效率低，底层使用Object[] elementData存储。
Vector源码分析：底层创建一个Object类型的数组，长度为10，默认情况下，扩容为原来的2倍。
面试题：ArrayList、LinkedList、Vector三者的异同？
同：都实现的List接口，存储数据的特点相同：存储有序的、可重复的数据。
3.4 List常用方法及遍历
public class ListTest {
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("aaa");
list.add("bbb");
System.out.println(list);
//add(int index,Object element):在index位置插入element
list.add(1,"charu");
//addAll(int index,Collection c):在index位置插入集合
//get(int index):返回index的元素
//indexOf(Object o)、lastindexOf(Object o):返回o在集合第一次(最后一次)出现的位置，不存在返回-1
//remove(int index)：删除指定index位置的元素并返回此元素
//set(int index,Object ele):设置index位置的元素为ele
//subList(int fromIndex，int toIndex)：返回从fromIndex到toIndex位置的子集合（左闭右开）
}
//遍历：
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("aaa");
list.add("bbb");
//方式一：iterator方式遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("******************");
//方式二：for、foreach方式遍历
for (Object o:list
) {
System.out.println(o);
}
System.out.println("******************");
//方式三：lambda表达式
list.forEach(s -> System.out.println(s+"lambda"));
}
}4.Set接口：存储无序的、不可重复的数据。—>高中讲的“集合”
Set接口：存储无序的、不可重复的数据。—>高中讲的“集合”
HashSet：作为Set接口的主要实现类，线程不安全的，可以储存null值
LinkedHashList：作为HashSet的子类；遍历其内部顺序时，可以按照添加的顺序去遍历作为HashSet的子类；遍历其内部顺序时，可以按照添加的顺序去遍历，对于频繁的遍历操作，LinkedHashSet高于HashSet
TreeSet：可以按照添加对象的指定属性，进行排序。
要求：
向Set中添加数据的类一定要重写hashCode()和equals()方法，
重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。
4.1 HashSet
HashSet底层：数组+链表
一：Set：存储无序的、不可重复的数据
以HashSet为例说明：
1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的
2.不可重复性：保证添加的元素按照equals()判断时，不能返回true，即相同的元素只能添加一个。
二：添加元素的过程：以HashSet为例说明：
向HashSet中添加元素a，首先调用元素a所在类的hashcode()方法，计算元素a的哈希值，此哈希值通过某种算法
计算出在HashSet底层数组中的存放位置（即为索引位置），判断数组此位置上是否已经有元素：
如果此位置上没有其他元素，直接把a放进去
如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与b的哈希值：
如果哈希值不同，则元素a添加成功（jdk7以链表的方式接在b后面，jdk7把b挤走放在b的位置）（jdk7上jdk8下）
如果哈希值相同，进而需要调用a所在类的equals()方法：
equals()返回true，元素a添加失败。
equals()返回false，元素a添加成功。
@Test
public void test1(){
Set set = new HashSet();
set.add(456);
set.add(123);
set.add("aa");
set.add("bb");
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}4.2 LinkedHashSet
LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个和后一个数据。
优点：对于频繁的遍历操作，LinkedHashSet高于HashSet。
@Test
public void test2(){
Set set = new LinkedHashSet();
set.add(456);
set.add(123);
set.add("aa");
set.add("bb");
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}4.3 TreeSet
1.向TreeSet中添加的数据，必须是相同类的对象
2.两种排序方式：自然排序(集合中存的类实现Comparable接口)，定制排序（Comparator）(常用类中讲过)
添加数据的所属类实现一个Comparable接口，重写compareTo()方法
3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()
4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals()
public class TreeSetTest{
//自然排序
@Test
public void test1(){
TreeSet set = new TreeSet();
set.add(456);
set.add(123);
set.add(-534);
set.add(55);
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
//定制排序
@Test
public void test2(){
Comparator comparator = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return 0;
}
};
TreeSet set = new TreeSet(comparator);
}
}4.4 关于HashSet底层结构的一个小练习
public class SetJingdian {
@Test
public void test1() {
HashSet set = new HashSet();
Person p1 = new Person(1001, "AA");
Person p2 = new Person(1002, "BB");
//Person类有id，name两个属性并提供构造方法，toString()以及equals()、hashCode()
set.add(p1);
set.add(p2);
System.out.println(set);//2个
p1.name = "CC";
set.remove(p1);//移除1001CC计算出hash值的位置的p1，移除失败
System.out.println(set);//2个
set.add(new Person(1001, "CC"));//1001CC的哈希值位置上为空，不比equals，添加成功
System.out.println(set);//3个
set.add(new Person(1001, "AA"));//1001AA哈希值位置上有一个修改过的1001CC，比较equals不同，添加成功
System.out.println(set);//4个
}
}三：Map接口：双列接口，用来存储一对（key-value）的数据—>高中函数：y=f(x),x相当于key，y相当于value
Map概述：
Map：双列数据，存储key-value对的数据—类似于高中函数 y=f（x）
HashMap：作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value
LinkedHashMap：保证在遍历map元素时，可以按照添加顺序去遍历
原因：在原有HashMap底层结构基础上，添加了一对指针，指向前一个和后一个键值对,对于频繁的遍历操作，此类执行效率高于HashMap
TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。（key的自然排序和定制排序）底层使用红黑树。
Hashtable：作为古老的实现类；线程安全的，效率低；不能存储null的key和value
Properties：常用来处理配置文件。key和value都是String类型
Map的结构理解:
Map中的key：无序的、不可重复的，使用Set存储所有key —>hashMap中，key所在的类要重写equals()和hashCode()
Map中的value：无序的、不可重复的，使用Collection存储所有value —>value所在的类要重写equals()
一个键值对中：key-value构成一个Entry对象
Map中的Entry：无序的、不可重复的，使用Set存储所有Entry
1.HashMap
HashMap底层：数组+链表（jdk7之前）
数组+链表+红黑树（jdk8）
HashMap的底层实现原理：
HashMap的底层实现原理?以jdk7为例说明
* HashMap map = new HashMap();
* 实例化后，底层创建一个长度为16的一维数组Entry[] table
* ...多个put后...
* map.put(key1,value1)；
* 首先，调用key1所在类的hashCode()计算key1的哈希值，此哈希值经过某种算法后，得到在Entry数组中的存放位置。
* 如果此位置上数据为空，此时Entry（key1-value1）添加成功。
* 如果此位置上数据不为空，(意味着此位置上存在一个或多个(以链表形式存在)数据)，比较key1和已经存在的一个或多个数据的哈希值：
* 如果key1的哈希值与已经存在的数据的哈希值都不同，此时Entry（key1-value1）添加成功
* 如果key1的哈希值与已经存在的某个数据的哈希值相同，继续比较key1的equals()方法，比较：
* 如果equals()返回false：此时Entry（key1-value1）添加成功
* 如果equals()返回true：使用value1替换原有的value
*
* ☆在不断添加过程中，会涉及扩容问题，占用超过12个时，默认扩容为原来容量的2倍，并将原有数据复制过来
*
* jdk8相较于jdk7在底层实现方面的不同：
* 1.new HashMap()时底层没有创建一个长度为16的数组
* 2.jdk8底层的数组是：Node[]，而非Entry[]
* 3.首次调用put()方法时，底层创建长度为16的数组
* 4.jdk7底层只有数组+链表；jdk8中底层数组+链表+红黑树。当数组的后一个索引位置上的元素以链表形式存在的数据个数>8且当前数组长度>64，
* 此时此索引位置上的所有数据改为使用红黑树存储。2.LinkedHashMap
LinkedHashMap：保证在遍历map元素时，可以按照添加顺序去遍历
原因：在原有HashMap底层结构基础上，添加了一对指针，指向前一个和后一个键值对对于频繁的遍历操作，此类执行效率高于HashMap3.TreeMap
- 向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
- 因为要按照key进行排序：自然排序、定制排序
4.Map的常用方法及遍历
Map中定义的方法：
- 添加：put（）
- 删除：remove（）
- 修改：put()
- 查询：get()
- 长度：size()
- 遍历：keySet()、values()、entrySet()
public class MapTest {
@Test
public void test1(){
Map map = new HashMap();
map.put("AA",123);
map.put("BB",5634);
map.put("CC",999);
//与上一个key“AA”相同，替换value
map.put("AA",456);
System.out.println(map);
Map map1 = new HashMap();
map1.put("DD",5634);
map1.put("EE",999);
map.putAll(map1);
Object cc = map.remove("CC");//返回value
System.out.println(cc);
map.clear();
System.out.println(map.size());
//遍历所有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 o:values
) {
System.out.println(o);
}
//遍历所有key-values:entrySet()
Set set1 = map.entrySet();
Iterator iterator1 = set1.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
Map.Entry entry = (Map.Entry)obj;
System.out.println(entry.getKey()+"-->"+entry.getValue());
}
//方法二：
Set set2 = map.keySet();
Iterator iterator2 = set2.iterator();
while (iterator2.hasNext()){
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key+"------"+value);
}
}
}四：Collections
Collections:操作Collection、Map的工具类
面试题：Collection和Collections的区别？
Collections是操作Collection、Map的工具类
Collection是创建集合的接口，包括list和set常用方法：
- 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/min(Collection)
- Object max/min(Collection，Comparator)
- int frequency(Collection,Object):返回指定集合中指定元素的出现次数
- void copy(List dest，List src):将src中的内容复制到dest中(易错，如下代码)
- boolean replaceAll(List list，Object oldVal，Object newVal)：
- synchronizedList(List list)：将list改为线程安全的
说明：
在使用copy方法时需注意：dest的size()，也就是dest中存的元素个数要不小于list中的元素个数才能复制
public class CollectionsTest {
@Test
public void test1(){
List list = new ArrayList();
list.add(123);
list.add(-9);
list.add(7);
list.add(96);
//java.lang.IndexOutOfBoundsException: Source does not fit in dest
//ArrayList dest = new ArrayList();
//Collections.copy(dest,list);
//dest的size()，也就是dest中存的元素个数要不小于list中的元素个数才能复制
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size());
Collections.copy(dest,list);
System.out.println(dest);
}
}
