Java的集合框架

一、集合类的由来：

       对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。

       就使用集合容器进行存储。      

二、集合特点：

1，用于存储对象的容器。

2，集合的长度是可变的。

3，集合中不可以存储基本数据类型值。

集合容器因为内部的数据结构不同，有多种具体容器。

不断的向上抽取，就形成了集合框架。

 

三、框架的顶层Collection接口：

Collection的常见方法：

1，添加。

       boolean add(Object obj):

       boolean addAll(Collection coll):

      

2，删除。

       boolean remove(object obj):

       boolean removeAll(Collection coll);

       void clear();

      

3，判断：

       boolean contains(object obj):

       boolean containsAll(Colllection coll);

       boolean isEmpty():判断集合中是否有元素。

 

4，获取：

       int size():

       Iterator iterator():取出元素的方式：迭代器。

       该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。

       所以该迭代器对象是在容器中进行内部实现的。

       对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，

       也就是iterator方法。

      

       Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

       其实就是抓娃娃游戏机中的夹子！

             

5，其他：

       boolean retainAll(Collection coll);取交集。

       Object[] toArray():将集合转成数组。

      

四、Collection的两个常用子接口

       1、List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。

List:特有的常见方法：

1，添加

       void add(index,element);

       void add(index,collection);

 

2，删除；

       Object remove(index):

 

3，修改：

       Object set(index,element);

      

4，获取：

       Object get(index);

       int indexOf(object);

       int lastIndexOf(object);

       List subList(from,to);

      

List有一个共性特点就是都可以操作角标。

List集合是可以完成对元素的增删改查。

 

2、Set：元素不能重复,无序。

Set接口中的方法和Collection一致。

 

五、List接口的三个常用实现类

       1、Vector:内部是数组数据结构，是同步的。增删，查询都很慢！

       2、ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。

       ArrayList的演示代码如下：

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

 

 

public class ListDemo2

{

      

       public static void main(String[] args) {

 

              List list =new ArrayList();

//            show(list);

                           

              list.add("abc1");

              list.add("abc2");

              list.add("abc3");

             

              System.out.println("list:"+list);

              ListIterator it = list.listIterator();//获取列表迭代器对象

              //它可以实现在迭代过程中完成对元素的增删改查。

              //注意：只有list集合具备该迭代功能.

                           

              while(it.hasNext()){

                    

                     Object obj = it.next();

                    

                    if(obj.equals("abc2")){

                            it.set("abc9");

                     }

              }

             

              while(it.hasPrevious()){

                     System.out.println("previous:"+it.previous());

              }

              System.out.println("list:"+list);

}

             

       3、LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

    LinkedList的特有方法如下：

addFirst();

       addLast():

       jdk1.6

       offerFirst();

       offetLast();

      

       getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.

       getLast();

       jdk1.6

       peekFirst();//获取但不移除，如果链表为空，返回null.

       peekLast():

      

       removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.

       removeLast();

       jdk1.6

       pollFirst();//获取并移除，如果链表为空，返回null.

       pollLast();

       六、Set接口的两个常用实现类

       1、HashSet:内部数据结构是哈希表，是不同步的。

       如何保证该集合的元素唯一性呢？

       是通过对象的hashCode和equals方法来完成对象唯一性的。

       如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。

       如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。

       如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

             

       如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。

一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法以建立对象判断是否相同的依据。

示例代码如下：

 

 

import java.util.HashSet;

import java.util.Iterator;

 

public class HashSetTest {

 

       

        public static void main(String[] args) {

 

             

              HashSet hs =new HashSet();

             

             

              hs.add(new Person("lisi4",24));

              hs.add(new Person("lisi7",27));

              hs.add(new Person("lisi1",21));

              hs.add(new Person("lisi9",29));

              hs.add(new Person("lisi7",27));

             

             

              Iterator it = hs.iterator();

             

              while(it.hasNext()){

                     Person p = (Person)it.next();

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

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

              }

        }

 

}

 

class Person   {

 

        private String name;

        private int age;

       

       

       

        public Person(String name,int age) {

             

              this.name = name;

              this.age = age;

        }

       

        public int hashCode() {

             

              return name.hashCode()+age*27;

 

        }

 

        public boolean equals(Object obj) {

             

              if(this == obj)

                    return true;

              if(!(obj instanceof Person))

                    throw new ClassCastException("类型错误");

             

              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集合中的元素进行排序。是不同步的。

               判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。

                           

       TreeSet对元素进行排序的方式一：

让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

              如果不要按照对象中具备的自然顺序进行排序或者对象中不具备自然顺序。怎么办？

              TreeSet集合第二种排序方式二：

                让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。

              将该类对象作为参数传递给TreeSet集合的构造函数。