集合

集合框架的概述

集合、数组都是对多个数据进行存储的结构，简称Java容器（此处的存储不牵扯持久化存储(文件等))
数组在存储多个数据方面的特点：

一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素类型也就确定了，我们也就只能操作指定类型的数据了

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

集合可分为Collection和Map两种体系
Collection接口：单列数据，定义了存取一组对象的方法的集合
List:元素有序、可重复的集合
Set:元素无序、不可重复的即可
Map接口：双列数据，保存具有映射关系"key-value"对的集合

集合框架

|----Collection接口：单列集合，用来存储一个一个的对象
	|----List接口：存储有序的、可重复的数据。-->"动态"数组
		|----ArrayList、LinkedList、Vector
	|----set接口：存储无序的、不可重复的数据。
		|----HashSet、LinkedHashSet、TreeSet
|----Map接口：双列集合，用来存储一对(key-value)的数据
	|----HashMap、LinkedHashMap、TreeMap、HashTable、Properties

Collection接口中的方法

向Collection中添加对象时，该对象所在的类要重写equals()方法
add(Object e):将元素e添加到集合中
size():获取添加元素的个数
addAll(Collection coll1):添加coll1集合中的元素添加到当前的集合中
isEmpty():判断当前集合是否为空；
clear():清空集合元素
boolean contains(Object obj):是通过元素的equals方法来判断是否是同一个对象
boolean containsAll(Collection c):也是调用元素的equals方法来比较的，拿两个集合的元素挨个比较
boolean remove(Object obj):删除集合中的元素
boolean remove(Collection coll1):从当前集合中移除coll1中所有的元素
boolean retianAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
boolean equals(Object obj):判断当前解和和形参元素都相同
int hasCode():返回当前对象的哈希值
Object[] toArray():返回一个当前集合的数组

iterator():返回Iterator接口的实例，用于遍历集合的元素

拓展：数组转换为集合：
List<String> list = Arrays.asList(new String[]{"AAA","bb","cc"});

集合元素的遍历操作，使用迭代器Iterator接口

Collection接口继承了java.lang.lterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了lterator接口的对象。
lterator 仅用于遍历集合，lterator 本身并不提供承装对象的能力。如果需要创建lterator 对象，则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

boolean hasNext():判断是否还有下一个元素

T next():1、指针下移，2、将下移以后集合位置上的元素返回

boolean remove():移除当前元素，可以在遍历的时候删除集合中的元素，此方法不同于集合直接调用remove()
注意：如果还未调用next()或在上一次调用next方法后已经调用了remove方法，在调用remove都会报IllegalStateException

Iterator iterator = coll.iterator();
while(iter.hasNext()){
	System.out.println(iterator.next());
}

使用foreach循环遍历集合元素 jdk5.0新增用于遍历集合，数组

内部仍然调用迭代器

//for(集合元素的类型 局部变量:集合对象)
for（Object obj : coll){
System.out.println(obj);
}

	int arr = new int[1,2,3,4,5,6]；
	//for(数组元素的类型 局部变量 ：数组对象)
	for(iant i : arr){
		System.out.println(i);
	}

List接口

元素有序，且可重复，List容其中都对应一个整数型的序号记载其在容其中的位置，可以根据序号存取容器中的元素，常见的有ArrayList、LinkedList和Vector
ArrayList:作为List接口的主要实现类，线程不安全的，效率高，底层使用Object[]存储
LinkedList:对于频繁的插入、删除操作，使用此类效率比ArrayList高，底层使用双向链表存储
Vector:作为List接口的古老实现类，线程安全的，效率低

ArrayList的源码分析

jdk 7情况下

ArrayList list = new ArrayList();//底层创建了长度为10的Objectp[]书uElementData
list.add(123);//elementData[0] = new Integer(123);
...
List.add(11);//如果此次添加导致底层的elementData数组容量不够，则扩容。默认情况下，扩容为原来容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中

结论：建议开发中给你使用带参的构造器：ArrayuList list = new ArrayList(int capacity)
jdk 8的情况下：

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}，并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementDatap[0]中。
...
后续的添加和扩容操作与jdk7无异

小结：jdk7中的ArrayList的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存

LinkedList:源码分析

LinkedList linkedList = new LinkedList();//内部声明了Node类型的first和last属性,默认为null
list.add(123);//将123封装到Node中，创建了Node对象
双向链表
其中,Node定义为：
private static class Node<E>{
	E item;
	Node<E> next;
	Node<E> prev;
	Node(Node<E> prev,E element,Node<E> next){
		this.item = element;
		this.next = next;
		this.prev = prev;
	}
}

Vector源码分析

创建对象时，底层都创建了长度为10的数组，在扩容方面，默认扩容为原来的数组长度的2倍。

List接口方法

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到tolIndex位置的子集合
常用方法：
增：add(Object obj)
删：remove(int index)/remove(Object obj)
改：set(int index,Object ele)
查：get(int index)
插：add(int index,Object ele)
长度：size()
遍历：1.迭代器2.增强for3.普通for

Set接口

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

set接口中没有定义新的方法，使用的都是Collection中声明的方法
要求：向set中添加的数据，其所在的类一定要重写hashCode()和equals()重写的hashCode()尽可能保证一致性：相等的对象必须具有相等的散列码

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

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

HashSet底层：数组+链表的结构

LinkedHashSet使用

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据
优点：对于频发的遍历操作，LinkedHashSet效率高于HashSet

TreeSet

1、向TreeSet中添加数据，要求时相同的类的对象
2、两种排序方式：自然排序(实现Comparable接口)和定制排序 (Comparator)
3、自然排序中，比较两个对象是否相同的标准为：compareTo()返回0,不再是euqals().
4.定制排序中，比较两个对象是否相同的标准为:compare()返回0，不再是equals()

Map接口

|-----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）

1.HashMap的底层实现原理？
2.HashMap和Hashtable的异同
3.CurrentHashMap和Hashtable的异同

Map结构的理解：
Map中的key：无序的、不可重复的，使用Set存储的所有的key --->key所在的类要重写equals()和hasCode()方法以HashMap为例
Map中的value:无序的、可重复的，使用Collection存储所有的value ---->value所在的类要重写equals()
一个键值对：key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的，使用Set存储所有的entry

HashMap的底层实现原理

jdk7为例：
HashMap map = new HashMap();
在实例化以后，底层创建了长度是16的一维数组Entry[] table
...可能已经执行过多次put...
map.put(key1,value1):
首先调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置
如果此位置上的数据为空，此时的key1-value1添加成功-----情况一
如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功-----情况二
如果key1的哈希值与已经存在的某一个数据（key2-value2)的哈希值相同，继续比较：调用key1所在类的equals()方法：比较：
如果equals()返回false:此时key1-value1添加成功 -----情况三
如果equals()返回true:使用value1替换value2
关于情况2和情况三：此时key1-value1和原来的数据以链表的方式存储

在不断的添加中，会涉及到扩容问题，当超出临界值（且要存放的位置非空）时，扩容。默认的扩容方式：扩容为原来的2倍，并将原有的数据复制过来。

jdk8相较于jdk7在底层实现方面的不同：
1.new HashMap():底层没有创建一个长度为16的数组
2.jdk 8底层的数组是Node[]，而非Entry[]
3.首次调用put()方法是，底层创建长度为16的数组
5.jdk7底层结构只有：数组+链表。jdk8中底层的结构：数组+链表+红黑树
当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时此索引位置上的所有数据改为使用红黑树存储。
DEFAULT INITIAL CAPACITY : HashMap的默认容量，16
DEFAULT_LOAD_FACTOR: HashMap的默认加载因子: 0.75
threshold:扩容的临界值，=容量*填充因子:16 * 0.75 => 12
TREEIFY_THRESHOLD: Bucket中链表长度大于该默认值，转化为红黑树:8
MIN_TREEIFY_CAPACITY: 桶中的Node被树化时最小的hash表容量:64

LinkedHashMap的底层实现

源码中:
static class Entry<K, V> extends HashMap.Node<K, V> {
	Entry<K, V> before, after;//能够记录添加的元素的先后顺序
	Entry(int hash, K key, V value, Node<K, V> next) {
		super(hash, key, value, next);
	}
}

Map接口中定义的方法

添加、删除、修改操作：
Object put(Object kye,Object value):将指定key-value 添加到（或修改）当前map对象中
void putAll(Map m):将m中的所有的key-value对存放到当前map中
Object remove(Object key):移除指定key的key-value对，并返回value
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集合。

//遍历所有的key集合：keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext){
	System.out.println(itertor.next);
}
//遍历所有的value集合：values();
Collection  values = map.values();
for(Object obj :values){
	System.out.println(obj);
}
//遍历所有的key-value
//方式一：
Set entrySet = map.entrySet();
Iterator  iterator1 = enterySet.iterator();
while(itertor1.hasNext()){
	Object obj = iterator1.next();
	//entrySet集合中的元素都是Entry
	Map.Entry entry = (Map.Entry)obj;
	System.out.println(entry.getKey()+"---->"+entry.getValue());
}
//方式二：
Set keySet = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
	Object key = iterator.next();
	Object value = map.get(key);
	System.out.println(key+"====>"+value);
}

总结：
添加：put(Object key,Object value)
删除：remove(Object key)
修改：put(Object key,Object value)
查询：get(key)
长度：size()
遍历：keySet()/values()/entrySet()

TreeMap

向TreeMap中添加key-value,要求key必须是由同一个类创建的对象，因为要按照key进行排序：自然排序、定制排序

Properties

Properties 类是 Hashtable 的子类，该对象用于处理属性文件由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key和 value 都是字符串类型存取数据时，建议使用setProperty(String keyString value)方法和getProperty(String key)方法

Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.printIn(user);

Collections工具类

Collections是一个操作Set、List和Map等集合的工具类
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
排序操作: (均为static方法)

reverse(List): 反转 List 中元素的顺序

shuffle(List): 对 List 集合元素进行随机排序

sort(List): 根据元素的自然顺序对指定 List 集合元素按升序排序

sort(List，Comparator): 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序

swap(List，int， int):将指定 list 集合中的i处元素和处元素进行交换

查找、替换
Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection,Comparator): 根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection, Comparator)
int frequency(Collection，Object): 返回指定集合中指定元素的出现次数
void copy(List dest,List src): 将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal): 使用新值替换List 对象的所有旧值

Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题
例子：List list1 = Collections.synchronizedList(list);

posted @ 2023-05-16 15:52 生活的样子就该是那样阅读(25) 评论(0) 收藏举报

刷新页面返回顶部

把学习当作习惯

集合