集合框架

集合框架

早在 Java 2 中之前，Java 就提供了特设类。比如：Dictionary, Vector, Stack, 和 Properties 这些类用来存储和操作对象组。

虽然这些类都非常有用，但是它们缺少一个核心的，统一的主题。由于这个原因，使用 Vector 类的方式和使用 Properties 类的方式有着很大不同。

集合框架被设计成要满足以下几个目标：

• 该框架必须是高性能的。基本集合（动`态数组，链表，树，哈希表）的实现也必须是高效的。
• 该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。
• 对一个集合的扩展和适应必须是简单的。

为此，整个集合框架就围绕一组标准接口而设计。你可以直接使用这些接口的标准实现，诸如： LinkedList**, **HashSet, 和 TreeSet 等,除此之外你也可以通过这些接口实现自己的集合。

从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合Collection，存储一个元素集合，另一种是图Map，存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

• 接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
• 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
• 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

除了集合，该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。

接口

• Set和List的区别

  1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可重复的元素。

  2. Set 检索效率低，删除和插入效率高，插入和删除不会引起元素位置改变 （实现类有HashSet、TreeSet）。

  3. List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变。 （实现类有ArrayList、LinkedList、Vector）

集合实现类（集合类）

迭代器

迭代器，可以通过循环来得到或删除集合的元素。

Iterable是一个定义集合遍历方式的接口，有方法 iterator() 获取迭代器对象，因此实现了Iterable接口的类才可以使用for-each循环遍历，例如实现了Collection接口的类。

Iterator 是一个定义了集合迭代器的借口，有方法 hasNext()、next()、remove() 来使用迭代器对集合进行遍历操作。

ListIterator 继承了 Iterator，以允许双向遍历列表和修改元素，List接口可以使用双向迭代器。

public class Test{
 public static void main(String[] args) {
     List<String> list = new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
     // 第一种遍历方法使用 For-Each 遍历 List
     for (String str : list) { //也可以改写 for(int i=0;i<list.size();i++) 这种形式
        System.out.println(str);
     }
 
     // 第二种遍历，把链表变为数组相关的内容进行遍历
     String[] strArray = new String[list.size()];
     list.toArray(strArray);
     for(int i=0; i < strArray.length; i++) // 可以改写为  for(String str:strArray) 这种形式
     {
        System.out.println(strArray[i]);
     }
     
     // 第三种遍历 使用迭代器进行相关遍历
     
     Iterator<String> ite=list.iterator();
     while(ite.hasNext()) // 判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}

比较器

TreeSet 和 TreeMap的按照排序顺序来存储元素。这是通过实现了比较器接口 Comparator 来精确定义按照什么样的排序顺序，这个接口可以以不同的方式来排序一个集合。

Comparable 是自然排序使用的接口，提供的方法compareTo(T o)实现，当一个类实现了Comparable接口，就意味着该类支持排序。

Comparator 是比较器接口，可以实现此接口自定义排序规则，用自定义的比较器入参，可以完成集合的自定义排序，例如 compare(E a, E b) 返回值为 int 类型。

注：当自然排序与自定义比较器同时使用，自定义比较器优先级更高。

Comparable 与 Comparator比较：

用 Comparable 简单， 只要实现 Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码；

用 Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去即可进行比较。

判断重复的标准：

调用对象的compareTo方法进行升序排列（A.compareTo(B)），如果return 0 表示相等；返回值大于0，则认为A大于B；如果返回值小于0，则认为A小于B。

Collections工具类

用于操作Collection下的集合。

ArrayList

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。

扩容底层是使用Arrays.copyOf，在元素个数大于数组长度的时候进行扩容，扩容每次扩大到原长度的1.5倍，

// 导包 与 初始化
import java.util.ArrayList; // 引入 ArrayList 类
// E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
// objectName: 对象名。
ArrayList<E> objectName = new ArrayList<>(); // 初始化

常用方法：

LinkedList

LinkedList是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。链表可分为单向链表和双向链表。一个单向链表包含两个值：当前节点的值和一个指向下一个节点的链接。

// 导包 与 初始化
import java.util.LinkedList; 

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表

常用方法：

HashSet

HashSet 基于 HashMap 来实现的，实现了 Set 接口，是一个不允许有重复元素的集合。HashSet 是无序的，即不会记录插入的顺序，HashSet 允许有 null 值。

HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 必须在多线程访问时显式同步对 HashSet 的并发访问。

// 导包 与 初始化
import java.util.HashSet;

HashSet<String> sites = new HashSet<String>();

常用方法：

LinkedHashSet

LinkedHashSet是HashSet的子类，是有序的HashSet，通过链表完成。所以继承了HashSet所有的方法

TreeSet

TreeSet对元素进行排序，底层是基于TreeMap来实现的，TreeMap底层基于红黑树（特殊的二叉树，左边叉值小，右边叉值大，有自平衡机制），存储的元素类型必须一样且元素类型的类必须实现Comparable接口。

TreeSet存在两种排序方式：

1. 自然排序：元素类型必须实现了Comparable接口，且必须重写compareTo()方法。

2. 定制排序： 在创建TreeSet对象的时候，传入一个Comparator接口的实现类，该实现类必须重写compare方法。

构造方法：

• TreeSet()创建一个有自然排序功能的TreeSet对象。 默认自然排序是升序。

• TreeSet(Collection c) 构造一个包含指定集合中的元素的新树集，根据其元素的 自然排序进行排序 。 使用该构造方法，要求，集合参数c必须元素是同一种类型，且实现了Comparable接口的。

• TreeSet(Comparator comparator) 创建一个有定制排序功能的TreeSet对象。可以使用Comparator的实现类对象，也可以使用Comparator的匿名内部类。

常用方法：

Map

Map也是一种容器的接口，里面存储的是一对一对的数据，每添加一次，添加的是两个（一对）数据，一个映射（一个Map对象）不能包含重复的键，与Collection并无关系；Collection体系，存储在都是单个单个的数据，数据之间没有关系。

Map的遍历方式：

1. 如果只是获取所有一个值，使用values()方法

2. 如果只是获取所有的key，使用keySet()方法

3. 如果获取所有的key-value，使用entrySet()，不要用先通过keySet()获取key，再用get()获取具体的value，这样会导致二次查询，效率低下

Map m = new HashMap();
m.put("小明", 90);
m.put("小马", 60);
m.put("小郭", 60);
Set entrys = m.entrySet();
for (Object en : entrys) {
	// 需要把en强制转成 Entry类型
	Entry e = (Entry)en;
	System.out.println(e.getKey()+"--"+e.getValue());
}

HashMap

基于hashCode()，底层是Entry键值对的数组，数组中装装的是键值对。从结构实现来讲，HashMap是数组+链表+红黑树实现。

HashMap会根据添加的key的hashCode值与当前数组的length（默认是16）取模，而得到数组的下标，进而保存键值对，故HashMap存储的数据是无序的，因为角标是计算得出而不是按顺序排列。

如果key模length后，得到的下标是相等的，就会发生哈希冲突，这时候再继续判断key的equals方法，如果equals判断为true，就会将原来的键值对覆盖，如果是false，就会在该下标处的原来键值对后面形成链表，如果链表长度达到8个且元素总量大于64时，就形成红黑树。当删除键值对后剩余的数量小于等于6的时候，就重新将红黑树退化为链表。

构造方法：

• HashMap()构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。

  容量16：是键值对的数组长度16

  负载系数0.75：扩容机制是当容量达到75%的时候，开始扩容，就是创建新数组，复制元素。

• HashMap(int initialCapacity)创建空的 HashMap具有指定的初始容量initialCapacity和默认负载因子（0.75）。

• HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。

• HashMap(Map m) 创建一个HashMap对象，并且传入另一个Map对象m，这样先创建对象就有了与m相同的数据

常用方法：

HashTable 与 HashMap的区别：

• HashMap可以接受null键值和值，而HashTable则不能。

• HashMap去掉了Hashtable的contains方法，改成containsValue和containsKey。

• Hashtable继承自Dictionary类，而HashMap是Java1.2引进的interface Map 的一个实现。

• 最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而**HashMap就必须为之提供外同步**。

• Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

Properties

Properties 继承于 Hashtable。表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。Properties 定义的实例变量，这个变量持有一个 Properties 对象相关的默认属性列表。

使用场景：

1. 将内存中的数据写入到硬盘中；

2. 将硬盘中的数据读取到内存中；

3. 使用时需要使用 Properties 自己的方法，才能使key和value都是String类型。

常用方法：

Properties pp = new Properties(); //获得一个Properties对象
		
pp.setProperty("XXXX", "OOOO"); //给Properties对象设置值
pp.setProperty("YYYY", "JJJJ");
		
System.out.println(pp.size());
System.out.println(pp);
		
System.out.println(pp.getProperty("XXXX")); //从Properties对象根据key获得值

PrintStream ps = new PrintStream("/qq.txt"); // 建立一个打印流与文件关联
pp.list(ps); // 将list方法的值持久化到文件中

FileInputStream fis = new FileInputStream("/easyexplore.link") // 建立一个文件输入流，与对应文件相关联
pp.load(fis); // load方法讲文件中的值加载到Properties对象中
System.out.println(pp);
		
String property = pp.getProperty("path"); // 获得Properties对象中的 “path” 值对应的属性
System.out.println(property);

泛型

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

规则限制：

1. 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2. 同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3. 泛型的类型参数可以有多个。
4. 泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。
5. 泛型的参数类型还可以是通配符类型。例如<? extends Number> 表示最高可以传入的类型是Number及其子类类型

泛型类

一个类本质看成是一个通用的模板，在设计类的时候，其中的数据类型写一个符号，泛指所有的类型，但是不指具体的某种类型

当在使用模板来创建一个对象的时候可以指定自己的类型。

class Point<数据类型>{    // 表示在类声明了一个符号  数据类型，是一种泛指
   数据类型 x;
   数据类型 y;
}  

泛型方法

就是把泛型类型的声明放在某个方法上面，只需将泛型参数列表置于返回值前，只能够本方法上或者内部可以使用这个符号，在调用方法的时候传入的实际参数为真实的类型。

注：在创建数组的时候,必须要知道具体类型的。

public static <T> T[] getArr(T[] arr){
	T[] copyOf = (T[])Arrays.copyOf(arr, arr.length, arr.getClass());
	Arrays.sort(copyOf);
	return copyOf;
}