声明：由于学习所用环境为JDK1.8,所有java代码均在JDK1.8环境中测试通过，如果环境发生变化，可能会有错误！
一、集合的概念与框架结构
1、集合：Java API所提供的一系列类的实例，可以用于动态存放多个对象。
Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中
特点：长度不固定，只能存储引用类型对象
2、java集合框架
3、Collection接口中定义了一些集合常用方法
public static void main(String[] args) {
List<String> list=new LinkedList<String>();
Collections.addAll(list, "aa","bb","cc");
showList(list);
System.out.println("打乱之后：");
Collections.shuffle(list);
showList(list);
System.out.println("反转之后：");
Collections.reverse(list);
showList(list);
}
public static void showList(List<String> list){
for(String str:list){
System.out.print(str+" ");
}
System.out.println();
}
4、存储特点：
Collection接口－定义了存取对象的方法。两个常用的子接口：
List接口：存放的元素有序且允许有重复的集合接口。
Set接口：存放的元素不包含重复元素的集合接口。
二、List集合及其实现类
List接口是Collection接口的子接口
实现List接口的集合类中的元素是有序的，且允许重复。
List集合中的元素都对应一个整数型的序号记载其在集合中的位置，可以根据序号存取集合中的元素。
JDK API所提供的List集合类常用的有 :ArrayList、LinkedList
1、List接口常用方法
List接口比Collection接口中新增的几个实用方法：
public Object get(int index);
返回列表中的元素数
public Object add(int index, Object element);
在列表的指定位置插入指定元素.将当前处于该位置的元素（如果有的话）和所有后续元素向右移动
public Object set(int index, Object element) ;
用指定元素替换列表中指定位置的元素
public Object remove(int index);
移除列表中指定位置的元素
public ListIterator listIterator()
返回此列表元素的列表迭代器
2、实现类--ArrayList
ArrayList是使用数组结构实现的List集合。
优点：
对于使用索引取出元素有较好的效率，它使用索引来快速定位对象
缺点：
元素做删除或插入速度较慢、因为使用了数组，需要移动后面的元素以调整索引顺序。
public static void main(String[] args) { List<String> list=new ArrayList<String>();
list.add("中国");
list.add("俄罗斯");
list.add("中国");
list.add("意大利");
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+" ");
}
System.out.println();
list.remove("中国");
for(String str:list){
System.out.print(str+" ");
}
}
3、实现类--LinkedList
LinkedList是使用双向链表实现的集合。
LinkedList新增了一些插入、删除的方法。
优点：对频繁的插入或删除元素有较好的效率
缺点：查询元素时，效率低，因为要从第一个元素查找。
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> list=new LinkedList<String>();
System.out.println("模拟栈数据类型");
list.push("香港");
list.push("澳门");
list.push("厦门");
System.out.print(list.pop()+" ");
System.out.print(list.pop()+" ");
System.out.print(list.pop()+" ");
System.out.println();
System.out.println("模拟队列数据类型");
list.add("香港");
list.add("澳门");
list.add("厦门");
System.out.print(list.removeFirst()+" ");
System.out.print(list.removeFirst()+" ");
System.out.print(list.removeFirst()+" ");
}
三、迭代器的使用
1、Iterator是专门的迭代输出接口。所谓的迭代输出就是将元素进行判断，判断是否有内容，如果有内容则把内容取出。
Iterator对象称作迭代器，用以方便的实现对集合内元素的遍历操作。
2、所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了Iterator接口的对象。
Iterator it = coll.iterator();
while(it.hasNext()){
it.next();
}
3、Iterator接口中定义了如下方法：
boolean hasNext(); //判断游标右边是否有元素
Object next(); //返回游标右边的元素并将游标移动到下一个位置
4、另一种遍历集合的方法：
用增强for遍历集合中的元素
凡是能用 Iterator 迭代的集合都可以用JDK5.0中增强的for循环来更简便的遍历。
List<String> list=new ArrayList<String>();
…
eg: for(String data:list){
System.out.print(data+” ”)
}
public class IteratorDemo {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"西安","北京","厦门","西安","咸阳");
Iterator<String> iter=list.iterator(); // 返回List集合的迭代器
// 通过迭代器遍历集合
while(iter.hasNext()){
System.out.print(iter.next()+" ");
}
}
三、泛型补充1、泛型（Generic type）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
泛型的好处：
解决了类型安全的问题(运行期出现“java.lang.ClassCastException”异常)
2、泛型类
class Gen<T> {
private T ob; // 定义泛型成员变量
public Gen(T ob) {
this.ob = ob;
}
public T getOb() {
return ob;
}
public void setOb(T ob) {
this.ob = ob;
}
public void showType() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
3、受限泛型
1. 设置上限
类名称<? extends 上限类>
只能接收上限类对象或其子类对象
2. 设置下限
类名称<? super 下限类>
接收下限类对象或其父类对象
注意：若定义泛型类，可以将?设置为泛型标识。
public class GenericDemo {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
list.add("apple");
list.add("banana");
for(String data:list){
System.out.print(data+" ");
}
method(list);
method(new ArrayList<Object>());
}
public static void method(List<? super String> list){
List<String> temp=(List<String>)list;
temp.add("abc");
}
}
四、Set接口的实现类
Set接口没有提供Collection接口额外的方法，但实现Set接口的集合类中的 元素是不可重复的。
JDK API中所提供的Set集合类常用的有：
HashSet：散列存放
TreeSet：有序存放
LinkedHashSet
1、HashSet的存储原理
根据每个对象的哈希码值(调用hashCode()获得)用固定的算法算出它的存储索引，把对象存放在一个叫散列表的相应位置(表元)中：
如果对应的位置没有其它元素，就只需要直接存入。
如果该位置有元素了，会将新对象跟该位置的所有对象进行比较(调用equals())，以查看是否已经存在了：还不存在就存放，已经存在就不存储。
2、HashSet的特点
(1) HashSet不保存元素的加入顺序。
(2)HashSet接口存、取、删对象都有很高的效率。
(3)对于要存放到HashSet集合中的对象，对应的类可以重写hashCode(Object obj)方法和equals()以实现对象相等规则的编写。
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
return this.age;
}
@Override
public boolean equals(Object obj) {
if(obj==null){
return false;
}else if(this==obj){
return true;
}else if(!(obj instanceof Student)){
return false;
}
Student student=(Student)obj;
if(this.name!=null && this.name.equals(student.name) && this.age==student.age){
return true;
}
return false;
}
}
public class StudentHashSet { public static void main(String[] args) { HashSet<Student> set=new HashSet<>(); set.add(new Student("李丽", 20)); set.add(new Student("李梅", 22)); set.add(new Student("李梅", 22)); set.add(new Student("王梅", 22)); for(Student stu:set){ System.out.print(stu); System.out.println(); } }}
3、TreeSet集合的特点
(1)TreeSet:可以对加入其中的元素进行排序。但前提是必须指定排序规则。
(2)构造方法： public TreeSet()
如果使用TreeSet的无参构造实例化TreeSet集合，则加入到TreeSet集合中的元素所对应的类必须实现java.lang. Comparable<T>接口，复写其中的int compareTo(T o)方法，并在方法中编写排序规则。
(3)在Comparable<T>接口的compareTo(T o)方法中，指定排序规则(以升序为例)：
public int compareTo(Girl girl)｛
if(this.xxx>girl.xxx){
return 1;
}else if(this.xxx<girl.xxx){
return -1;
}else{
return 0;
}
｝
TreeSet比较排序的过程，已经对重复元素去重了
public class Person implements Comparable<Person> { private String name;
private int age;
private double score;
public Person() {
}
public Person(String name, int age, double score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", score=" + score
+ "]";
}
@Override
public int compareTo(Person person) {
if(this.score>person.score){
return 1;
}else if(this.score<person.score){
return -1;
}else{
if(this.age>person.age){
return 1;
}else if(this.age<person.age){
return -1;
}else{
return 0;
}
}
}
}
public class PersonTreeSet { public static void main(String[] args) { TreeSet<Person> set=new TreeSet<Person>(); set.add(new Person("李梅", 18, 89.9)); set.add(new Person("王梅", 19, 89.9)); set.add(new Person("张梅", 17, 80.9)); set.add(new Person("赵梅", 18, 90.5)); for(Person person:set){ System.out.println(person); } }}
