Java集合框架的概述
前言：所谓集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储。
1.面向对象语言对事物的体现都是以对象的新式，为了方便对多个对象的操作，就要对对象进行存储。
2.使用Array存储对象方面具有一些弊端，而java集合就像一种容器，可以动态地把多个对象的引用放入容器中。
一、集合分类：
Collection接口继承树理解：
Collection接口 ：单列集合，用来存储一个一个对象
↓下子接口：
List接口：存储有序的、可重复的数据， 又称为“动态”数组。数组可以 称为静态。
ArrayList、LinkedList、Vector
set接口：存储无序的、不可重复的数据 称为：集合。
Hashset、LinkedHashset、TreeSet
Map接口：双列集合，用来存储一对（key - value） 对的数据。
HashMap、LinkedHashMap、TreeMap、Hashtable、properties
Collection接口中的方法使用说明
public class CollectionTest {
// Collection 接口中的使用方法
@Test
public void test() {
Collection coll = new ArrayList();
coll.add("AA");
coll.add("BB");
coll.add("CC");
coll.add(123);
coll.add(456);
coll.add(new Date());
System.out.println(coll.size());
Collection coll2 = new ArrayList();
coll2.add(456);
coll2.add("CC");
coll2.addAll(coll);
System.out.println(coll);
//clear():清空集合元素
coll.clear();
//isEmpty 判断当前集合是否为空
System.out.println(coll2.isEmpty());
}
-----------------------------------------------------
//返回当前对象的哈希值
System.out.println(coll.hashCode());
// 集合 --> 数组 toArry()
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
数组 --->集合:调用Arrays类的静态方法asList()
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);
二、Iterator迭代器接口
答：【 集合元素的遍历操作，使用迭代器Iterator接口 】
内部包含方法：hasNext()和next（）
使用Iterator接口遍历集合元素概念：
集合元素遍历方法一：
代码示例：取集合中的各个元素
Iterator iteraton = coll.iterator();
while (iteraton.hasNext()) {
System.out.println(iteraton.hasNext());
}
}
迭代器的执行原理理解：
@Test
public void test3() {
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String(“tom”));
coll.add(true);
Iterator iterator = coll.iterator();
while (iterator.hasNext()) {
Object obj = iterator.hasNext();
// 移除元素操作
if (“tom”.equals(obj)) {
iterator.remove();
}
}
}
}
集合元素遍历方法二：
public class fortest {
@Test
public void test1() {
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String(“tom”));
coll.add(true);
// for (集合元素的类型 局部变量：集合对象)
//内部仍然调用了迭代器
for (Object obj : coll) {
System.out.println(obj);
}
}
}
遍历数组方法
@Test
public void test2() {
int arr[] = new int[]{1, 2, 44, 33, 5, 6, 7, 8, 0};
// for(数组元素的类型 局部变量：数组对象)
for (int i : arr) {
System.out.println(i);
}
}
}
三、List接口概述
1.鉴定Java中数组用来存储数据的局限性，我们通常使用List替代数组。
2.List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
3.List容器中的元素都对应一个整数型的序号记载在容器中的位置，可以根据序号存取容器中的元素。
4.JDK API 中List接口的实现类长用的有：ArrayList、LinkedList和Vector。
面试题：
ArrayList、LinkedList、Vector 三者的异同？
相同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
不同点：ArrayList：作为List接口的主要实现类；线程不安全的，效率高。底层使用Object[ ] elementData存储。
LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
Vector ：作为List接口的古老实现类；线程安全的，效率低。底层使用Object [ ] elementData存储。
/**
* List 常用方法
- 增：add
- 删：romove
- 改：set
- 查：get
- 插：add
- 长度：size
- 遍历：1.Iterator迭代器方式
- 增强for循环
- 普通的循环
*/
public class ListTest {
@Test
public void test1() {
ArrayList list = new ArrayList();
list.add(“123”);
list.add(“456”);
list.add(“AA”);
list.add(“MM”);
list.add(“KK”);
// 方式一: Iterator迭代器方式
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("-----------------------------------");
// 方式二:增强for循环
for (Object obj : list) {
System.out.println(obj);
}
System.out.println("-----------------------------------");
// 方式三:普通for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
四、Set接口概述
1.Set接口是Collection的子接口，set接口没有提供额外的方法
2.Set集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set集合中，则添加操作失败。
3.Set判断两个对象是否相同不是==运算符，而是equals()方法。
collection 接口：单列集合，用来存储一个一个的对象
Set 特点：存储无序的、不可重复的数据
以HashSet为例说明：
1.无序的：不等于随机性。存储的数据在底层数组中并非按照数组素引的顺序添加，而是根据数据的哈希值决定的。
2.不可重复性：保证添加的元素按照equals()判断时，不能返回true.即：相同元素只能添加一个。
Set接口实现类的对比：
HashSet底层是：数组+链表的结构。 
TreeSet的使用与说明：
1.自然排序中，比较两个对象是否相同的标准为：CompareTo( )返回0，不在是equals() .
2.定制排序中，比较两个对象是否相同的标准为：Compare()返回0.不在是equals（）
说明：
1、向TreeSet中添加的数据，要求是相同类的对象。
2、两种排序方式。（自然排序和定制排序）
备注：
1.Set接口中没有额外定义新的方法，使用都是Collection中声明过的方法。
2.要求：向Set中添加的数据，其所在的类一定要重写hashcode() 和 equals()
3.要求：重写的hashcode()和equals()尽可能保持一致性。
五、Map 接口
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的底层：数组+链表（JDK 1.7之前）
数组+链表+红黑树（JDK 8 ）
Map结构的理解
Map中的key：无序的、不可重复的，使用Set存储所有的Key
Map中的value：无序的、可重复的，使用Collection存储所有的value
一个键值对：key-value构成了一个Entry（入口）对象。
Map中的entry：无序的、不可重复的，使用Set存储所有的entry。
Map接口常用方法：
HashMap 底层实现原理？
JDK 1.8实现原理
// 读配置文件
public class PropertiesTest {
public static void main(String[] args) throws Exception {
Properties pros = new Properties();
FileInputStream file = new FileInputStream(“jdbc.properties”);
pros.load(file);
String name = pros.getProperty(“name”);
String password = pros.getProperty(“password”);
System.out.println(“name =” + name + “,password=” + password)
}
}
Collections 工具类
面试题：
collection和Collections的区别
colleciton是集合接口，继承它的接口有list，set，注意map集合虽然也属于集合体系，但是map并不继承collection，map和collection是平级关系
collections是集合工具类，服务于colleciton，相当于collciont的工具，常用的方法有：
static <T extends Comparable<? super T>> void sort(List list)
根据元素的自然顺序 对指定列表按升序进行排序。
static void sort(List list, Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
根据元素的自然顺序，返回给定 collection 的最大元素。
static T max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static int binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表，以获得指定对象。
static void fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素
static void reverse(List<?> list) 反转指定列表中元素的顺序。
static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
二分原理：
public class Demo {
public static void main(String[] args) {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println(list);
int binarySearch = binarySearch(list, 4);
System.out.println(binarySearch);
}
/**
* 注意使用此方法的前提是已经排好序
*
* @param list
* @param key
* @return
*/
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) {
int max = list.size() - 1;//最大的位置
int min = 0;//最小的位置
int mid = 0;//中间位置
while (min <= max) {
mid = (max + min) >> 1;
Comparable<? super T> comparable = list.get(mid);
int num = comparable.compareTo(key);
if (num > 0) {
max = mid - 1;
} else if (num < 0) {
min = mid + 1;
} else {
return mid;
}
}
return -1;
}
}
六、寄语专区：
