java基础之集合框架

集合框架

1.集合框架的体系结构
答: 集合框架–jdk提供的对集中合并数据进行统一管理/处理的开发类库。
交由集合统一管理/处理的数据有两种表现形式:单例数据与键值对数据。

2. Conllection与Map
答:

3. List与Set
答:list接口处理有顺序的单列数据。
List接口可以有重复的数据元素,按照顺序区分。
List接口下有ArrayList类和LinkedList类。
Set接口处理没有顺序的单列数据。
Set接口不能有重复的数据元素(重复的数据元素被视为同一个)。
Set接口下有HashSet类和LinkedHashSet类。

4.ArrayList与LinkedList
答:ArrayList处理有顺序的单列数据、保存数据的存储空间会自动扩展(注意与数组区别)、可以保存任意数据类型数据(注意与数组区别)、数据存储结构是动态数组结构(优:查询快,缺:添加和删除慢)。
ArrayList() 构造一个初始容量为10的空列表。
ArrayList(Collection c) 将实现Collection接口的集合类转换成ArrayList
ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。

package com.click369.jihe;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestList {
	public static void main(String[] args) {
		// ArrayList() 构造一个初始容量为10的空列表。
		ArrayList al1 = new ArrayList();
		// ArrayList(Collection c) 将实现Collection接口的集合类转换成ArrayList
		ArrayList al2 = new ArrayList(al1);
		// ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
		ArrayList al3 = new ArrayList(30);

		List lt1 = new ArrayList();
		List lt2 = new ArrayList(lt1);
		List lt3 = new ArrayList(40);

		Collection cl1 = new ArrayList();
		Collection cl2 = new ArrayList(cl1);
		Collection cl3 = new ArrayList(50);
	}
}

实例方法
add(E e) 将指定的元素追加到此列表的末尾。
clear() 从列表中删除所有元素。
contains(Object o) 如果此列表包含指定的元素，则返回 true 。
get(int index) 返回此列表中指定位置的元素。
indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
isEmpty() 如果此列表不包含元素，则返回 true 。
remove(int index) 删除该列表中指定位置的元素。
remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
size() 返回此列表中的元素数。
toArray()以正确的顺序(从第一个到最后一个元素)返回一个包含此列表中所有元素的数组。
例如：

package com.click369.test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestMain {
	public static void main(String[] args) {
		//ArrayList中的实例方法
		ArrayList list1=new ArrayList();
		//1.add(E e) 将指定的元素追加到此列表的末尾。
		list1.add("hello");
		list1.add(true);
		list1.add(12.5);
		list1.add("hello");
		//2.size() 返回此列表中的元素数。
		System.out.println("list1的元素数="+list1.size());
		//3.clear() 从列表中删除所有元素。[清空]
		//list1.clear();
		//System.out.println("list1的元素数="+list1.size());
		//4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
		System.out.println("判断hello元素是否在list1这个集合中=="+list1.contains("hello1"));
		//5.get(int index) 返回此列表中指定位置的元素。
		//System.out.println("get(5)=="+list1.get(5));
		//6.indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
		System.out.println("hello元素在list1中第一次出现的位置=="+list1.indexOf("hello"));
		//7.lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
		System.out.println("hello元素在list1中最后一次出现的位置=="+list1.lastIndexOf("hello"));
		//8.isEmpty() 如果此列表不包含元素，则返回 true 。
		//list1.clear();
		//System.out.println("list1集合是否为空="+list1.isEmpty());
		//9.remove(int index) 删除该列表中指定位置的元素。 
		//list1.remove(2);
		//System.out.println("list1的元素数="+list1.size());
		//10.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		//list1.remove("hello");
		//System.out.println("list1的元素数="+list1.size());
		//System.out.println("get(0)=="+list1.get(0));
		//11.set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
		list1.set(0,"world");
		System.out.println("get(0)=="+list1.get(0));
		//12.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
		Object[] objs=list1.toArray();
	}
}

Iterator iterator() 以正确的顺序返回该列表中的元素的迭代器接口。【遍历ArrayList中的数据元素】
ArrayList集合的遍历
例如：

package com.click369.test;
import java.util.ArrayList;
import java.util.Iterator;
public class TestMain {
	public static void main(String[] args) {
		//ArrayList集合的遍历
		ArrayList  list=new ArrayList();
		list.add("hello");
		list.add(1001);
		list.add("world");
		list.add(true);
		list.add(12.5);
		//1.通过普通的for循环遍历ArrayList集合
		for(int i=0;i<list.size();i++){
			System.out.println("list---"+list.get(i));
		}
		//2、使用增强的for循环
		for(Object obj:list){
			System.out.println("obj---"+obj);
		}
		//3.使用Iterator  iterator()迭代器
		Iterator it=list.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			System.out.println("Iterator---"+obj);
		}
	}
}

LinkedList类
1.处理有顺序的单列数据
2.保存数据的存储空间，会自动扩展(注意与数组的区别)
3.可以保存任意数据类型的数据(注意与数组的区别)
4.数据存储结构是链表(火车)结构(优势：添加/删除速度快 缺点：查询速度慢)
构造方法：
LinkedList() 构造一个空列表。
LinkedList(Collection c) 将实现Collection接口的集合类转换成LinkedList
例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
public class TestMain {
	public static void main(String[] args) {
		//测试LinkedList的构造方法--创建对象
		//LinkedList() 构造一个空列表。
		LinkedList  list1=new LinkedList();
		//LinkedList(Collection c) 将实现Collection接口的集合类转换成LinkedList
		ArrayList  alist=new ArrayList();
		LinkedList  list2=new LinkedList(alist);
		//可以利用List接口
		List  list11=new LinkedList();
		List  list22=new LinkedList(list11);
		//可以利用Collection接口
		Collection  list111=new LinkedList();
		Collection  list222=new LinkedList(list111);
	}
}

实例方法与ArrayList一样：
add(E e) 将指定的元素追加到此列表的末尾。
clear() 从列表中删除所有元素。
contains(Object o) 如果此列表包含指定的元素，则返回 true 。
get(int index) 返回此列表中指定位置的元素。
indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
isEmpty() 如果此列表不包含元素，则返回 true 。
remove(int index) 删除该列表中指定位置的元素。
remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
size() 返回此列表中的元素数。
toArray()以正确的顺序从第一个到最后一个元素,返回一个包含此列表中所有元素的数组。

LinkedList类提供了一组针对第一个元素和最后一个元素的操作方法：
addFirst(E e) 在该列表开头插入指定的元素。
addLast(E e) 将指定的元素追加到此列表的末尾
getFirst() 返回此列表中的第一个元素。
getLast() 返回此列表中的最后一个元素。
removeFirst() 从此列表中删除并返回第一个元素。
removeLast() 从此列表中删除并返回最后一个元素。
因为LinkedList类的数据存储结构是链表(火车)结构。
例如：

package com.click369.test2;
import java.util.LinkedList;
public class TestMain {
	public static void main(String[] args) {
		//LinkedList中的实例方法
		LinkedList list1=new LinkedList();
		//1.add(E e) 将指定的元素追加到此列表的末尾。
		list1.add("hello");
		list1.add(true);
		list1.add(12.5);
		list1.add("hello");
		//2.size() 返回此列表中的元素数。
		//System.out.println("list1的元素数="+list1.size());
		//3.clear() 从列表中删除所有元素。[清空]
		//list1.clear();
		//System.out.println("list1的元素数="+list1.size());
		//4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
		//System.out.println("判断hello元素是否在list1这个集合中=="+list1.contains("hello"));
		//5.get(int index) 返回此列表中指定位置的元素。
		//System.out.println("get(2)=="+list1.get(2));
		//6.indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
		//System.out.println("hello元素在list1中第一次出现的位置=="+list1.indexOf("hello"));
		//7.lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
		//System.out.println("hello元素在list1中最后一次出现的位置=="+list1.lastIndexOf("hello"));
		//8.isEmpty() 如果此列表不包含元素，则返回 true 。
		//list1.clear();
		//System.out.println("list1集合是否为空="+list1.isEmpty());
		//9.remove(int index) 删除该列表中指定位置的元素。 
		//list1.remove(2);
		//System.out.println("list1的元素数="+list1.size());
		//10.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		//list1.remove("hello");
		//System.out.println("list1的元素数="+list1.size());
		//System.out.println("get(0)=="+list1.get(0));
		//11.set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
		//list1.set(0,"world");
		//System.out.println("get(0)=="+list1.get(0));
		//12.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
		//Object[] objs=list1.toArray();
		
		//LinkedList类提供了一组针对第一个元素和最后一个元素的操作方法：
		//addFirst(E e) 在该列表开头插入指定的元素。
		//addLast(E e) 将指定的元素追加到此列表的末尾
		//getFirst() 返回此列表中的第一个元素。 
		//getLast() 返回此列表中的最后一个元素。
		//removeFirst() 从此列表中删除并返回第一个元素。
		//removeLast() 从此列表中删除并返回最后一个元素。
		//因为LinkedList类的数据存储结构是链表【火车】结构
	}
}

LinkedList集合的遍历

package com.click369.test3;
import java.util.Iterator;
import java.util.LinkedList;
public class TestMain {
	public static void main(String[] args) {
		//LinkedList集合的遍历
		LinkedList  list=new LinkedList();
		list.add("hello");
		list.add(1001);
		list.add("world");
		list.add(true);
		list.add(12.5);
		//1.通过普通的for循环遍历ArrayList集合
		for(int i=0;i<list.size();i++){
			System.out.println("list---"+list.get(i));
		}
		//2、使用增强的for循环
		for(Object obj:list){
			System.out.println("obj---"+obj);
		}
		//3.使用Iterator  iterator()迭代器
		Iterator it=list.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			System.out.println("Iterator---"+obj);
		}
	}
}

5.HashSet与LinkedHashSet
HashSet:
1.处理的是没有顺序的单列数据(重复的元素算一个)。
2.保存数据的存储空间，会自动扩展。
3.可以保存任意数据类型的数据。
构造方法：
HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
HashSet(Collection c)将实现Collection 接口的集合类转换成HashSet
HashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。
HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子
例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
public class TestMain {
	public static void main(String[] args) {
		//测试HashSet的构造方法--创建对象
		//HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
		HashSet set1=new HashSet();
		//HashSet(Collection c)将实现Collection 接口的集合类转换成HashSet
		ArrayList list=new ArrayList();
		HashSet	set2=new HashSet(list);	
		//HashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。 
		HashSet set3=new HashSet(10);
		//HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子
		HashSet set4=new HashSet(10,0.5f);
		//可以使用Set接口
		Set set11=new  HashSet();
		Set set22=new  HashSet(list);
		Set set33=new  HashSet(30);
		Set set44=new  HashSet(40,0.5f);
		//可以使用Collection接口
		Collection set111=new  HashSet();
		Collection set222=new  HashSet(list);
		Collection set333=new  HashSet(30);
		Collection set444=new  HashSet(40,0.5f);
	}
}

实例方法：
add(E e) 将指定的元素添加到此集合。
clear() 从此集合中删除所有元素。
contains(Object o) 如果此集合包含指定的元素，则返回 true 。
isEmpty() 如果此集合不包含元素，则返回 true 。
remove(Object o) 如果存在，则从该集合中删除指定的元素。
size() 返回此集合中的元素数。
toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
例如：

package com.click369.test2;
import java.util.HashSet;
public class TestMain {
public static void main(String[] args) {
		//HashSet中的实例方法
		HashSet set1=new HashSet();
		//1.add(E e) 将指定的元素追加到此列表的末尾。
		set1.add("hello");
		set1.add(true);
		set1.add(12.5);
		set1.add("hello");
		//2.size() 返回此列表中的元素数。
		//System.out.println("set1的元素数="+set1.size());
		//3.clear() 从列表中删除所有元素。[清空]
		//set1.clear();
		//System.out.println("set1的元素数="+set1.size());
		//4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
		System.out.println("判断hello元素是否在set1这个集合中=="+set1.contains("hello"));
		//5.isEmpty() 如果此列表不包含元素，则返回 true 。
		//set1.clear();
		//System.out.println("set1集合是否为空="+set1.isEmpty());
		//6.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		set1.remove("hello");
		System.out.println("set1的元素数="+set1.size());
		//7.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
		Object[] objs=set1.toArray();
	}
}

HashSet集合的遍历

package com.click369.test3;
import java.util.HashSet;
import java.util.Iterator;
public class TestMain {
	public static void main(String[] args) {
		//HashSet集合的遍历
		HashSet  set=new HashSet();
		set.add("hello");
		set.add(1001);
		set.add("world");
		set.add(true);
		set.add(12.5);
		//1、使用增强的for循环
		for(Object obj:set){
			System.out.println("obj---"+obj);
		}
		//2.使用Iterator  iterator()迭代器
		Iterator it=set.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			System.out.println("Iterator---"+obj);
		}
	}
}

LinkedHashSet类
定义结构：
public class LinkedHashSet
extends HashSet
implements Set,
LinkedHashSet是HashSet类的子类
只要会使用HashSet，那么就一定会使用LinkedHashSet。
构造方法：
LinkedHashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
LinkedHashSet(Collection c)将实现Collection 接口的集合类转换成LinkedHashSet
LinkedHashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。
LinkedHashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的
实例方法：
add(E e) 将指定的元素添加到此集合。
clear() 从此集合中删除所有元素。
contains(Object o) 如果此集合包含指定的元素，则返回 true 。
isEmpty() 如果此集合不包含元素，则返回 true 。
remove(Object o) 如果存在，则从该集合中删除指定的元素。
size() 返回此集合中的元素数。
iterator() 返回此集合中元素的迭代器。

6.HashMap与Hashtable与TreeMap与ConcurrentHashMap
答:
HashMap是应用更加广泛的哈希表实现，行为上大致上与Hashtable一致，主要区别在于HashMap不是同步的，支持null键和值等。通常情况下，HashMap进行put或者get操作，可以达到常数时间的性能，所以它是绝大部分利用键值对存取场景的首选，比如，实现一个用户ID和用户信息对应的运行时存储结构。

Hashtable是早期Java类库提供的一个哈希表实现，本身是同步的，不支持null键和值，由于同步导致的性能开销，所以已经很少被推荐使用。Hashtable使用Synchronized同步锁修饰了put、get、remove等方法，因此在高并发场景下，读写操作都会存在大量锁竞争，给系统带来性能开销。

TreeMap则是基于红黑树的一种提供顺序访问的Map，和HashMap不同，它的get、put、remove之类操作都是O（log(n)）的时间复杂度，具体顺序可以由指定的Comparator来决定，或者根据键的自然顺序来判断。

ConcurrentHashMap在保证线程安全的基础上兼具了更好的并发性能。在JDK1.7中，ConcurrentHashMap就使用了分段锁Segment减小了锁粒度，最终优化了锁的并发操作。在JDK1.8中，ConcurrentHashMap做了大量的改动，摒弃了Segment的概念。由于Synchronized锁在Java6之后的性能已经得到了很大的提升，所以在JDK1.8中，Java重新启用了Synchronized同步锁，通过Synchronized实现HashEntry作为锁粒度。这种改动将数据结构变得更加简单了，操作也更加清晰流畅。与JDK1.7的put方法一样，JDK1.8在添加元素时，在没有哈希冲突的情况下，会使用CAS进行添加元素操作；如果有冲突，则通过Synchronized将链表锁定，再执行接下来的操作。

7.Conllection与Conllections
答: collection是一个接口，collections是一个操作集合的工具类
collection它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。

collections它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，用于对集合中元素进行排序、搜索以及线程安全等各种操作，服务于Java的Collection框架。