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