黑马程序员——java基础——集合框架（1）Collection

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、 集合框架

1、集合概述

   java中的集合也就是容器，容器就是用来存储对象用的，因此根据存储的特性上可以分为单列集合(Collection)和双列集合(Map)。

并且每一种容器都有自己的内部数据结构，所以我们会根据需要选择相应的容器。

1）集合的特点：

    a)对象封装数据，对象多了也需要存储。集合用于存储对象。

    b)对象的个数确定可以使用数组，但是不确定怎么办？可以用集合。因为集合是可变长度的。

2）集合和数组的区别：

    a)数组是固定长度的；集合可变长度的。

    b)数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。

    c)数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。

3）数据结构：就是容器中存储数据的方式。

4）对于集合容器，有很多种。因为每一个容器的自身特点不同，其实原理在于每个容器的内部数据结构不同。

集合容器在不断向上抽取过程中。出现了集合体系。在使用一个体系时有一个原则：参阅顶层内容。建立底层对象。

 

2、Collection接口

Collection：是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。

|--List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。

|--Set：无序(存入和取出顺序有可能不一致)，不可以存储重复元素。必须保证元素唯一性。

 

Collection集合类的共性方法 

1）添加：

add(object)：添加一个元素

addAll(Collection) ：添加一个集合中的所有元素。

2）删除：

clear()：将集合中的元素全删除，清空集合。

remove(obj) ：删除集合中指定的对象。注意：删除成功，集合的长度会改变。

removeAll(collection) ：删除部分元素。部分元素和传入Collection一致。

3）判断：

boolean contains(obj) ：集合中是否包含指定元素 。

boolean containsAll(Collection) ：集合中是否包含指定的多个元素。

boolean isEmpty()：集合中是否有元素。 

4）获取：

int size()：集合中有几个元素。

5）取交集：

boolean  retainAll(Collection) ：对当前集合中保留和指定集合中的相同的元素。如果两个集合元素相同，返回flase；如果retainAll修改了当前集合，返回true。

6）获取集合中所有元素：

Iterator  iterator()：返回一个迭代器

7）将集合变成数组：

toArray();

注：集合中存储的都是对象的引用（地址）。

 

3、Iterator接口

    Iterator迭代器：是一个接口。每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口。

    也就说，只要通过该接口就可以取出Collection集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。

作用：用于取集合中的元素。

 

1）迭代器常见方法

 boolean

hasNext()  如果仍有元素可以迭代，则返回 true。

 E

next()   返回迭代的下一个元素。

 void

remove()  从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

2）迭代器使用方法 

Iterator it = coll.iterator();//获取容器中的迭代器对象

代码示例：

public static void main(String[] args) {

Collection list = new ArrayList();//创建一个集合对象

list.add("abc0");//添加元素

list.add("abc1");

list.add("abc2");

//方法一

Iterator it = coll.iterator();//获得迭代器

while(it.hasNext()){

System.out.println(it.next());

}

//方法二

for(Iterator it = coll.iterator();it.hasNext(); ){

System.out.println(it.next());

}

}

3）使用迭代要注意的事项

    a) 迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。

    b)迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

    c)迭代器的next方法返回值类型是Object，所以要记得类型转换。

 

4、 List接口

List本身是Collection接口的子接口，具备了Collection的所有方法。现在学习List体系特有的共性方法，查阅方法发现List的特有方法都有索引，这是该集合最大的特点。

1）list体系： 

List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。

|--ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快。

|--LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。

|--Vector：底层的数据结构就是数组，线程同步的，Vector无论查询和增删都巨慢。

 

 2）list集合的特有方法：List集合支持对元素的增、删、改、查。

a)添加：

    add(index,element) ：在指定的索引位插入元素。

    addAll(index,collection) ：在指定的索引位插入一堆元素。

b)删除：

    remove(index) ：删除指定索引位的元素。 返回被删的元素。

c)获取：

    Object get(index) ：通过索引获取指定元素。

    int indexOf(obj) ：获取指定元素第一次出现的索引位，如果该元素不存在返回-1；所以，通过-1，可以判断一个元素是否存在。

    int lastIndexOf(Object o) ：反向索引指定元素的位置。

    List subList(start,end) ：获取子列表。

d)修改：

    Object set(index,element) ：对指定索引位进行元素的修改。

    e)获取所有元素：

    ListIterator listIterator()：list集合特有的迭代器。

 

3）ListIterator

    ListIterator是List集合特有的迭代器。

    ListIterator it = list.listIterator;//取代Iterator it = list.iterator;

方法摘要

 void

add(E e) 将指定的元素插入列表（可选操作）。

 boolean

hasNext() 以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。

 boolean

hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。

 E

next() 返回列表中的下一个元素。

 int

nextIndex() 返回对 next 的后续调用所返回元素的索引。

 E

previous() 返回列表中的前一个元素。

 int

previousIndex() 返回对 previous 的后续调用所返回元素的索引。

 void

remove() 从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。

 void

set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

 

4）可变长度数组的原理：

    当元素超出数组长度，会产生一个新数组，将原数组的数据复制到新数组中，再将新的元素添加到新数组中。

    ArrayList：是按照原数组的50%延长。构造一个初始容量为 10 的空列表。

    Vector：是按照原数组的100%延长。

         注意：对于list集合，底层判断元素是否相同，其实用的是元素自身的equals方法完成的。所以建议元素都要复写equals方法，建立元素对象自己的比较相同的条件依据。

 

5）LinkedList：的特有方法。

a）添加

    addFirst();//添加一个元素到链表开头

    addLast();//添加一个元素到链表末尾

    在jdk1.6以后。

    offerFirst();

    offerLast();

b）获取

    getFirst()://获取链表中的第一个元素。如果链表为空，抛出NoSuchElementException;

    getLast();//获取链表中的最后一个元素。如果链表为空，抛出NoSuchElementException;

    在jdk1.6以后。

    peekFirst();获取链表中的第一个元素。如果链表为空，返回null。

    peekLast();

c）删除

    removeFirst()：获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，抛出NoSuchElementException

    removeLast();

    在jdk1.6以后。

    pollFirst();获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，返回null。

    pollLast();

6）枚举Enumeration

    枚举：是Vector特有的取出方式。Vector有三种取出方式。其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

特有方法：

    addElement(obj);//添加元素，相当于add(obj);

    Enumerationelements();//Vector特有取出方式(枚举)

    hasMoreElements();//相当于Iterator的hasNext()方法

    nextElements();//相当于Iterator的next()方法

代码示例：

Vector v=new Vector();  

for(Enumeration e=v.elements();e.hasMoreElements();){  

System.out.println(e.nextElements());  

}  

 

5、Set接口

Set接口中的方法和Collection中方法一致的。Set接口取出方式只有一种，迭代器。

1）  Set体系：

Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。

|--HashSet：底层数据结构是哈希表，线程是不同步的。无序，高效；

HashSet集合保证元素唯一性：通过元素的hashCode方法，和equals方法完成的。首先判断元素的hashCode值是否相同。如果相同，则继续判断元素的equals方法，是否为true。

              |--LinkedHashSet：有序，hashset的子类。

|--TreeSet：对Set集合中的元素的进行指定顺序的排序。不同步。TreeSet底层的数据结构就是二叉树。

TreeSet保证元素唯一性的依据：compareTo方法。

 

2）HashSet

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

       可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

代码示例：

/*

往hashSet集合中存入自定对象

姓名和年龄相同为同一个人，重复元素。

*/

import java.util.*;

public class HashSetTest {

         publicstatic void main(String[] args) {

                   HashSeth=new HashSet();  //创建集合对象，注意set添加的元素是无序的

                   /*    

                   添加集合元素，同时会调用复写的hashCode方法，在内存中形成对象的哈希值.

                   HashSet中特有的add方法自动调用复写的equals方法：首先判断元素的hashCode值是否相同。若不同，直接添加元素。若相同，会继续判断元素的equals方法，

                   元素相同返回false,不添加元素;元素不同，返回true，添加元素。

                   */

                   //进行比较，排除相同元素，取出集合中的不同元素，

                   h.add(newPerson("童话故事",19));

                   h.add(newPerson("白雪公主",19)); 

                   h.add(newPerson("黑马    ",22));

                   h.add(newPerson("小矮人一",100));

                   h.add(newPerson("白雪    ",100));

                   h.add(newPerson("小矮人一",100));

                   h.add(newPerson("黑马    ",22));

                   h.add(newPerson("假白雪  ",100));

                   h.add(newPerson("白雪公主",19));

                   //利用迭代器取集合中的元素

                   Iterator<Person>it=h.iterator();

                   while(it.hasNext()){

                            //输出集合的下一个元素，此时元素默认object对象，需向下转型输出。

                            Personp=(Person)it.next();

                            System.out.println(p.getName()+"__________ "+p.getAge());

                   }

         }

}

class Person{

         privateString name;

         privateint age;

         Person(){}

         Person(Stringname,int age){

                   this.name=name;

                   this.age=age;

         }

         //重写hashCode方法

         publicint hashCode(){

                   returnname.hashCode()+age*33;

                   //为了保证哈希值的唯一性，age需要乘以一个非0非1的int型整数

         }

         //重写equals方法

         publicboolean equals(Object obj){

                   if(!(objinstanceof Person))

                            returnfalse;

                   Personp = (Person)obj;//向下转型

                   returnthis.name.equals(p.name) && this.age == p.age;

                  

         }

         publicvoid setName(String name){

                   this.name=name;

         }

         publicString getName(){

                   returnname;

         }

         publicvoid setAge(int age){

                   this.age=age;

         }

         publicint getAge(){

                   returnage;

         }

}

 

3）TreeSet:

用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。

如果元素不具备比较性，在运行时会发生ClassCastException异常。

所以需要元素实现Comparable接口，强制让元素具备比较性，复写compareTo方法。

依据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。

TreeSet方法保证元素唯一性的方式：就是参考比较方法的结果是否为0，如果return 0，视为两个对象重复，不存。

         注意：在进行比较时，如果判断元素不唯一，比如，同姓名，同年龄，才视为同一个人。

在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。

 

TreeSet集合排序有两种方式

a)      自然排序

让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。

代码示例：

/*

往TreeSet集合中存储自定义对象学生。

想按照学生的年龄进行排序。

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

*/

class TreeSetDemo {

         publicstatic void main(String[] args) {

                   TreeSetts = new TreeSet();

                   ts.add(newStudent("lisi02",22));

                   ts.add(newStudent("lisi007",20));

                   ts.add(newStudent("lisi09",19));

                   ts.add(newStudent("lisi08",19));

                   ts.add(newStudent("lisi007",20));

                   ts.add(newStudent("lisi02",40));

                   Iteratorit = ts.iterator();//遍历打印

                   while(it.hasNext()){

                            Studentstu = (Student)it.next();

                            System.out.println(stu.getName()+"..."+stu.getAge());

                   }

         }

}

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

         privateString name;

         privateint age;

         Student(Stringname,int age){

                   this.name= name;

                   this.age= age;

         }

         publicint compareTo(Object obj){//复写compereTo方法

                   if(!(objinstanceof Student))

                            thrownew RuntimeException("不是学生对象");

                   Students = (Student)obj;

                   if(this.age>s.age)

                            return1;

                   if(this.age==s.age){//如果年龄相同，则比较次要条件

                            returnthis.name.compareTo(s.name);

                   }

                   return-1;

         }

         publicString getName(){

                   returnname;

         }

         publicint getAge(){

                   returnage;

         }

}