黑马程序员系列第四篇 集合（1）

ASP.Net+Android+IOS开发  、Net培训、期待与您交流！

（前言：本篇文章主要依据毕向东老师的课程视频整理而成，如要详细学习，请观看毕老师视频  百度网盘链接地址：http://pan.baidu.com/s/1o6mwDzO）

目录：1、集合概述      2、Collection、Iterator接口     3、List接口与其ArrayList、LinkedList、Vector子类   4、Set接口及其HashSet、TreeSet子类

1、集合概述 

下图为JDK中集合的框架设计图，我们主要使用的集合为黑色方框中的四种集合。

数组和集合的不同：集合中对象数量不定，而数组中对象数量必须是确定的。

ArrayList  底层数据存储结构是数组结构   特点：查询速度快，增删稍慢，线程不同步

LinkedList 底层数据结构是链表结构        特点：查询稍慢，增删快

Vector      底层是数组数据结构             特点：都很慢，线程同步，出现最早，已经被ArrayList替代了现在很少用

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

HashSet   底层数据结构是hash表

TreeSet    底层数据结构是二叉树红黑树

2、Collection、Iterator接口 

迭代器 Iterator  是为了方便集合操作元素而定义。而且专门为List集合定义了特有的迭代器ListIterator（为Iterator接口的子接口）

注意：使用迭代器时，不可以再通过集合对象的方法操作集合中的对象，会发生ConcurrentModification异常。

两个基本接口中的方法很重要

代码演示了Collection方法的使用以及遍历的操作方式（例子很普通，主要看下遍历的操作方法）

public class CollectionTest {
    public static void main(String[] args) {
        List d=new ArrayList();//新建集合、向集合中添加对象
        d.add("jake"); 
        d.add("alean");
        d.add("sam");           
        iteratorTest(d);
    }
    //如何使用ListIterator进行遍历操作对象
    public static void iteratorTest(List c){
           ListIterator it=c.listIterator();
           while(it.hasNext()){
               //ListIterator中添加
               if(it.next()!=null){  
                   it.add("nanjing");
               }
//               ListIterator中修改
//               if(it.next()=="jake"){
//                   it.set("beokj");
//               }             
           }
           System.out.println(c);
    }
    //collection接口方法使用
    public static void collectionMethods(){
        Collection c=new ArrayList();
        Collection d=new ArrayList();
        //增加
        d.add("jake"); d.add("alean");d.add("sam");
        c.addAll(d);
        //删除
        //c.remove("jake");
        //c.removeAll(c);
        //c.clear();
        System.out.println(c.isEmpty());
        System.out.println(c+":size="+c.size());
    }
}

3、List接口与其ArrayList、LinkedList、Vector子类

      ArrayList中涉及到比较集合中对象是否相同中用到的底层方法是集合中对象的equals()方法

      LinkedList中的方法  JDK1.6以后出现了替代getFirst()getLast() emoveFirst() emoveLast()方法的

      offerFirstofferLastpeekFirst()peekLast()新方法，新方法的优势是集合中没有元素了不会出现NoSuchElementException异常

      Vector  有特有的枚举方式取数据。其实枚举和迭代是一样的，枚举的名称和方法名称过长，所以被迭代器取代了，仅做了解

   ArrayList 演示代码（除去集合中的重复对象）

public class ArrayListDemo {

    public static void main(String[] args) {
        //新建一个ArrayList类型集合，向其中添加Person对象
         ArrayList al=new ArrayList();
        al.add(new Person("jack",12));
        al.add(new Person("jack",12));
        al.add(new Person("jack",11));
        al.add(new Person("jack2",12));
        al.add(new Person("jack",12));
          //除去al集合中的相同对象，打印结果
        System.out.println(singleElement(al));
    }
    //删除ArrayList集合中重复的元素
    public static ArrayList singleElement(ArrayList arrays){
         ArrayList al=new ArrayList();        
         Iterator ite=arrays.iterator();
         //通过while循环，在其中用ArrayList的contains方法判断是否重复
         while(ite.hasNext()){
             Object obj=ite.next();
             if(!al.contains(obj))
                 al.add(obj);
         }
        return al;
    }

}
//Person类
class Person{
    private String name;
    private int age;
    //共有全参构造方法
    public Person(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;
    }
    //重写equals方法，自定义比较的依据，这里我们定义对象的姓名、年龄都相同时，对象才相等
    public boolean equals(Object obj) {
        Person per=(Person)obj;         
            if(!(obj instanceof Person))                
                return false;
            else 
                return per.name.equals(name) && per.age==age;
    }
    //重写toString方法，便于查看程序的运行结果
    public String toString() {
        return name+"::"+age;
    }
    
}

LinkedList示例代码（用LinkedList模拟堆栈（先进后出）和队列（先进先出）数据结构）

public class LinkedListDemo {
    public static void main(String[] args) {
        
        Queue queue=new Queue();
        queue.set("红");
        queue.set("黄");
        queue.set("蓝");
        queue.set("紫");
        
        while(!queue.isNull()){
            System.out.println(queue.get());
        }
    }
}
//模拟队列，先进先出
class Queue{
    private LinkedList ll;
    public  Queue(){
         ll=new LinkedList();
     }
    public Object get(){
        return ll.removeFirst();
    }
    public void set(Object obj){
        ll.addLast(obj);
    }
    public boolean isNull(){
        return ll.isEmpty();
    }
}
//模拟堆栈-先进后出
class Stack{
    private LinkedList ll;
    public  Stack(){
         ll=new LinkedList();
     }
    public Object get(){
        return ll.removeLast();
    }
    public void set(Object obj){
        ll.addLast(obj);
    }
    public boolean isNull(){
        return ll.isEmpty();
    }
}

 4、Set接口及其HashSet、TreeSet子类

HashSet 中比较的底层原理 ： 先调用hashcode方法判断对象hash值是否相同，若相同，再调用对象那个的equels（）方法，判断对象是否相同

实际开发中，新建集合中的对象时，都要重写对象的hashcode和equals方法

TreeSet ： 可以对TreeSet集合中的元素进行自然排序。

第一种排序方式：比较原理是在集合元素中实现CompareTo接口

第二种排序方式：当元素自身不具备比较性时，可让集合具有比较性。方法：定义比较器（即实现了Comparator接口的类），将比较器对象作为参数传递给TreeSet集合的构造函数。

总结：两种方式中，第二种方式基于接口编程，拓展性好，比较常用。如果两种排序方式同时存在，系统使用第二种方式

 HashSet集合的代码示例

public class HashSetDemo{

    public static void main(String[] args) {
         
        HashSet hs=new HashSet();
        hs.add(new Persons("Tom1",24));    
        hs.add(new Persons("Tom1",25));  
        hs.add(new Persons("Tom1",24));  
        //遍历器来查询集合中对象
        Iterator ite=hs.iterator();
        while(ite.hasNext())
            System.out.println(ite.next());
    }
}
//Person类
class Persons{
    private String name;
    private int age;
    //共有全参构造方法
    public Persons(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;
    }
    //重写hashCode方法，自己定义判断
    public int hashCode(){
        return name.hashCode()+age;
    }
  //重写equals方法，自定义比较的依据，这里我们定义对象的姓名、年龄都相同时，对象才相等
    public boolean equals(Object obj) {
        Persons per=(Persons)obj;         
            if(!(obj instanceof Persons))                
                return false;
            else         
                return per.name.equals(name) && per.age==age;
    }
  //重写toString方法，便于查看程序的运行结果
    public String toString() {
        return name+"::"+age;
    }    
}

TreeSet代码示例

同时实现了两种排序方式。验证了两种排序方式共存是，系统采用何种方式

public class TreeSetDemo {
//两种比较方式共存，系统采用比较器的比较方式
    public static void main(String[] args) {
        
       TreeSet ts=new TreeSet(new comparator());
        ts.add(new Persont("bbama1",22));
        ts.add(new Persont("abama3",22));
        ts.add(new Persont("abama2",24));
        ts.add(new Persont("abama3",21));
        
        Iterator ite=ts.iterator();
        while(ite.hasNext()){
            System.out.println(ite.next());
        }
    }

}
//实现比较器，规定元素按照姓名排序，姓名相同的按年龄排序
class comparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        Persont p1=(Persont)o1;
        Persont p2=(Persont)o2;
        int i=p1.getName().compareTo(p2.getName());
        if(i==0)
            return p1.getAge()-p2.getAge();
        else return i;
    }    
}
//Person类，规定元素按照年龄排序，年龄相同的按姓名排序
class Persont implements Comparable<Persont>{
    private String name;
    private int age;
    //共有全参构造方法
    public Persont(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;
    }

  //重写toString方法，便于查看程序的运行结果
    public String toString() {
        return name+"::"+age;
    }
@Override
public int compareTo(Persont per) {
    if(age>per.age)
    return 1;
    if(age==per.age){
        return name.compareTo(per.name);
    }    
    else
        return -1;
}    
}

       初学者难免错误，欢迎评判指教，持续更正ing...........

ASP.Net+Android+IOS开发  、Net培训、期待与您交流！