Java 集合
Collection<<interface>>
├List<<interface>>
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set<<interface>>
└HashSet
Map<<interface>>
├Hashtable
├HashMap
└WeakHashMap
1. Collection 和 Collections的区别
java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
java.util.Collections 是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作
class Demo {
public Demo() {}
public static void main(String[] args){
ArrayList c = new ArrayList();
for (int i = 0; i < 3; i++) {
c.add(new Integer(i));
}
c.add("11");
c.add("22");
c.add("33");
Iterator it = c.iterator();
System.out.println("排序前的输出：\n");
for (int i = 0; i < c.size(); i++) {
System.out.println("" + c.get(i));
}
Collections.shuffle(c, new Random());
System.out.println("排序后的输出：\n");
while (it.hasNext()) {
System.out.println("" + it.next());
}
}
}
2. HashMap和Hashtable的区别
Hashtable继承自Dictionary类, size()表示包含了多少元素；isEmpty()判断是否包含了元素；put(Object key, Object value)添加一个值；get(Object key)获得与某个键对应的值；而remove(Object Key)从列表中删除“键－值”对。还可以使用枚举技术：keys()产生对键的一个枚举（Enumeration）；而elements()产生对所有值的一个枚举。这便是一个Dictionary（字典）的全部。
(1) 继承和实现区别
Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。
(2) 线程安全不同
HashTable的方法是同步的，HashMap是未同步，所以在多线程场合要手动同步HashMap。HashMap效率高
(3) 对null的处理不同
HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)。
HashTable 不允许null值,编译期不会检查，运行期会出现空指针异常。HashMap允许 null值是指可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。
(4) 方法不同 HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。
(5) HashTable使用Enumeration，HashMap使用Iterator。
(6) HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。
HashTable测试
public static void main(String ar()[]) {
Hashtable hash = new Hashtable();
hash.put("abc", "1");
hash.put("ddd", "1");
hash.put("asdf", "2");
// hash.put("asdfsad", null); NullPointerException
Enumeration enumkey = hash.keys();
while (enumkey.hasMoreElements()) {
String str = (String) enumkey.nextElement();
System.out.println(str + " --- " + hash.get(str));
if ("1".equals(hash.get(str)))
hash.remove(str);
}
System.out.println("asdf:" + hash.get("asdf"));
enumkey = hash.elements();
while (enumkey.hasMoreElements()) {
String str = (String) enumkey.nextElement();
System.out.println(str );
}
}
HashMap测试
public static void main(String[] args) {
// 在HashMap中的对象是无序的
HashMap hm = new HashMap();
hm.put("a", "wpskl 1");
hm.put("b", "wpskl 3");
hm.put("c", "wpskl 5");
// 测试是否包含关键字"a"
System.out.println(hm.containsKey("a"));//true
System.out.println(hm.containsKey("d"));//false
System.out.println(hm.get("a")); //wpskl 1
System.out.println(hm.entrySet());
//[a=wpskl 1, c=wpskl 5, b=wpskl 3]
Iterator it = hm.entrySet().iterator();
while (it.hasNext()) {
System.out.println(it.next());
//a=wpskl 1,c=wpskl 5,b=wpskl 3
}
// Set keySet()返回关键字的集合
it = hm.keySet().iterator();
while (it.hasNext()) {
System.out.println(hm.get(it.next()));
//get(key)返回关键字对应的值
}
// Collection values()返回值的集合
it = hm.values().iterator();
while (it.hasNext()) {
System.out.println(it.next());
//wpskl 1,wpskl 5,wpskl 3
}
}
3. List总结(ArrayList,Vector, LinkedList)
List除了具有Collection接口必备的iterator()方法外，它还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历
ArrayList,Vector, LinkedList的存储性能和特性：
（1）ArrayList是最常用的List实现类，内部通过数组实现，它允许对元素进行快速随机访问。当数组大小不满足时会增加存储能力（默认大小是10，每次扩充为原来的1.5倍），将已有数组数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行拷贝，移动，代价比较高。因此，它适合随即查找和遍历，不适合插入合删除。
（2）Vector与ArrayList一样，也是通过数组实现的。它支持线程的同步，避免多线程同时写引起的不一致性。但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
List list = Collections.synchronizedList(new ArrayList());//创建同步的ArrayList
（3）LinkedList使用双向链表实现存储，很适合数据的动态插入和删除，随即访问和遍历速度比较慢。另外，它还提供了List没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。
（4）堆栈类继承Vector，Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Stack;
import java.util.Vector;
//演示List的使用 List是能维护元素的次序，它允许元素重复
public class TestList {
//初始化一个List
public static void init(List list) {
if (list != null) {
list.add("aaa");
list.add("ccc");
list.add("bbb");
list.add("eee");
list.add("ddd");
}
}
//输出List的内容
public static void output(List list) {
if (list != null) {// 根据列表下标遍历，使用list.size()获取列表中元素的个数
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
// 或者用迭代器遍历
Iterator it = list.iterator();
Object value = null;
while (it.hasNext()) {
value = it.next();
// System.out.println(value);
}//或
for(Iterator i=list.iterator();i.hasNext();){
value=i.next();
}
}
}
//使用ArrayList
public static void testArrayList() {
List list = new ArrayList();
init(list);
System.out.println("使用ArrayList: ");
output(list);
}
//使用Vector
public static void testVector() {
List list = new Vector();
init(list);
System.out.println("使用Vector: ");
output(list);
}
//使用LinkedList
public static void testLinkedList() {
List list = new LinkedList();
init(list);
System.out.println("使用LinkedList: ");
output(list);
}
public static void main(String[] args) {
TestList.testArrayList();
TestList.testVector();
TestList.testLinkedList();
List list = new ArrayList();
init(list);
// List支持元素重复
list.add("aaa");
list.add("bbb");
System.out.println("插入元素aaa, bbb后：");
output(list); //在末尾添加
list.add(1, "fff");// 指定元素插入的位置
System.out.println("在下标为1处插入fff后：");
output(list);
List list2 = new ArrayList();
list2.add("ggg");
list2.add("hhh");
// 将另一列表中的元素插入到列表中
list.addAll(list2);
System.out.println("添加list2的元素后：");
output(list);
// 判断列表是否包含某一元素
// 通过元素的equals方法，判断元素是否相等
System.out.println("list包含aaa? " + list.contains("aaa"));
// 判断列表中是否包含了另外一个列表中的所有元素。
System.out.println("list包含list2中的所有元素? " + list.containsAll(list2));
// 定位一个元素在列表中最先出现的位置System.out.println("aaa在list中第一次出现的位置: " + list.indexOf("aaa"));
// 定位一个元素在列表中最后出现的位置System.out.println("aaa在list中最后一次出现的位置: " + list.lastIndexOf("aaa"));
list.set(2, "xxx");// 更新列表中某个位置的元素值
System.out.println("更新位置为2的元素为xxx后：");
output(list);
// 删除列表中的某个元素，只删除第一次出现的那个
list.remove("aaa");
System.out.println("删除元素aaa后：");
output(list);
list.remove(1); // 删除列表中指定位置的元素
System.out.println("删除下标为1的元素后：");
output(list);
// 删除列表中的其他元素，只保留另一个列表中包含的元素
list.retainAll(list2);
System.out.println("删除除list2包含的以外的元素后：");
output(list);
// 删除列表中在另一列表中也包含了的元素
list.removeAll(list2);
System.out.println("删除list2包含的元素后：");
output(list);
list.clear();// 清空列表
// 判断列表中是否有数据
System.out.println("清空List后" + list.isEmpty());
init(list);
// 用列表中的某些元素构造一个新的列表
list2 = list.subList(1, 3);
System.out.println("用list的第1个到第3个元素构造一个新的List:");
output(list2);
// 用List特有的遍历器ListIterator遍历列表
// 与普通的Iterator不用，它允许两个方向遍历列表
ListIterator listIt = list.listIterator();
System.out.println("正向遍历列表");
while (listIt.hasNext()) {
System.out.print(listIt.next());
}
System.out.println("反向遍历列表");
while (listIt.hasPrevious()) {
System.out.print(listIt.previous());
}
// 也可以使用ListIterator从List中间插入和删除元素，
// 只能在遍历器当前位置添加和删除。
listIt.add("newadd");
System.out.println("ListIterator往列表中添加元素newadd后: ");
output(list);
listIt.next();
listIt.remove();
System.out.println("用ListIterator删除列表中元素后: ");
output(list);
// LinkedList自定义的方法
LinkedList linklist = new LinkedList();
init(linklist);
linklist.addFirst("fff");// 添加元素到列表头
System.out.println("把fff放到列表头后：");
output(linklist);
// 添加元素到列表尾
linklist.addLast("eee");
System.out.println("把eee放到列表尾后：");
output(linklist);
// 获取表头元素
System.out.println("列表头元素：" + linklist.getFirst());
// 获取表尾元素
System.out.println("列表尾元素：" + linklist.getLast());
linklist.removeFirst();// 删除列表头的元素
System.out.println("删除列表头元素后：");
output(linklist);
linklist.removeLast();// 删除列表尾的元素
System.out.println("删除列表尾元素后：");
output(linklist);
// 堆栈Stack类，它继承自Stack类
Stack myStack = new Stack();
myStack.push("aaa");// 插入元素，是插入到尾部
myStack.push("bbb");
myStack.push("ccc");
myStack.push("ddd");
myStack.push("aaa");
myStack.push("ddd");
System.out.println("堆栈中的元素是: ");
output(myStack);
System.out.println("堆栈尾部元素: " + myStack.peek());
System.out.println("弹出堆栈尾部元素: " + myStack.pop());
}
}4. Map
Map接口提供3种集合的视图：
map的key不能够重复，value可以
（1）key-value映射集合 — entrySet() 返回包含映射的Set视图。Set中的每个元素都是一个Map.Entry对象，可以使用getKey()和getValue()方法（还有一个setValue() 方法）访问后者的键元素和值元素
（2）key集合 — keySet() 包含键的 Set 视图。删除 Set 中的元素还将删除 Map 中相应的映射（键和值）
（3）value集合，values() 是值的 Collection 视图。删除 Collection 中的元素还将删除 Map 中相应的映射（键和值）
我们还必须获得一个Iterator对象，进而取得相应的key-value映射、key和value。
Iterator keyValuePairs = aMap.entrySet().iterator();
Iterator keys = aMap.keySet().iterator();//keys.remove();删除当前键值对
Iterator values = aMap.values().iterator();//values.remove();删除当前键值对
Map增删方法
clear() 从 Map 中删除所有映射
remove(Object key) 从 Map 中删除键和关联的值
put(Object key, Object value) 将指定值与指定键相关联
Map访问方法
get(Object key) 返回与指定键关联的值
containsKey(Object key) 如果 Map 包含指定键的映射，则返回true
containsValue(Object value) 如果此 Map 将一个或多个键映射到指定值，则返回 true
isEmpty() 如果 Map 不包含键-值映射，则返回 true
size() 返回 Map 中的键-值映射的数目
5. 集合排序
list，set，map都是可以使用collections.sort()排序，http://lavasoft.blog.51cto.com/62575/68380
Java API针对集合类型排序提供了两种支持：
java.util.Collections.sort(java.util.List)
java.util.Collections.sort(java.util.List, java.util.Comparator)
实现Comparable接口
/*实现Comparable接口*/
// 要排序的元素对象
public class Cat implements Comparable<Cat> {
private int age;
private String name;
public Cat(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String toString() {
return "Cat{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
public int compareTo(Cat o) {
return this.getAge() - o.getAge();
}
}
实现个性化排序测试
import java.util.*;
//通过实现Comparable接口实现个性化排序测试
public class TestComparable {
public static String outCollection(Collection coll) {
StringBuffer sb = new StringBuffer();
for (Object obj : coll) {
sb.append(obj + "\n");
}
System.out.println(sb.toString());
return sb.toString();
}
public static void main(String args[]) {
test();
test2();
}
public static void test() {
System.out.println("----------test()---------");
System.out.println("升序排序测试:");
List<Cat> listCat = new ArrayList<Cat>();
Cat cat1 = new Cat(34, "hehe");
Cat cat2 = new Cat(12, "haha");
Cat cat3 = new Cat(23, "leizhimin");
Cat cat4 = new Cat(13, "lavasoft");
listCat.add(cat1);
listCat.add(cat2);
listCat.add(cat3);
System.out.println("原集合为:");
outCollection(listCat);
System.out.println("调用Collections.sort(List<T> list)排序：");
Collections.sort(listCat);
outCollection(listCat);
System.out.println("逆序排列元素:");
Collections.sort(listCat, Collections.reverseOrder());
outCollection(listCat);
System.out.println("再次逆序排列元素:");
Collections.reverse(listCat);
outCollection(listCat);
System.out.println("添加一个元素后输出集合：");
listCat.add(cat4);
outCollection(listCat);
System.out.println("排列后输出:");
Collections.sort(listCat);
outCollection(listCat);
}
针对数组的排序测试
public static void test2(){
String[] strArray = new String[] {"z", "a", "C"};
System.out.println("----数组转换为列表-------");
List<String> list = Arrays.asList(strArray);
outCollection(list);
System.out.println("----列表转换为数组(1)-----");
String[] strArrayNew1 = list.toArray(strArray);
for(String str:strArrayNew1){
System.out.println(str);
}
System.out.println("---列表转换为数组(2)-----");
String[] strArrayNew2 = (String[]) list.toArray();
for(String str:strArrayNew2){
System.out.println(str);
}
System.out.println("----顺序排序列表------");
Collections.sort(list);
outCollection(list);
System.out.println("---按String实现的Comparator对象 String.CASE_INSENSITIVE_ORDER排序----");
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
outCollection(list);
System.out.println("-----倒序排序列表------");
Collections.sort(list, Collections.reverseOrder());
outCollection(list);
System.out.println("-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----");
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
outCollection(list);
System.out.println("-----反转列表元素的顺序------");
Collections.reverse(list);
outCollection(list);
}
}
Comparator接口排序
//要排序的元素对象
public class Person {
private int age;
private String name;
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
import java.util.Comparator;
//Person类的排序接口
public class PersonComparator implements
Comparator<Person> {
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
}
import java.util.*;
/* 结论:排序针对的是确切的集合对象,当集合对象的元素发生变化时,集合内的元素不会自动重新排序. */
public class TestComparator {
public static String outCollection(Collection coll) {
StringBuffer sb = new StringBuffer();
for (Object obj : coll) {
sb.append(obj + "\n");
}
System.out.println(sb.toString());
return sb.toString();
}
public static void main(String args[]) { test1(); }
public static void test1() {
System.out.println("----------test1()---------");
System.out.println("升序排序测试:");
List<Person> listPerson = new ArrayList<Person>();
Person person1 = new Person(34, "lavasoft");
Person person2 = new Person(12, "lavasoft");
Person person3 = new Person(23, "leizhimin");
Person person4 = new Person(13, "sdg");
listPerson.add(person1);
listPerson.add(person2);
listPerson.add(person3);
Comparator<Person> ascComparator = new PersonComparator();
//利用Collections静态工具方法对List进行排序
Collections.sort(listPerson, ascComparator);
outCollection(listPerson);
System.out.println("继续添加一个Person对象：");
listPerson.add(person4);
outCollection(listPerson);
System.out.println("添加一个对象后,重新排序:");
Collections.sort(listPerson, ascComparator);
outCollection(listPerson);
System.out.println("\n降序排序测试:");
Comparator<Person> descComparator = Collections.reverseOrder(ascComparator);
System.out.println("利用反转后的排序接口对象:");
Collections.sort(listPerson, descComparator);
outCollection(listPerson);
System.out.println("\n求最大最小元素测试:");
Person p_max = Collections.max(listPerson, ascComparator);
Person p_min = Collections.min(listPerson, ascComparator);
System.out.println("最大元素为:" + p_max.toString());
System.out.println("最小元素为:" + p_min.toString());
}
}
集合Map排序
Map<String, Integer> map = new TreeMap<String, Integer>();
map.put("j2se", 20);
map.put("j2ee", 10);
map.put("j2me", 30);
List<Map.Entry<String, Integer>> infoIds = new ArrayList<Map.Entry<String, Integer>>( map.entrySet());
//排序前
for (int i = 0; i < infoIds.size(); i++) {
String id = infoIds.get(i).toString();
System.out.println(id);
}
//排序
Collections.sort(infoIds, new Comparator<Map.Entry<String, Integer>>() {
public int compare(Map.Entry<String, Integer> o1,Map.Entry<String, Integer> o2) {
return (o2.getValue() - o1.getValue());
} });
//排序后
for (int i = 0; i < infoIds.size(); i++) {
String id = infoIds.get(i).toString();
System.out.println(id);
}
排序前：
j2ee=10
j2me=30
j2se=20
排序后：
j2me=30
j2se=20
j2ee=10
6. java中hashcode()和equals()
equals()和hashcode()这两个方法都是从object类中继承过来的。String 、Math、还有Integer、Double等都覆盖了equals和hashcode方法
equals()方法在object类中定义如下：默认是按地址值进行的比较(即对象的引用)
public boolean equals(Object obj) { return (this == obj); }
hashcode默认是对象的地址，由于在内存中的地址肯定是不同的，所以运算得到的hashcode一般不会相同。
hashCode的作用: hashCode()是用来产生哈希玛的，而哈希玛是用来在散列存储结构中确定对象的存储地址的。HashSet来说，在将对象存入其中时，通过被存入对象的 hashCode() 来确定对象在 HashSet 中的存储地址，通过equals()来确定存入的对象是否重复，hashCode() ，equals()都需要自己重新定义。
equals()相等的两个对象，hashcode()一定相等；
hashcode()相等，equals()可能相等，也可能不等
public class HashSetTest {
public static void main(String[] args) {
HashSet<Student> hs = new HashSet<Student>();
hs.add(new Student(1, "zhangsan"));
hs.add(new Student(2, "lisi"));
hs.add(new Student(3, "wangwu"));
hs.add(new Student(1, "zhangsan"));
Iterator<Student> it = hs.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
class Student {
int num;
String name;
Student(int num, String name) {
this.num = num;
this.name = name;
}
public int hashCode() {
return num*name.hashCode();
}
public boolean equals(Object o) {
Student s = (Student) o;
return num == s.num && name.equals(s.name);
}
public String toString() {
return num + ":" + name;
}
}
314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
