集合
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");
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);
}
}
}
|