集合

Collections

◆所以的集合类都实现了collection接口。

ArrayList

◆集合中存放的是对象的引用而不是对象本身。

◆ArrayList是一个动态增长的数组，当我们调用无参构造函数时，默认会分配一个长度为10的数组，当空间不足时会动态增长为原来的1.5倍加1，然后将旧的数组复制到新的数组当中，当新的数组无法容纳更多的元素时，重复该过程。

◆可以用ArrayList(int initialCapacity)来初始化数组的容量，容量过大时，可以用trimToSize()方法挤压到刚好适合的大小，也可以用ensureCapacity(int minCapacity)来调整大小。

◆ArrayList是一个List接口的可变数组的实现，实现了List接口里面的所有方法，并且允许它的所有成员为null。它可以粗略的认为和Vector相当，但ArrayList不是同步的，Vector是同步的。

◆ArrayList底层维护的是一个

Private transient object[] elementData

常用的方法

package com.anllin.collections;

import java.util.ArrayList;

public class ArrayListTest

{

public static void main(String[] args)

{

// 当这样初始化时，会产生一个容量为10的类型为Object[]的elementData数组。ArrayList的内部实现方式。

// 当容量超过10时，会自动增长为（10*3）/2+1

ArrayList list = new ArrayList();

list.add("Hello");

list.add("World");

list.add("Welcome");

for (int i = 0; i < list.size(); i++)

{

System.out.println(list.get(i));

}

list.remove("Welcome");

list.add("World");

list.add("aaa");

list.add("bbb");

for (int i = 0; i < list.size(); i++)

{

System.out.println(list.get(i));

}

System.out.println(list.indexOf("World"));

System.out.println(list.indexOf("aaa"));

list.clear();

System.out.println(list.size());

}

◆对于ArrayList来说，当你没有使用泛型时，默认里面的成员类型都为Object类型，当你把int,String等类型放进去后，取出来时要进行相应的类型转化，否则程序运行时会报错。

package com.anllin.collections;

import java.util.ArrayList;

public class ArrayListTest3

{

public static void main(String[] args)

{

ArrayList list = new ArrayList();

list.add("anllin");

list.add(new Integer(23));

list.add(new Boolean(false));

list.add(new Long(1379446));

for (int i = 0; i < list.size(); i++)

{

System.out.println(list.get(i));

}

int age = ((Integer)list.get(1)).intValue();

System.out.println(age);

}

◆ 对于原生数据类型，不能直接把它添加到ArrayList中，要使用相应的包装类，使用泛型则可以避免这种问题。当调用toArray方法时，也不能直接用原生数据类型的包装类型进行转化，因为数组时存放的是对象，可能存的是不同的包装类型。如下：

package com.anllin.collections;

import java.util.ArrayList;

public class ArrayListTest4

{

public static void main(String[] args)

{

ArrayList list = new ArrayList();

list.add(new Integer(1));

list.add(new Integer(2));

list.add(new Integer(3));

list.add(new Integer(4));

list.add(new Integer(5));

list.add(new Integer(6));

list.add(new Integer(7));

int sum = 0;

for (int i = 0; i < list.size(); i++)

{

int val = ((Integer)list.get(i)).intValue();

sum += val;

}

System.out.println(sum);

//不能直接用Integer[] 转换，因为list.toArray()产生的是一个Object[]，数组里的每个元素不一定是Integer类型的。

Object[] arr = list.toArray();

for (int i = 0; i < arr.length; i++)

{

int val = ((Integer)arr[i]).intValue();

System.out.println(val);

}

◆如果你在集合中存放了自定义的类，那么打印时会调用Object.toString()方法，如果你想要打印自己想要的结果，就要重写toString()方法。

package com.anllin.collections;

import java.util.ArrayList;

public class ArrayListTest2

{

public static void main(String[] args)

{

ArrayList list = new ArrayList();

list.add(new Point(1,1));

list.add(new Point(2,2));

list.add(new Point(3,3));

list.add(new Point(4,4));

//自定义的类要输入自己想要的格式信息，必须重写toString()方法

System.out.println(list);

}

class Point

{

/**

* Properties

int x;

int y;

/**

* Constructor

* @param x

* @param y

public Point(int x,int y)

{

this.x = x;

this.y = y;

}

/**

* @category Method ref Object.toString() is overrided.

public String toString()

{

return "x = " + this.x + ", y = " + this.y;

}

◆对于ArrayList的删除操作，需要将后续的元素往前移动，代价比较高。

◆如果要经常对元素进行查找，用ArrayList比较好，如果要经常对元素插入或删除，用LinkedList比较好。

LinkedList

◆ LinkedList也实现了List接口，所以操作上和ArrayList相似，不同的是，它也实现了deque,queue接口，提供了get,insert,remove的其他一些细粒度的操作，我们可以用这些方法轻松的实现stack，queue和double-ended queue。

◆ 底层维护的是一个双链表，双链表中维护的是一个个Entry<E>结点类。

private static class Entry<E> {

E element;

Entry<E> next;

Entry<E> previous;

Entry(E element, Entry<E> next, Entry<E> previous) {

this.element = element;

this.next = next;

this.previous = previous;

}

基本的操作：

public class LinkedListTest

{

public static void main(String[] args)

{

LinkedList list = new LinkedList();

list.add("aaa");

list.add("bbb");

list.add("ccc");

list.add("ddd");

for(Iterator iterator = list.iterator(); iterator.hasNext();)

{

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

}

◆单链表结点类

public class Node

{

Node next;

String data;

public Node(String data)

{

this.data = data;

}

public String toString()

{

return this.data.toString();

}

◆单链表的一些基本操作

public class NodeTest

{

public static void main(String[] args)

{

Node node1 = new Node("node1");

Node node2 = new Node("node2");

Node node3 = new Node("node3");

//add nodes generate a cycle single Liked List.

node1.next = node2;

node2.next = node3;

node3.next = node1;

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

System.out.println("----------------");

Node node4 = new Node("node4");

//insert node4 into between node1 and node 2;

node1.next = node4;

node4.next = node2;

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

System.out.println("----------------");

//remove the node4

node1.next = node2;

node4.next = null;

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

System.out.println("----------------");

}

◆双链表结点类

public class DbNode

{

DbNode next;

String data;

DbNode priv;

public DbNode(String data)

{

this.data = data;

}

public String toString()

{

return this.data.toString();

}

◆双链表的操作

public class DbNodeTest

{

public static void main(String[] args)

{

DbNode node1 = new DbNode("node1");

DbNode node2 = new DbNode("node2");

DbNode node3 = new DbNode("node3");

DbNode node4 = new DbNode("node4");

//add nodes generates a cycle double Linked List;

node1.next = node2;

node1.priv = node3;

node2.next = node3;

node2.priv = node1;

node3.next = node1;

node3.priv = node2;

System.out.println(node1.priv.priv.priv);

System.out.println("------------------");

//insert node4 between node1 and node2

node1.next = node4;

node4.priv = node1;

node4.next = node2;

node2.priv = node4;

System.out.println(node1.priv.priv.priv);

System.out.println("------------------");

//remove the node4

node1.next = node2;

node2.priv = node1;

System.out.println(node1.priv.priv.priv);

System.out.println("------------------");

}

◆用LinkedList实现Stack

public class MyStack

{

private LinkedList list;

public MyStack()

{

list = new LinkedList();

}

public void push(Object obj)

{

if(null != obj)

{

list.addLast(obj);

}

public void pop()

{

list.removeLast();

}

public Object peek()

{

return list.getLast();

}

public boolean isEmpty()

{

return list.isEmpty();

}

public int size()

{

return list.size();

}

public String toString()

{

return this.list.toString();

}

◆测试stack

public class StackTest

{

public static void main(String[] args)

{

MyStack stack = new MyStack();

stack.push("aaa");

stack.push("bbb");

stack.push("ccc");

System.out.println(stack.peek());

System.out.println(stack);

stack.pop();

System.out.println(stack);

System.out.println(stack.isEmpty());

}

◆用LinkedList实现Queue

public class MyQueue

{

private LinkedList list;

public MyQueue()

{

list = new LinkedList();

}

public void inqueue(Object obj)

{

if(null != obj)

{

list.addLast(obj);

}

public Object dequeue()

{

return list.removeFirst();

}

public boolean isEmpty()

{

return list.isEmpty();

}

public int size()

{

return list.size();

}

public String toString()

{

return this.list.toString();

}

◆测试Queue

public class QueueTest

{

public static void main(String[] args)

{

MyQueue queue = new MyQueue();

queue.inqueue("aaa");

queue.inqueue("bbb");

queue.inqueue("ccc");

System.out.println(queue);

queue.dequeue();

System.out.println(queue);

System.out.println(queue.isEmpty());

}

HashSet

◆HashSet实现了Set接口，Set是一个不包含重复成员值的集合。只有要增加的成员在集合中满足为null时才会被增加成功（也就是说没有相同的值在集合中），所以通常要使自定义的类的对象添加时不重复的话，需要重写equals和hashCode方法。

◆Add方法的判断条件为(e==null ? e2==null : e.equals(e2))

◆HashSet底层维护的是HashMap的KeySet集合，KeySet符合Set接口的特征。KeySet用一个Entry[]来实现，程序会根据key所给的hashCode值来计算它的位置，如果该位置无元素，则将它插入，有元素就再散列，直到找到没有元素的位置。HashSet会根据初始容量和负载因子来计算数组的容量，快满时会扩容。

public class HashSetTest

{

public static void main(String[] args)

{

//HashSet底层是维护一个HashMap对象，所有的操作都通过这个对象来完成。

//HashSet是一个添加不包含重复值的无序集合。

HashSet set = new HashSet();

set.add("a");

set.add("b");

set.add("c");

set.add("d");

set.add("e");

set.add("f");

set.add("g");

set.add("h");

//这行不会添加成功，因为String类重写了hashCode方法。

System.out.println(set.add("a"));

for(Iterator tr = set.iterator(); tr.hasNext();)

{

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

}

◆ 对于HashSet来说，如果添加的对象的hashCode相同，则不会被添加，否则调用equals方法判断增加的值是否在集合中已经存在，如果为true不添加，否则添加。

◆ 当我们重写Object类的equals方法时，必须重写hashCode方法，反之亦然。

public class HashSetTest2

{

public static void main(String[] args)

{

//HashSet是否会重复添加相同的元素的关键是，hashCode是否相同。

HashSet set = new HashSet();

Person person = new Person("aaa");

set.add(person);

set.add(new Person("bbb"));

set.add(new Person("ccc"));

set.add(new Person("ddd"));

set.add(person);//不会被添加，因为person是同一对象，hashCode相同。

set.add(new Person("aaa"));//这里被添加了，因为这个对象的hashCode与前一个对象的hashCode不同。

//为了达到new Person("aaa")时，名称相同则不添加的目的，我们需要重写Object的equals和hashCode方法。

//重写后，则set.add(new Person("aaa"));就不会被执行了。

for (Iterator tr = set.iterator(); tr.hasNext();)

{

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

}

for (Iterator tr = set.iterator(); tr.hasNext();)

{

System.out.println(tr.next().hashCode());

}

public class HashSetTest3

{

public static void main(String[] args)

{

HashSet set = new HashSet();

set.add(new Integer(4));

set.add(new Integer(2));

set.add(new Integer(3));

set.add(new Integer(1));

//这行不会添加成功，因为它本身重写了equals和hashCode方法。

//只有hashCode不同时才会被添加成功。

boolean flag = set.add(new Integer(4));

System.out.println(flag);

for(Iterator tr = set.iterator(); tr.hasNext();)

{

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

}

TreeSet

◆TreeSet实现了SortedSet接口，这个接口提供了一个的有序的成员集合，它会按照自然升序排序或按照重写的comparator类的 compare方法进行排序。

TreeSet还实现了Set接口，所以也不能添加重复的成员，条件是hashCode不同时。

◆ 所有插入到SortedSet集合中的成员，必须实现comparable接口或重写comparator类的 compare方法。

◆ TreeSet底层可以简单的看成是一个TreeMap的KeySet集合。

public class TreeSetTest

{

public static void main(String[] args)

{

//TreeSet是一个可以排序的集合，当要使用不同的排序规则时，可以自定义一个Comparator类，然后当参数传递。

//TreeSet不能包含重复的成员，条件是hashCode不同。

//TreeSet底层维护的其实是一个TreeMap对象。

TreeSet set = new TreeSet();

set.add("c");

set.add("a");

set.add("e");

set.add("d");

set.add("f");

set.add("a");

System.out.println(set);

for(Iterator iter = set.iterator(); iter.hasNext();)

{

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

}

◆对于自定义的类，是没有排序规则的，所以在使用TreeSet添加时，必须先定制好排序规则。否则会报ClassCastException

public class TreeSetTest2

{

public static void main(String[] args)

{

TreeSet set = new TreeSet(new StudentScoreComparator());

Student s1 = new Student(10);

Student s2 = new Student(20);

Student s3 = new Student(30);

Student s4 = new Student(40);

Student s5 = new Student(50);

set.add(s1);

set.add(s2);

set.add(s3);

set.add(s4);

set.add(s5);

for(Iterator iter = set.iterator(); iter.hasNext();)

{

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

}

//自定义排序的规则，让所有的学生按考试成绩进行排序

class StudentScoreComparator implements Comparator

{

public int compare(Object arg0, Object arg1)

{

Student s1 = (Student)arg0;

Student s2 = (Student)arg1;

return s2.score-s1.score;

}

public class Student

{

int score;

public Student(int score)

{

this.score = score;

}

public String toString()

{

return "Student [score=" + score + "]";

}

◆对于系统提供的类型，一般已经指定好了排序规则，但是我们可以改变这个规则。

public class TreeSetTest3

{

public static void main(String[] args)

{

TreeSet set = new TreeSet(new StringComparator());

set.add("c");

set.add("a");

set.add("e");

set.add("d");

set.add("f");

set.add("b");

System.out.println(set);

}

//自定义排序规则让字符串按降序排列

class StringComparator implements Comparator

{

public int compare(Object arg0, Object arg1)

{

String str1 = (String)arg0;

String str2 = (String)arg1;

return str2.compareTo(str1);

}

Collections类

常用方法

public class CollectionTest

{

public static void main(String[] args)

{

LinkedList list = new LinkedList();

list.add(new Integer(8));

list.add(new Integer(-20));

list.add(new Integer(20));

list.add(new Integer(-8));

//用Collections.reverseOrder()可以实现对原有集合的反序排序。

//Collections是一个用于操作集合的类，Collection是一个接口，两者不一样

Comparator r = Collections.reverseOrder();

Collections.sort(list,r);

for(Iterator iter = list.iterator(); iter.hasNext();)

{

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

}

System.out.println("----------------");

//把原有集合的顺序打乱，每次运行都会产生不同的结果。

Collections.shuffle(list);

for(Iterator iter = list.iterator(); iter.hasNext();)

{

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

}

System.out.println("----------------");

//取得集合中的最大值和最小值

System.out.println(Collections.min(list));

System.out.println(Collections.max(list));

}

HashMap

◆HashMap是一个基于Map接口实现的散列表，集合中包含的是一个个键值对的对象，不能包含重复的键，一个键至少要映射一个值，值是可以重复的。它相当于Dictionary类。

◆Map接口提供了三种集合的视图，分别是Keys,values和key-value mappings

◆HashMap底层采有数组（Entry[]）加单链表(Entry->Entry)的形式实现。

static class Entry<K,V> implements Map.Entry<K,V> {

final K key;

V value;

Entry<K,V> next;

final int hash;

Entry(int h, K k, V v, Entry<K,V> n) {

value = v;

next = n;

key = k;

hash = h;

}

基本操作：

public class HashMapTest

{

public static void main(String[] args)

{

//HashMap是一个键值对映射的集合，底层维护的是一个Entry<k,v>对象。

//HashMap不包含重复的键，但是可以包含重复的值，一个键可以对应多个值，但是一个值不能对应多个健。

//HashMap是一个无序的集合。

HashMap map = new HashMap();

map.put("1","aaa");

map.put("2","bbb");

map.put("3","ccc");

map.put("4","ddd");

map.put("5","aaa");

//因为keys是不能重复的，所以它的类型是set

Set keys = map.keySet();

for(Iterator tr = keys.iterator(); tr.hasNext();)

{

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

}

System.out.println("---------------");

//因为values是可以重复的，所以它的类型是Collection

Collection values = map.values();

for(Iterator tr = values.iterator(); tr.hasNext();)

{

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

}

System.out.println("---------------");

map.remove("5");

for(Iterator tr = keys.iterator(); tr.hasNext();)

{

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

}

◆当使用自定义类时，如果不想在集合中添加重复的对象，可以重写equals和hashCode方法。当键相同时，后面的值会覆盖掉前面的值。

public class HashMapTest2

{

public static void main(String[] args)

{

//当使用定义类时，如果不想出现重复的对象，要重写equals和hashCode方法。

//换句话说，就是HashMap健不重复的关键是hashCode是否相同，而不是对象是否相同。

HashMap map = new HashMap();

map.put(new Person("Bob"),"1");

map.put(new Person("John"),"2");

map.put(new Person("Mike"),"3");

map.put(new Person("Kate"),"4");

//这行在插入时，会将已存在键的值替换掉。而不是象set那样不让它插入。

map.put(new Person("John"),"5");

Set keys = map.keySet();

for(Iterator tr = keys.iterator(); tr.hasNext();)

{

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

}

System.out.println("---------------");

Collection values = map.values();

for(Iterator tr = values.iterator(); tr.hasNext();)

{

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

}

System.out.println("---------------");

}

◆在命令行中输入单词，统计每个单词出现的次数

public class HashMapTest4

{

public static void main(String[] args)

{

HashMap map = new HashMap();

for(int i = 0; i<args.length; i++)

{

if(map.containsKey(args[i]))

{

Integer value = (Integer)map.get(args[i]);

value = new Integer(value.intValue()+ 1);

map.put(args[i],value);

}

else

{

map.put(args[i],new Integer(1));

}

Set keys = map.keySet();

System.out.println(map);

for(Iterator iter = keys.iterator(); iter.hasNext();)

{

String key = (String)iter.next();

int val = ((Integer)map.get(key)).intValue();

System.out.println(key + "=" + val);

}

◆返回一个键值对视图

public class HashMapTest5

{

public static void main(String[] args)

{

HashMap map = new HashMap();

map.put("a","aa");

map.put("d","dd");

map.put("c","cc");

map.put("b","bb");

//返回一个包含健值对的集合。类型是Map.Entry<k,v>.

Set set = map.entrySet();

for(Iterator iter = set.iterator(); iter.hasNext();)

{

Map.Entry entry = (Map.Entry)iter.next();

String key = (String)entry.getKey();

String val = (String)entry.getValue();

System.out.println(key + ":" + val);

}

TreeMap

◆TreeMap是一个基于NavigableMap接口实现的一个红黑树集合，可以按自然顺序或给定一个比较器进行排序。

◆一些基本的操作

public class TreeMapTest

{

public static void main(String[] args)

{

//TreeMap是一个有序的集合，不能包含重复的键，当插入相同键时，值会被替换，但是键只有一个。

//TreeMap底层维护的是一个Map.Entry<k,v>对象。

//当不想使用默认的排序方式时，可以使用Comparator创建自己的排序规则。

TreeMap map = new TreeMap();

map.put("a","aa");

map.put("b","bb");

map.put("c","cc");

map.put("d","dd");

map.put("e","ee");

map.put("e","ff");

Set set = map.entrySet();

for(Iterator iter = set.iterator(); iter.hasNext();)

{

Map.Entry entry = (Map.Entry)iter.next();

String key = (String)entry.getKey();

String val = (String)entry.getValue();

System.out.println(key + ":" + val);

}

◆使用TreeMap的一个简单的例子

/**

* 题目：随机生成50个数字（整数），每个数字的范围是[10，50]，统计每个数字出

现的次数以及出现次数最多的数字与它的个数，最后将每个数字及其出现次数打印

出来，如果某个数字出现次数为0，则不要打印它。打印时按照数字的升序排列。

* @author Administrator

public class TreeMapTest3

{

public static void main(String[] args)

{

//存储数字及其出现的次数（key为数字，value为出现次数）。

TreeMap map = new TreeMap();

Random rand = new Random();

for(int i = 0; i<50; i++)

{

Integer key = new Integer(rand.nextInt(41)+ 10);

if(map.containsKey(key))

{

Integer val = (Integer)map.get(key);

val = new Integer(val.intValue()+ 1);

map.put(key,val);

}

else

{

map.put(key,new Integer(1));

}

Set set = map.entrySet();

Collection vals= map.values();

int max = ((Integer)Collections.max(vals)).intValue();

//存储出现次数最多的数字

List list = new ArrayList();

for(Iterator iter = set.iterator(); iter.hasNext();)

{

Map.Entry entry = (Map.Entry)iter.next();

Integer key = (Integer)entry.getKey();

Integer val = (Integer)entry.getValue();

if(max == val.intValue())

{

list.add(key);

}

System.out.println(key + ":" + val);

}

System.out.println("----------------");

System.out.println("出现次数最多的是" + max + "次");

for(Iterator iter = list.iterator(); iter.hasNext();)

{

Integer val = (Integer)iter.next();

System.out.println(val);

}

◆当要想在TreeMap中添加自定义的类的对象时，要实现一个比较器，告诉TreeMap按什么排序。

public class TreeMapTest2

{

public static void main(String[] args)

{

TreeMap map = new TreeMap(new NameComparator());

map.put(new Person("Bob"),"1");

map.put(new Person("John"),"2");

map.put(new Person("Mike"),"3");

map.put(new Person("Kite"),"4");

map.put(new Person("Judy"),"5");

map.put(new Person("Judy"),"6");

Set set = map.entrySet();

for(Iterator iter = set.iterator(); iter.hasNext();)

{

Map.Entry entry = (Map.Entry)iter.next();

String key = ((Person)entry.getKey()).name;

String val = (String)entry.getValue();

System.out.println(key + ":" + val);

}

//实现自己的比较器

class NameComparator implements Comparator

{

public int compare(Object arg0, Object arg1)

{

Person p1 = (Person)arg0;

Person p2 = (Person)arg1;

return p2.name.compareTo(p1.name);

}

以前版本遗留下来的一些集合类

Vector

◆Vector与ArrayList相似，但是Vector是同步的。Vector底层实现也与ArrayList近似，只不是扩容是为原来容量的2倍。使用上没有多大的区别，现在已很少使用。

public class VectorTest

{

public static void main(String[] args)

{

Vector vector = new Vector();

vector.add("aaa");

vector.add("bbb");

vector.add("ccc");

for(int i = 0; i<vector.size(); i++)

{

System.out.println(vector.get(i));

}

Properties

◆Properties代表一个属性的持久化集合，它可以被保存到一个流中，也可以从一个流中加载。实现了Map<Object,Object>接口，继承自Hashtable<Object,Object>类。

◆可以调用load(Reader) / store(Writer, String)方法来将Properties对象存放到文件中。也可以调用　loadFromXML(InputStream) and storeToXML(OutputStream, String, String)来存取到一个xml文件中。

◆获取系统中的属性并打印出来

public class PropertiesTest

{

public static void main(String[] args)

{

Properties p = System.getProperties();

Set set = p.keySet();

for(Iterator iter = set.iterator(); iter.hasNext();)

{

String key = (String)iter.next();

String val = p.getProperty(key);

System.out.println(key + " : " + val);

}