集合（一）

一、集合类概述
为什么出现集合类？
• 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，有何不同？
• 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。
数组中可以存储基本数据类型，集合只能存储对象。

集合类的特点？
• 集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

二、集合框架的构成及分类

三、集合框架中的常用接口

1）、Collection定义了集合框架的共性功能。
1，添加
add(e);
addAll(collection);

2，删除
remove(e);
removeAll(collection);
clear();

3，判断。
contains(e);
isEmpty();

4，获取
iterator();
size();

5，获取交集。
retainAll();

6，集合变数组。
toArray();

1，add方法的参数类型是Object。以便于接收任意类型对象。
2，集合中存储的都是对象的引用(地址)

什么是迭代器呢？
其实就是集合的取出元素的方式。
如同抓娃娃游戏机中的夹子。

迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。通过容器的iterator()方法获取该内部类的对象。

2）、Collection接口有两个子接口：
List（列表） ，Set（集）

Collection：
|–List:元素是有序的，元素可以重复。因为该集合体系有索引。

• —-ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
• —–LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
• —-Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

|–Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、

• —-HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
  HashSet是如何保证元素唯一性的呢？
  -是通过元素的两个方法，hashCode和equals来完成。
  -如果元素的HashCode值相同，才会判断equals是否为true。
  -如果元素的hashcode值不同，不会调用equals。
  -注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
• —-TreeSet：

Set集合的功能和Collection是一致的。

List：特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
addAll(index,Collection);

删
remove(index);

改
set(index,element);
查
get(index):
subList(from,to);
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();

List集合 特有的迭代器。
ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。

所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

该接口只能通过List集合的listIterator方法获取。

四 、List接口中常用类

1）ArrayList
线程不安全，查询速度快。

import java.util.*;

/*
去除ArrayList集合中的重复元素。
*/

class ArrayListTest {

    public static void sop(Object obj){
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java01");

        sop(al);//打印集合

        al = singleElement(al);

        sop(al); //打印去除重复后的集合

    }

    public static ArrayList singleElement(ArrayList al){
        //定义一个临时容器。
        ArrayList newAl = new ArrayList();

        Iterator it = al.iterator();

        while(it.hasNext()){
            Object obj = it.next();
            if(!newAl.contains(obj))
                newAl.add(obj);
        }

        return newAl;
    }
}

import java.util.*;

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。

思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。
List集合判断元素是否相同，依据是元素的equals方法。
*/
/* 
要求：去除ArrayList 中的相同对象 
注意：要重写equals()方法。 

*/  
import java.util.*;  
class Person{  
         private int age;  
         private String name;  
         Person(String name,int age){  
                   this.name = name;  
                   this.age = age;  
         }  
         public String getName(){  
                   return this.name;  
         }  
         public int getAge(){  
                   return this.age;  
         }  
        public boolean equals(Object obj){

        if(!(obj instanceof Person))
            return false;
        // 要向下转型 
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
}  

class Test{  
         public static ArrayList myRemove(ArrayList a,ArrayList b) {  
                   if(a.isEmpty()){  
                            return a;  
                   }  
                   ListIterator it = a.listIterator();  
                   while(it.hasNext()){  
                            Object obj = it.next();  
                            Person p = (Person) obj;  
                            if(!(b.contains(p))){  
                                     b.add(p);  
                            }         
                 }  
                     return b;  
         }  
}  
public class ArrayListTest2{  
         public static void main(String[] args) {  
                   ArrayList a1 = new ArrayList();  
                   ArrayList a2 = new ArrayList();  
                   a1.add(new Person("java01",12));  
                   a1.add(new Person("java01",12));  
                   a1.add(new Person("java013",23));  
                   a1.add(new Person("java014",33));  
                   a1.add(new Person("java014",33));  
                   a1.add(new Person("java0145",44));  
                   sop(a1);  
                   sop(Test.myRemove(a1,a2));  
         }  

         public static void sop(ArrayList a){  
                   ListIterator l = a.listIterator();  
                   while(l.hasNext()){  
                            Object obj =l.next();  
                            if (obj instanceof Person) {  
                                     Person p = (Person) obj;  
                                     System.out.println(p.getName()+"...."+p.getAge());  
                            }else {  
                                     break;  
                            }                         
                   }  
         }  
}  

2）LinkedList
链表结构，增删速度快。

/*
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出  如同一个杯子。
队列：先进先出 First in First out  FIFO 如同一个水管。
*/

import java.util.*;
class DuiLie{
    private LinkedList link;

    DuiLie(){
        link = new LinkedList();
    }

    public void myAdd(Object obj){
        link.addFirst(obj);
    }
    public Object myGet(){
        return link.removeFirst();
    }
    public boolean isNull(){
        return link.isEmpty();
    }

}

class  LinkedListTest{
    public static void main(String[] args) {
        DuiLie dl = new DuiLie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");

        while(!dl.isNull()){
            System.out.println(dl.myGet());
        }
    }
}

3）Vector
线程安全，但速度慢，已被 ArrayList替代。

import java.util.*;

/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。
*/
class VectorDemo {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");

        Enumeration en = v.elements();
        while(en.hasMoreElements()){
            System.out.println(en.nextElement());
        }
    }
}

五、Set接口中常用的类

1)HashSet
线程不安全，存取速度快。

import java.util.*;

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
*/
class HashSetTest {
    public static void sop(Object obj){
        System.out.println(obj);
    }
    public static void main(String[] args) {
        HashSet hs = new HashSet();

        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a2",12));

        //sop("a1:"+hs.contains(new Person("a2",12)));

        hs.remove(new Person("a4",13));

        Iterator it = hs.iterator();

        while(it.hasNext()){
            Person p = (Person)it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
}
class Person{
    private String name;
    private int age;
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public int hashCode(){
        System.out.println(this.name+"....hashCode");
        return name.hashCode()+age*37;
    }

    public boolean equals(Object obj){

        if(!(obj instanceof Person))
            return false;

        Person p = (Person)obj;

        return this.name.equals(p.name) && this.age == p.age;
    }


    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

2)TreeSet
线程不安全，可以对Set集合中的 元素进行排序。
可以对Set集合中的元素进行排序。
1. 底层数据结构是二叉树。保证元素唯一性的依据：
compareTo方法return 0.
2. TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
3. TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。

/*
练习：按照字符串长度排序。
字符串本身具备比较性。但是它的比较方式不是所需要的。
这时就只能使用比较器。
*/

import java.util.*;
class  TreeSetTest{
    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new StrLenComparator());

        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("z");
        ts.add("hahaha");

        Iterator it = ts.iterator();

        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

class StrLenComparator implements Comparator{
    public int compare(Object o1,Object o2){
        String s1 = (String)o1;
        String s2 = (String)o2;

        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num==0)
            return s1.compareTo(s2);

        return num;
    }
}

/*
需求：
往TreeSet集合中存储自定义对象学生。
想按照学生的年龄进行排序。

记住，排序时，当主要条件相同时，一定判断一下次要条件。

*/
import java.util.*;

class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();

        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi08",19));

        Iterator it = ts.iterator();
        while(it.hasNext()){
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}


class Student implements Comparable{//该接口强制让学生具备比较性。

    private String name;
    private int age;

    Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public int compareTo(Object obj){

        if(!(obj instanceof Student)){
            throw new RuntimeException("不是学生对象");
        }
        Student s = (Student)obj;
        if(this.age>s.age){
            return 1;
        }   
        if(this.age==s.age){
            return this.name.compareTo(s.name);
        }
        return -1;
    }

    public String getName(){
        return name;

    }
    public int getAge(){
        return age;
    }
}