Java集合框架综述
1：集合框架(Collection Framework)
首先要知道 集合代表的是一组对象,和数组差不多 但是数组的长度是固定不变的,而集合是可以变换长度的,比如说:集合就是一根金箍棒,可长可短, 数组就像是一根普通的木棍,长度是固定的，不能变长或者变短。在Java的集合框架中定义了一套规范用来操作集合和具体实现细节，在这里呢也可以把集合想象成一个数据库 ，它有“增删改查”四种操作 ，在本章呢会介绍集合框架的基本类和接口和一些的基本操作方法。
2：集合框架的两大接口（Collection和Map）
1.Collection接口
Collection表示一组对象 ，这些对象也称为collection元素，一个collection允许有重复的值，而另一些则不允许，一些collection是有序的，而有一些是无序的，在Java中没有直接实现collection的 但是它提供了两个子接口 这两个子接口继承了collection接口，那是哪两个接口呢？
ヾ(✿ﾟ▽ﾟ)ノ 这里介绍两个collection接口的子接口 List 和 Set
1.1ArraysLIst类
ArrayList是List的一个实现类。每一个ArrayList实例都有一个容量，该容量是指用来存储列表的数组大小，它总是等于或者小于列表的大小，随着向ArrayList不断添加元素，其容量也不断的增大。这里ArrayList它跟数组有很多相同点，到底有什么相同点和不同点呢？如下图
那知道ArrayList的概念 怎么创建一个ArrayList集合呢？ 定义语法如下：
1 //创建ArrayList集合 2 List list = new ArraysList(0);
在创建ArrayList集合的时候需要导入包：
//导入包
import java.util.ArrayList; import java.util.List;
知道了创建ArrayList集合 那怎么向集合里添加元素呢 开始说过java集合框架中定义了一套规范来实现“增伤改查”那怎么实现具体操作呢？下面介绍ArrayList集合的常用方法：
ArraysLIst 集合的常用方法
Arrays.asList(); 将数组装换为集合
add(Object value); 添加元素
add(int index,Object value)向指定位置插入元素
get(int index);通过下标获取元素
set(intindex,Object value);修改指定位置的元素
remove(int index); 移除集合中指定位置的元素
remove(Object o);从集合中移除第一次出现的指定元素(如果存在)
removeAll(collection<?>c);从列表中移除制动的collection 中包含的所有元素
Clear (); 移除集合中所有的元素
//遍历ArrayList
foreach(Object item : list){
//通过get（）方法获取元素
}
需要注意的是： 1.存储的元素类型都是Object类型
2.ArrayList集合中是可以添加重复的值，这个跟数组是一样的
3. 它的初始容量为10的空列表
1.2HashSet类
HashSet是一个哈希集是set的一个重要实现类 它不保证顺序恒久不变，也就是说是无序的，它允许使用NUll元素 但是只能有一个。而且他还不能有重复的值。set中 添加某个对象 无论添加多少次 最终只会保留一个该对象(的引用) 并且 保留的是第一次添加的那一个。既然是无序的所以它没有索引，不能通过索引获取元素。同样跟ArrayList一样它储存的类型也是Object类型。
那怎么创建一个Hashset呢？ 代码如下：
//创建HashSet（哈希集）
HashSet hashset= new HashSet();
在创建HashSet实例时需要导入包：
import java.util.HashSet;
以下是HashSet类的一些常用方法 如下图：
add(Object value) 如果此 set中尚未包含指定元素，则添加指定元素 它的返回值是Boolean类型
clear() 移除所有元素
remove（Object o）如果指定元素存在于此 set 中，则将其移除 它的返回值是Boolean类型
size（）获取set中的元素的数量 返回值是int
isEmpty（）判断该set中是否包含任何元素 返回值是boolean类型
iterator() 返回对此 set 中元素进行迭代的迭代器。
大家看到Hashset并没有直接获取元素的方法，因为他是无序的 没有索引，这里我们用iterator（）方法迭代获取数据，那怎么用呢？代码如下：
import java.util.Iterator;//导包
itIterator i = hash.iterator(); while(i.hasNext()){ String str = (String)i.next();//需要强转 }
这里需要注意的是 HashSet里储存是Object类型 需要什么数据类型 就强转成什么数据类型
上面的是通过Iterator（）方法进行迭代 看起来比较麻烦 所以还有一种渐变的方法 通过foreach迭代器进行获取数据 代码如下：
foreach(Object item in hash){
//获取数据
}
上面是Collection接口中的两个子接口 List和Set 下面介绍另一个接口 Map
2.Map接口
Map提供了一种映射关系 其中的元素是以键值对(Key-value)的形式存储的 能够实现根据key快速查找Value
Map中的键值对以Entry类型的对象实例形式存在
健(key值)不可重复 value值可以
一个值可以跟很多的key进行映射关系 但一个健(key值)最多只能映射到一个值(value)
2.1 HashMap类
HashMap是map的一个重要实现,也是最常用的 基于哈希表实现 它的Entry对象是无序排序的，Key值和value值都可以为null 但是一个HashMap只能有一个kay值为null的映射(key值不可重复)
介绍了HashMap类的概念 那怎么创建呢？ 代码如下：
//导入包
import java.util.HashMap;
//创建Hashmap
HashMap hash = new HashMap();
那HashMap类中有什么常用方法呢？如下：
get(Object key); 指定健获取所映射的值
Clear();从此映射中移除所有的映射关系
remove(Object key);从此映射中移除指定键的映射关系(如果存在)
size(); 获取此映射中的键-值映射的关系
put(K key,V value) 在此映射中关联指定的值与指定键 如果该映射以前包含了一个该键的映射关系 从而达到修改的功能
entrySet 语法: public Set<Map.Entry<K,V>> enttryset() 返回map中所有的键值对
KeySet 语法: public Ste<k>keyset() 返回此映射中所包含的键的set视图
getKey() 获取键
getValue（） 获取值
如何向HashMap中添加映射关系呢？如下：
//创建HashMap
HashMap hashmap = new HashMap();
//通过HashMap类的Put（）方法添加映射关系
hashmap.put(1, "张三");
这里需要注意的是：1.向HashMap中添加映射关系时 需要指定一个Key（键）指定一个Value（值）从而达到映射关系，
2.同样这里的健（key）和值（value）都是object类型，
如何获取HashMao中的数据呢？HashMap是键值对可以通过获取键的方法获取数据代码如下：
//通过HashMap类的gat（object key）获取值
System.out.println(hashmap.get(1));
那如何遍历HashMap中的元素呢？ 用foreach迭代器实现 代码如下：
//遍历HashMap的Key值获取数据
for (Object item:hashmap.keySet()) {
System.out.println(hashmap.get(item));
}
其他的方法就不一一测试了 (￣▽￣)~*
那现在有一个问题 比如如下代码：
List list = new ArrayList();
list.add("qqyumidi");
list.add("corn");
list.add(100);
for (int i = 0; i < list.size(); i++) {
String name = (String) list.get(i); //1
System.out.println("name:" + name);
}
定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。
以上代码中有两个问题：
A.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。
B.因此，//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。
那有什么办法可以使集合能够约束元素类型呢 并达到安逸不报错呢？在Collection和Map中有出现了一个泛型集合。
3.什么是泛型？
泛型也可以理解为“参数化类型”，类型的参数化，就是可以把类型像方法的参数那样传递。这一点意义非凡。
那它有什么作用呢？ ：泛型使编译器可以在编译期间对类型进行检查以提高类型安全，减少运行时由于对象类型不匹配引发的异常。
怎么定义个泛型集合呢？把上面的代码修改如下：
List<String> list = new ArraysList<String>();//定义泛型的语法
list.add("aaa");
list.add("bbb");
list.add(1111);//1
foreach(String item : list){
System.out.println(item);
}
根据上面的代码 得到 定义泛型集合的语法：
List<E> list = new ArraysList<E>（）；
在List<>尖括号里是要对集合数据类型的约束
<E>中的E表示类型形参，可以接收具体的类型实参
上面的代码集合类型是String类型 那么代码“1”我们添加一个int类型的数据 这样编译器是会报错的，因为在定义泛型的时候 限制的是String类型 所以只能添加String类型的数据，
所以我们总结： 当泛型进行了数据类型约束的时候 不能添加其他的数据类型，否则编译器会报错。
那么HashSet也可以定义泛型，对元素的数据类型进行约束，那怎么创建HashSet泛型呢？语法如下：
//创建HashSet泛型
HashSet<E> hashSet = new HashSet<E>();
同样是对HashSet中的元素进行数据类型约束 用法如上，具体方法 请往上看HashSet集合的方法。
需要注意的是：
1.泛型集合中 不能添加泛型规定的类型及其子类型以外的对象 否则会报错
2.泛型集合中的限定类型 不能使用基本数据类型
3. 可以通过使用包装类限定允许存入的基本数据类型
以上是Collection家族的集合和泛型，那么Map家族有泛型吗？ 答案是肯定的
HashMap如何定义泛型呢 我们用代码实现一下 代码如下：
//定义HashMap泛型
HashMap<K, V> Hashmap = new HashMap<K, V>();
在HashMap<K,V>
K代表的是Key（键）的数据类型，
V代表的值（value）的数据类型，
也就是说 K键的数据类型必须是规定的数据类型不能是其他的数据类型，值（value）也是一样。
以上是对泛型的介绍，这里在介绍一下Map中的contains方法：
contains方法 某个序列是否包含某个对象 如果包含则返回true 如果不包含则返回faslse
HashMap中：
ContainsKey(object key); 获取此映射是否包含对于指定建的映射关系
ContainsValue(object values); 获取此映射是否在此映射中存在的值
具体怎么使用呢？请看代码：
Student类
public class Student { //学号 private String id; //姓名 private String name; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Student(String id,String name){ this.id=id; this.name=name; } }
test类
import java.util.HashMap;
/**
* ClassName: TestContains
* @Description: TODO测试 Map接口的HashMap类的Contains方法
*/
public class TestContains {
public static void main(String[] args) {
//创建HashMap泛型 键的类型约束是String类型 值的类型约束是学生类（Student）
HashMap<String, Student> hashmap = new HashMap<String, Student>();
//创建一个学生 张三
Student zs = new Student("A1000", "张三");
//向泛型中添加元素
hashmap.put("1",zs);
//检查是否存在键Key 1
boolean yesno = hashmap.containsKey("1");
//输出结果
System.out.println("Does it contain key1:"+yesno);
//检查是否包含值 Value “张三”这个学生
boolean yesno1 = hashmap.containsValue(zs);
//输出结果
System.out.println("Does it contain values‘张三’:"+yesno1);
}
}
这里我的HashMap中key的约束数据类型是String （这里大家注意下 泛型类型约束不能放基本数据类型 可以放数据类型的类 ）value的类型约束是Student类的实例，也是就是说我定义的是学生类 里面只能放一个学生 要是放一个老师就不行。
言归正传 这里我使用HashMap中的Contains方法来判断泛型中是否包含某个键 或者包含某个对象，它的返回值类型就是Boolean类型，true或false；
接下来带大家认识两个接口和一个工具类：
1.Collections(工具类)
Collections工具类是java集合框架中 用来操作集合对象的工具类，这里我们只介绍一个方法sort（）；
在使用之前需要导入工具类的包 代码如下：
//导入包
import java.util.Collections;
sort（）方法呢主要是排序 语法如下：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TetsCollectionsSort {
public static void main(String[] args) {
//创建ArrayList泛型
List<String> list = new ArrayList<String>();
//向集合里添加数据
list.add("aasd");
list.add("csfgsfd");
list.add("zasd");
list.add("gghg");
//输出排序前
System.out.println("排序前");
for (String item : list) {
System.out.println(item);
}
//进行排序
Collections.sort(list);
//排序后
System.out.println("排序后");
for (String item : list) {
System.out.println(item);
}
}
}
这里发现这些字符串的顺序发生了变化 那么是怎么进行排序的呢？
答：在排序String字符串的时候是比较首字母排序 如果首字母一样则比较第二个字符 如此往下，如果字符串的开头是数字，则比较数字的大小，数字在前，字母在后，
上面是java集合框架的Collections工具类的sort（）方法的介绍，下面介绍一个接口
2.Comparable接口
前面介绍了Collections.sort（）方法 而要实现序列的排序就要实现comparable接口下面就介绍Comparable接口
实现该接口表示，这个类的实例可以进行自然排序，
定义了默认的比较规则
其实现类需要compareTo（）方法
compareTo（）方法返回整数表示大 负数表示小 0表示相等
一个生活的小案例 在学校里做广播体操时 一般学生的排列都是按照身高去排列，从矮到高排列 因此学生是可以进行比较的，那么我们想两个事物要进行比较，是不是要找到可以比较的方式呢？在我们比较连个事物的时候
会有一个默认的比较规则，称为自然排序，比如在学生排列的时候这个身高就是可以比较的特性，也是默认的比较规则，那么自然顺序就是身高之间的差异。
那么如何用代码实现呢？ 代码如下：
Student类
public class Student{ //学号 private String id; //姓名 private String name; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Student(String id,String name){ this.id=id; this.name=name; } }
test类
import java.util.ArrayList; import java.util.List; import java.util.Collections; /* ClassName: TestContains * @Description: TODO测试comparable接口比较对象 */ public class TestContains { public static void main(String[] args) { // 创建HashMap泛型 键的类型约束是String类型 值的类型约束是学生类（Student） List<Student> list = new ArrayList<Student>(); // 创建两个学生 张三 李四 Student zs = new Student("Z1000", "张三"); Student ls = new Student("V1000", "李四"); // 向集合中添加元素 list.add(zs); list.add(ls); // 排列前 for (Student item : list) { System.out.println("学号是：" + item.getId() + "姓名：" + item.getName()); } // 排列 Collections.sort(list);//1 // 排序后 for (Student item : list) { System.out.println("学号是：" + item.getId() + "姓名：" + item.getName()); } } }
这里呢我们的代码1处会报错的 是因为咱们的Student这个类没有实现comparable接口 所以我们要对Student这个类进行改造 修改后的代码如下：
public class Student implements Comparable<Student>{ //学号 private String id; //姓名 private String name; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Student(String id,String name){ this.id=id; this.name=name; } //重写comparable的comparato（）方法 @Override public int compareTo(Student o) { return this.id.compareTo(o.id); } }
这里让Student这个类实现Comparable接口 因为接口都是抽象的 所以这里必须重写compareTo（）方法
这个方法实现 让学生的Id进行一个比较排列 返回整形 那么Test类输出如下：
排序前
学号是：Z1000姓名：张三
学号是：V1000姓名：李四
排序后
学号是：V1000姓名：李四
学号是：Z1000姓名：张三
这里的排序方法向上面介Collections.sort()方法一样
3.Comparator接口 ---- 比较工具
用于定义临时比较规则，而不是默认比较规则
其实现类需要实现Compare（）方法
强行对某个对象 collection 进行整体排序 的比较函数。可以将 Comparator 传递给 sort 方法
compare（）方法返回整数表示大 负数表示小 0表示相等
具体实现comparator接口的代码如下：
StudentComparator类
import java.util.Comparator; public class StudentComparator implements Comparator<Student>{
//要实现Comparator接口必须要重写Compare（）方法 @Override public int compare(Student o1, Student o2) { //按照学生的姓名进行排列 return o1.getName().compareTo(o2.getName()); } }
Test类修改如下：
import java.util.ArrayList; import java.util.List; import java.util.Collections; /* ClassName: TestContains * @Description: TODO测试comparable接口比较对象和comparator接口 */ public class TestContains { public static void main(String[] args) { // 创建HashMap泛型 键的类型约束是String类型 值的类型约束是学生类（Student） List<Student> list = new ArrayList<Student>(); // 创建两个学生 张三 李四 Student zs = new Student("Z1000", "张三"); Student ls = new Student("V1000", "李四"); // 向集合中添加元素 list.add(zs); list.add(ls); // 排列前 System.out.println("排序前"); for (Student item : list) { System.out.println("学号是：" + item.getId() + "姓名：" + item.getName()); } // 排列 Collections.sort(list); // 排序后 System.out.println("排序后"); for (Student item : list) { System.out.println("学号是：" + item.getId() + "姓名：" + item.getName()); } //按照姓名排序如下 System.out.println("按照姓名排序是："); Collections.sort(list,new StudentComparator()); for (Student item : list) { System.out.println("学号是：" + item.getId() + "姓名：" + item.getName()); } } }
这里Collections.sort();时需要传递一个集合 和一个实现类的对象，
本章主要介绍Java集合框架的主要成员有：Collection接口 Map接口 Collections工具类 Comparable接口 Comparator接口
本章内容到此结束！！！