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();

}