Java:Collection List Set

Java:集合

常见集合：List Set

List

    特点：元素是有序的，而且元素可以重复，因为该集合体系有索引。

    常见的三个子类：ArrayList、LinkedList、Verctor

    List集合判断元素是否相同，判断的依据是equals方法。

ArrayList

    底层数据结构为数组结构。特点：查询速度很快、修改元素方便，但插入元素、删除元素稍慢。

package Day14;

import java.util.*;

/*

* 去除ArrayList中的重复元素

* */

public class ArrayListTest {

    public static void main(String[] args) {

        ArrayList al = new ArrayList();

        al.add("java01");

        al.add("java02");

        al.add("java01");

        al.add("java03");

        al.add("java01");

        al.add("java02");

        System.out.println(singleElement(al));

    }

    public static ArrayList singleElement(ArrayList al){

        ArrayList newAl = new ArrayList();        

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

            Object obj = it.next();

            if (!newAl.contains(obj))

                newAl.add(obj);

        }

        return newAl;

    }

}

LinkedList

    底层用的是链表结构。特点：增删的速度很快、查询稍慢。

    特有方法：addFirst() addLast() getFirst() getLast() removeFirst() removeLast()，get只取元素不删除，而remove取出元素并删除元素，改变了集合的长度。removedFirst、removeLast方法，如果在遇到链表中没有元素时会出现NOSuchElementException。1.6版本以后出现了pollFirst方法，获取并移除列表的第一个元素，如果列表为空则返回Null。同样还有offerFirst、offerLast方法、peekFirst、peekLast方法。

package Day14;

import java.util.*;

/*

* 使用LinkedList模拟一个堆栈或者队列数据结构。

* 堆栈：先进后出 First In Last Out FILO

* 队列：先进先出 First In First Out FIFO

* */

public class LinkedListTest {

    public static void main(String[] args) {

        QueueDemo qd = new QueueDemo();

        qd.myAdd("java01");

        qd.myAdd("java02");

        qd.myAdd("java03");

        qd.myAdd("java04");

        

        while(!qd.isNull())

            System.out.println(qd.myGet());

    }

}

class QueueDemo{

    private LinkedList link;

    QueueDemo()

    {

        link = new LinkedList();

    }

    public void myAdd(Object obj)

    {

        link.addFirst(obj);

    }

    public Object myGet(){

        return link.removeLast();//如果模拟堆栈，这里removeFirst即可

    }

    public boolean isNull(){

        return link.isEmpty();

    }

}

Verctor

    底层数据结构为数组结构。和ArrayList不同的是，Vector是JDK 1.0出现的，而ArrayLIst是JDK 1.2出现的；Vector是同步的，而ArrayList是不同步的。

Colletion的常见方法

• 增：
  • add( )
  • addAll(Colletion c)，将集合c添加到新集合
• 删：
  • remove( )
  • removeAll(Collection b)，把和b集合的交集元素删除
  • clear( )，清空集合中的所有元素
• 获取：
  • size( )，获取集合中元素的个数（集合长度）
  • retainAll(Colletion b)，取和b集合中的交集，保留交集中的元素，删除其他元素（即把交集赋给原集合）
  • Iterator()，迭代器（去除集合中元素的方式），返回的是Iterator接口的子类对象

    Iterator it = al.iterator();

    • hasNext()，下一个节点是否有元素，it.hasNext();
    • next()，下一个节点中的元素，it.next();
• 判断：
  • contains()，是否包含某个元素
  • containsAll(Collettion c)，是否包含集合c中的所有元素
  • isEmpty()，集合是否为空

List中的（特有）方法

    凡是可以操作索引的方法都是该体系中的特有方法。

• 增：
  • add(index，element)
  • allAll(index，Colletion)
• 删：
  • remove(index，element)
• 改：
  • set(index，element)
• 查：
  • get(index)
  • subList(from，to)
  • listIterator()，列表迭代器

    ListIterator是Iterator的子接口。在迭代时不可以通过集合对象的方法操作集合的元素。因为会发生ConcurrentModificationException。所以在迭代时，只能通过迭代器的方法对元素进行判断、取出、删除的操作。如果想要其他的操作，例如增加元素，修改元素等，就需要起子接口，ListIterator。该接口是通过集合的listIterator方法获取。因为ListIterator有hasPervious和pervious方法，可以逆序获取集合元素。

  • indexOf()，获取元素的位置

Set

    特点：元素是无序的(存入和取出的顺序)，元素不可以重复，该集合体系没有索引。

    Set集合的功能和Collection的功能是一致的，没有特有方法。

    常见的子类：HashSet、TreeSet

    HashSet：底层数据结构是哈希表，线程非同步

package Day14;

import java.util.HashSet;

import java.util.Iterator;

public class HashSetDemo {

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        HashSet sh = new HashSet();

        //按序存入

        sh.add("java01");

        sh.add("java02");

        sh.add("java03");

        sh.add("java04");

        sh.add("java05");

        

        for (Iterator it = sh.iterator(); it.hasNext(); )

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

    }

}

运行结果是：

java05

java04

java03

java02

java01

hashSet判断元素是否存在是调用hashCode方法，如果两个元素的hashCode值一样，再使用equals方法判断是否"相等"，如果hashCode值一样，quals返回true说明是同一个元素或者相等的元素。

也就是说，如果对自定义的对象储存在hashSet中，需要重写equals方法，如果不想用Object类中的hashCode方法，则还需要重写hashCode方法。

TreeSet：底层数据结构是二叉树，可以对元素进行排序。

TreeSet排序的第一种方式：让元素自身具有比较性——元素实现Comparable接口，重写compareTo方法。这种排序方式叫做自然排序，也叫做默认排序。

package Day14;

import java.util.*;

/*

* 将学生类对象存储在TreeSet中

* */

public class TreeSetTest {

    public static void main(String[] args) {

        Student s1 = new Student("Jerry",26);

        Student s2 = new Student("Merry",25);

        Student s3 = new Student("Owen",27);

        Student s4 = new Student("Owen",25);

        

        TreeSet ts = new TreeSet();

        ts.add(s1);

        ts.add(s2);

        ts.add(s3);

        ts.add(s4);

        for (Iterator it = ts.iterator(); it.hasNext(); )

        {    

            Student stu = (Student)it.next();

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

        }

    }

}

class Student implements Comparable//实现Comparable接口

{

    private String name;

    private int age;

    Student(String name, int age)

    {

        this.name = name;

        this.age = age;

    }

    public int compareTo(Object obj)//重写compareTo方法

    {

        if (!(obj instanceof Student))

            throw new RuntimeException("对象不是学生类");

        Student s = (Student)obj;

        if (this.age==s.age)

            return this.name.compareTo(s.name);

        else return this.age-s.age;

        

    }

    public String getName()

    {

        return this.name;

    }

    public int getAge()

    {

        return this.age;

    }

}

运行结果：

Merry...25

Owen...25

Jerry...26

Owen...27

    TreeSet的第二种排序方式：当元素自身比具备比较性，或者元素的比较性是不需要的。这时就需要让集合具有比较性。

    TreeSet(Comparator<? super E> comparator)，构造一个空TreeSet，他根据指定比较器进行排序。也就是将比较器对象作为参数传递给TreeSet集合的构造函数。具体方法是，定义一个类实现Comparator接口，并覆盖comparte方法。

    当两种排序都存在时，以比较器Comparator为主。

package Day14;

import java.util.*;

public class TreeSetDemo2 {

    public static void main(String[] args) {

        TreeSet ts = new TreeSet(new MyComparator());

        ts.add(new Student("owen02",25));

        ts.add(new Student("owen002",23));

        ts.add(new Student("owen04",25));

        ts.add(new Student("owen06",26));

        ts.add(new Student("owen01",24));

        ts.add(new Student("owen02",27));

        ts.add(new Student("owen06",25));

        

        for (Iterator it = ts.iterator();it.hasNext();)

        {

            Student stu = (Student)it.next();

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

        }

    }

}

class Student

{

    private int age;

    private String name;

    Student(String name, int age)

    {

        this.name = name;

        this.age = age;

    }

    public String getName()

    {

        return name;

    }

    public int getAge()

    {

        return age;

    }

}

class MyComparator implements Comparator

{

    public int compare(Object o1,Object o2)

    {

        Student s1 = (Student)o1;

        Student s2 = (Student)o2;

        int num = s1.getName().compareTo(s2.getName());

        if (num==0)

            return s1.getAge()-s2.getAge();

        return num;

    }    

}

练习一：

    按照字符串长度排序

package Day14;

import java.util.*;

public class TreeSetTest2 {

    public static void main(String[] args) {

        TreeSet ts1 = new TreeSet(new StringLengthComparator());

        ts1.add("abc");

        ts1.add("z");

        ts1.add("aa");

        ts1.add("ab");

        ts1.add("vasdf");

        ts1.add("hahhah");

        for (Iterator it = ts1.iterator();it.hasNext();)

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

    }

}

class StringLengthComparator implements Comparator

{

    public int compare(Object o1, Object o2)

    {

        if(!(o1 instanceof String)||!(o2 instanceof String))

            throw new ClassCastException("不是String对象");

        String s1 = (String)o1;

        String s2 = (String)o2;

        if(s1.length()==s2.length())

            return s1.compareTo(s2);

        return s1.length()-s2.length();

    }

}