【java】 Collection介绍
2016-05-03 11:06
656 查看
转载于:http://blog.csdn.net/itlwc/article/details/10148321
[plain] view
plain copy
子接口
Set,List
集合中只能放置对象的引用,不能放置原生数据类型,
我们需要使用原生数据类型的封装类才能加入到集合中
plain copy
Ordered排序,按照某种由具体情况决定的顺序排序,是后天指定的
Sorted排序,按照天然顺序进行排序,是先天指定的
plain copy
实现类包括
LinkedList,Vector,ArrayList
列表接口,继承与Collection,可以按索引的顺序访问,有索引的Collection
具有列表的功能,元素顺序均是按添加的先后进行排列的,
允许重复的元素,允许多个null元素
plain copy
package com.itlwc;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
List list = new ArrayList();
// 向列表的尾部追加指定的元素
list.add("lwc");
// 在列表的指定位置插入指定元素
list.add(1, "nxj");
// 追加指定 collection 中的所有元素到此列表的结尾
list.addAll(new ArrayList());
// 从列表中移除所有元素
list.clear();
// 如果列表包含指定的元素,则返回true
list.contains("nxj");
// 如果列表包含指定 collection 的所有元素,则返回 true
list.containsAll(new ArrayList());
// 比较指定的对象与列表是否相等
list.equals(new ArrayList());
// 返回列表中指定位置的元素
list.get(0);
// 返回列表的哈希码值
list.hashCode();
// 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.indexOf("lwc");
// 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.lastIndexOf("lwc");
// 如果列表不包含元素,则返回 true
list.isEmpty();
// 移除列表中指定位置的元素
list.remove(0);
// 移除列表中出现的首个指定元素
list.remove("lwc");
// 从列表中移除指定 collection 中包含的所有元素
list.removeAll(new ArrayList());
// 用指定元素替换列表中指定位置的元素
list.set(0, "lp");
// 返回列表中的元素数
list.size();
// 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图
list.subList(1, 2);
// 返回以正确顺序包含列表中的所有元素的数组
list.toArray();
// 返回以正确顺序包含列表中所有元素的数组
list.toArray(new String[] { "a", "b" });
}
}
plain copy
构造方法
public ArrayList()
public ArrayList(int initialCapacity)
public ArrayList(Collection c)
ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组
当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍+1,
然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,
当新数组无法容纳增加的元素,重复该过程
ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,
因为操作之后后续元素需要移动
plain copy
package com.itlwc;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("lwc");
list.add("nxj");
// 方法一
Iterator<String> ite1 = list.iterator();
while (ite1.hasNext()) {
String str = ite1.next();
System.out.println(str);
}
System.out.println("---------------------");
// 方法二(方法一的变形)
for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {
String str = ite2.next();
System.out.println(str);
}
System.out.println("---------------------");
// 方法三
for(String s : list){
System.out.println(s);
}
}
}
/*
打印结果:
lwc
nxj
---------------------
lwc
nxj
---------------------
lwc
nxj
*/
[plain] view
plain copy
向量,历史比较悠久,Java诞生就有了,特点与ArrayList相同,
不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都使用ArrayList
构造方法
public Vector()
public Vector(int initialCapacity)
public Vector(int initialCapacity,int capacityIncrement)
第一个参数是初始容量,第二个参数是当Vector满时的增量
public Vector(Collection c)
Vector也是依赖数组实现的
案例
[java] view
plain copy
package com.itlwc;
import java.util.Enumeration;
import java.util.Vector;
public class Test {
public static void main(String[] args) {
Vector v = new Vector();
v.add("123");
v.add("lwc");
v.add("你好");
// Vector转换为枚举
Enumeration e = v.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
}
[java] view
plain copy
Vector的子类
案例
[java] view
plain copy
package com.itlwc;
import java.util.Enumeration;
import java.util.Stack;
public class Test {
public static void main(String[] args) {
Stack stack = new Stack();
// 向栈里面压一个整数
stack.push(new Integer(123));
stack.push("lwc");
stack.push(new Double(88.88));
// 遍历
Enumeration items = stack.elements();
while (items.hasMoreElements()) {
System.out.print(items.nextElement() + " ");
}
System.out.println();
// 出栈
while (stack.size() != 0) {
System.out.print(stack.pop() + " ");
}
}
}
/*
打印结果:
123 lwc 88.88
88.88 lwc 123
*/
[plain] view
plain copy
LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,
因此有很好的插入和删除性能,但随机访问元素的性能很差
构造方法
public LinkedList()
public LinkedList(Collection c)
LinkedList类中有一个Entry内部类,Entry内部类包含3个部分向前的引用,向后的引用,数据
header.next = header.previous = header;
[java] view
plain copy
package com.itlwc;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
List link = new LinkedList();
link.add(123);
link.add("lwc");
link.add(8.8);
link.add("nxj");
link.add(520);
printList(link);
printReversedList(link);
}
private static void printList(List link) {
System.out.println("正序链表中的元素");
// 的到链表的迭代器,位置指向链头
ListIterator li = link.listIterator();
// 判断迭代器中是否有下一个元素
while (li.hasNext()) {
// 返回下个元素
System.out.print(li.next() + " ");
}
System.out.println();
}
private static void printReversedList(List link) {
System.out.println("逆向链表中的元素");
// 的到链表的迭代器,位置指向link.size()结尾
ListIterator li = link.listIterator(link.size());
// 判断迭代器中是否有前一个元素
while (li.hasPrevious()) {
// 返回前一个元素
System.out.print(li.previous() + " ");
}
System.out.println();
}
}
/*
打印结果:
正序链表中的元素
123 lwc 8.8 nxj 520
逆向链表中的元素
520 nxj 8.8 lwc 123
*/
[java] view
plain copy
package com.itlwc;
class Node {
Node previous;// 前驱
String data;// 数据
Node next;// 后驱
public Node(String data) {
this.data = data;
}
}
public class Test {
public static void main(String[] args) {
Node node1 = new Node("node1");
Node node2 = new Node("node2");
Node node3 = new Node("node3");
node1.next = node2;
node2.previous = node1;
node2.next = node3;
node3.previous = node2;
node3.next = node1;
node1.previous = node3;
// 增加node4
Node node4 = new Node("node4");
node1.next = node4;
node4.previous = node1;
node4.next = node2;
node2.previous = node4;
// 删除node4
node1.next = node2;
node2.previous = node1;
node4.previous = null;
node4.next = null;
}
}
[plain] view
plain copy
依赖应该尽量在抽象层进行,避免在具体层进行,
在实际开发中尽量使用接口类型的引用,避免采用具体类型的引用
案例
[java] view
plain copy
package com.itlwc;
import java.util.LinkedList;
import java.util.List;
public class Test {
//如果我们需要传入参数是ArrayList就需要改动代码
public void printLinkedList(LinkedList ll){
System.out.println(ll);
}
//如果我们传入参数是List的子类,我们不需要改动代码,灵活性大
public void printList(List l){
System.out.println(l);
}
}
[java] view
plain copy
package com.itlwc;
import java.util.Arrays;
import java.util.List;
public class Test {
public static void main(String[] args) {
String[] str = { "l", "w", "c" };
//使用Java类库中java.util.Arrays类的静态方法asList()
List l = Arrays.asList(str);
System.out.println(str);
}
}
/*
打印结果:
[l, w, c]
*/
[plain] view
plain copy
ArrayList底层采用数组实现,LinkedList底层采用双链表实现
如果为列表增加对象
ArrayList是ArrayList底层数组维护的,LinkedList是LinkedList底层Entry对象维护的
LinkedList底层Entry结构
Entry{
Entry previous;
Object element;
Entry next;
}
其中element就是我们添加的元素,最后将生成的Entry对象加入到链表中
插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好
[java] view
plain copy
package com.itlwc;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
public class Test {
public static void main(String[] args) {
Map<Integer, String> map1 = new HashMap<Integer, String>();
map1.put(new Integer(1), "lwc");
map1.put(new Integer(2), "nxj");
Map<Integer, String> map2 = new HashMap<Integer, String>();
map2.put(new Integer(3), "tom");
map2.put(new Integer(4), "cat");
List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();
list.add(map1);
list.add(map2);
// 方法一
Iterator<Map<Integer, String>> ite1 = list.iterator();
while (ite1.hasNext()) {
Map<Integer, String> m = ite1.next();
System.out.println(m);
}
System.out.println("-----------------------------");
// 方法二(方法一的变形)
for (Iterator<Map<Integer, String>> ite2 = list.iterator(); ite2.hasNext();) {
Map<Integer, String> m = ite2.next();
System.out.println(m);
}
System.out.println("-----------------------------");
// 方法三:
for (Map<Integer, String> m : list) {
System.out.println(m);
}
}
}
/*
打印结果:
{1=lwc, 2=nxj}
{3=tom, 4=cat}
-----------------------------
{1=lwc, 2=nxj}
{3=tom, 4=cat}
-----------------------------
{1=lwc, 2=nxj}
{3=tom, 4=cat}
*/
plain copy
实现类
HashSet,LinkedHashSet
子接口
SortSet
实现类
TreeSet
不包含重复元素,最多包含一个null,元素没有顺序
[plain] view
plain copy
HashSet不是Ordered也不是Sorted,存储对象引用时是按照哈希策略来实现的,
HashSet中是否存在一个对象是通过equals()和hashCode()协同判断
不保证顺序
构造方法
public HashSet()
public HashSet(int initialCapacity)
public HashSet(Collection c)
HashSet底层是使用HashMap实现的
HashSet的add()方法详解:
判断已经存储在集合中的对象hashCode值是否与增加对象的hashCode值一致
如果不一致,直接加进去
如果一致,再进行equals()比较
如果equals()返回true,对象已经存在不增加进去
如果equals()返回false,把对象增加进去
[plain] view
plain copy
LinkedHashSet是Ordered,采用双链表实现的
有固定顺序,也就是插入顺序
LinkedHashSet底层是使用LinkedHashMap实现的
构造方法
public LinkedHashSet()
public LinkedHashSet(int initialCapacity)
public LinkedHashSet(Collection c)
[plain] view
plain copy
保证迭代器按照元素递增顺序遍历的集合,可以按照元素的自然顺序进行排序
常用方法
Object first()
返回此有序集合中当前第一个(最小的)元素
Object last()
返回此有序集合中最后一个(最大的)元素
SortedSet headSet(Object toElement)
返回此有序集合的部分视图,其元素严格小于toElement
SortedSet tailSet(Object fromElement)
返回此有序集合的部分视图,其元素大于或等于fromElement
SortedSet subSet(Object fromElement,Object toElement)
返回此有序集合的部分视图,元素范围从fromElement(包括)到toElement(不包括)
Comparator comparator()
返回与此有序集合关联的比较器,如果使用元素的自然顺序,则返回 null
[java] view
plain copy
TreeSet是SortedSet接口的实现,元素不论以什么元素插入,在遍历的时候,都会以天然顺序遍历
TreeSet底层是使用TreeMap实现的
构造方法
public TreeSet()
public TreeSet(SortedSet s)
public TreeSet(int initialCapacity)
public TreeSet(Comparator<? super E>)
public TreeSet(Collection c)
因为TreeSet是带排序的,所以想要为TreeSet增加自定义类型,必须指定排序规则
[java] view
plain copy
package com.itlwc;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
TreeSet set = new TreeSet(new PersonComparator());
set.add(new Person("lwc", 80));
set.add(new Person("nxj", 70));
set.add(new Person("lp", 60));
set.add(new Person("fy", 75));
Iterator ite = set.iterator();
while (ite.hasNext()) {
Person p = (Person)ite.next();
System.out.println(p.name);
}
}
}
class Person {
String name;
int score;
public Person(String name, int score) {
this.name = name;
this.score = score;
}
}
class PersonComparator implements Comparator {
public int compare(Object o1, Object o2) {
Person p1 = (Person) o1;
Person p2 = (Person) o2;
return p1.score - p2.score;
}
}
[plain] view
plain copy
操作Collection类的工具类,类中方法都是静态的
[java] view
plain copy
package com.itlwc;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Test {
public static void main(String[] args) {
// 将所有元素从一个列表复制到另一个列表
Collections.copy(new ArrayList(), new ArrayList());
// 如果两个指定collection中没有相同的元素,则返回 true
Collections.disjoint(new ArrayList(), new ArrayList());
// 使用指定元素替换指定列表中的所有元素
Collections.fill(new ArrayList(), new Object());
// 返回指定 collection 中等于指定对象的元素数
Collections.frequency(new ArrayList(), new Object());
// 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1
Collections.indexOfSubList(new ArrayList(), new ArrayList());
// 根据元素的自然顺序,返回给定 collection 的最大元素
Collections.max(new ArrayList());
// //根据元素的自然顺序,返回给定 collection 的最大元素
Collections.min(new ArrayList());
// 使用另一个值替换列表中出现的所有某一指定值
Collections.replaceAll(new ArrayList(), "oldVal", "newVal");
// 反转指定列表中元素的顺序
Collections.reverse(new ArrayList());
// 返回一个比较器,它强行反转
Collections.reverseOrder();
// 返回一个比较器,它强行反转指定比较器的顺序
Collections.reverseOrder(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return 0;
}
});
// 使用默认随机源随机更改指定列表的序列
Collections.shuffle(new ArrayList());
// 根据元素的自然顺序对指定列表按升序进行排序
Collections.sort(new ArrayList());
// 根据元素的自然顺序对指定列表按降序进行排序
Collections.sort(new ArrayList(), Collections.reverseOrder());
// 在指定列表的指定位置处交换元素
Collections.swap(new ArrayList(), 1, 2);
}
}
Collection层次结构
Collection
[plain] viewplain copy
子接口
Set,List
集合中只能放置对象的引用,不能放置原生数据类型,
我们需要使用原生数据类型的封装类才能加入到集合中
Ordered与Sorted接口
[plain] viewplain copy
Ordered排序,按照某种由具体情况决定的顺序排序,是后天指定的
Sorted排序,按照天然顺序进行排序,是先天指定的
List
[plain] viewplain copy
实现类包括
LinkedList,Vector,ArrayList
列表接口,继承与Collection,可以按索引的顺序访问,有索引的Collection
具有列表的功能,元素顺序均是按添加的先后进行排列的,
允许重复的元素,允许多个null元素
List常用方法
[java] viewplain copy
package com.itlwc;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
List list = new ArrayList();
// 向列表的尾部追加指定的元素
list.add("lwc");
// 在列表的指定位置插入指定元素
list.add(1, "nxj");
// 追加指定 collection 中的所有元素到此列表的结尾
list.addAll(new ArrayList());
// 从列表中移除所有元素
list.clear();
// 如果列表包含指定的元素,则返回true
list.contains("nxj");
// 如果列表包含指定 collection 的所有元素,则返回 true
list.containsAll(new ArrayList());
// 比较指定的对象与列表是否相等
list.equals(new ArrayList());
// 返回列表中指定位置的元素
list.get(0);
// 返回列表的哈希码值
list.hashCode();
// 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.indexOf("lwc");
// 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1
list.lastIndexOf("lwc");
// 如果列表不包含元素,则返回 true
list.isEmpty();
// 移除列表中指定位置的元素
list.remove(0);
// 移除列表中出现的首个指定元素
list.remove("lwc");
// 从列表中移除指定 collection 中包含的所有元素
list.removeAll(new ArrayList());
// 用指定元素替换列表中指定位置的元素
list.set(0, "lp");
// 返回列表中的元素数
list.size();
// 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图
list.subList(1, 2);
// 返回以正确顺序包含列表中的所有元素的数组
list.toArray();
// 返回以正确顺序包含列表中所有元素的数组
list.toArray(new String[] { "a", "b" });
}
}
ArrayList
[plain] viewplain copy
构造方法
public ArrayList()
public ArrayList(int initialCapacity)
public ArrayList(Collection c)
ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组
当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍+1,
然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,
当新数组无法容纳增加的元素,重复该过程
ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,
因为操作之后后续元素需要移动
遍历ArrayList
[java] viewplain copy
package com.itlwc;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("lwc");
list.add("nxj");
// 方法一
Iterator<String> ite1 = list.iterator();
while (ite1.hasNext()) {
String str = ite1.next();
System.out.println(str);
}
System.out.println("---------------------");
// 方法二(方法一的变形)
for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {
String str = ite2.next();
System.out.println(str);
}
System.out.println("---------------------");
// 方法三
for(String s : list){
System.out.println(s);
}
}
}
/*
打印结果:
lwc
nxj
---------------------
lwc
nxj
---------------------
lwc
nxj
*/
Vector
[plain] viewplain copy
向量,历史比较悠久,Java诞生就有了,特点与ArrayList相同,
不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都使用ArrayList
构造方法
public Vector()
public Vector(int initialCapacity)
public Vector(int initialCapacity,int capacityIncrement)
第一个参数是初始容量,第二个参数是当Vector满时的增量
public Vector(Collection c)
Vector也是依赖数组实现的
案例
[java] view
plain copy
package com.itlwc;
import java.util.Enumeration;
import java.util.Vector;
public class Test {
public static void main(String[] args) {
Vector v = new Vector();
v.add("123");
v.add("lwc");
v.add("你好");
// Vector转换为枚举
Enumeration e = v.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
}
Stack
[java] viewplain copy
Vector的子类
案例
[java] view
plain copy
package com.itlwc;
import java.util.Enumeration;
import java.util.Stack;
public class Test {
public static void main(String[] args) {
Stack stack = new Stack();
// 向栈里面压一个整数
stack.push(new Integer(123));
stack.push("lwc");
stack.push(new Double(88.88));
// 遍历
Enumeration items = stack.elements();
while (items.hasMoreElements()) {
System.out.print(items.nextElement() + " ");
}
System.out.println();
// 出栈
while (stack.size() != 0) {
System.out.print(stack.pop() + " ");
}
}
}
/*
打印结果:
123 lwc 88.88
88.88 lwc 123
*/
LinkedList
[plain] viewplain copy
LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,
因此有很好的插入和删除性能,但随机访问元素的性能很差
构造方法
public LinkedList()
public LinkedList(Collection c)
LinkedList类中有一个Entry内部类,Entry内部类包含3个部分向前的引用,向后的引用,数据
header.next = header.previous = header;
遍历LinkedList
[java] viewplain copy
package com.itlwc;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
List link = new LinkedList();
link.add(123);
link.add("lwc");
link.add(8.8);
link.add("nxj");
link.add(520);
printList(link);
printReversedList(link);
}
private static void printList(List link) {
System.out.println("正序链表中的元素");
// 的到链表的迭代器,位置指向链头
ListIterator li = link.listIterator();
// 判断迭代器中是否有下一个元素
while (li.hasNext()) {
// 返回下个元素
System.out.print(li.next() + " ");
}
System.out.println();
}
private static void printReversedList(List link) {
System.out.println("逆向链表中的元素");
// 的到链表的迭代器,位置指向link.size()结尾
ListIterator li = link.listIterator(link.size());
// 判断迭代器中是否有前一个元素
while (li.hasPrevious()) {
// 返回前一个元素
System.out.print(li.previous() + " ");
}
System.out.println();
}
}
/*
打印结果:
正序链表中的元素
123 lwc 8.8 nxj 520
逆向链表中的元素
520 nxj 8.8 lwc 123
*/
自定义LinkedList结构
[java] viewplain copy
package com.itlwc;
class Node {
Node previous;// 前驱
String data;// 数据
Node next;// 后驱
public Node(String data) {
this.data = data;
}
}
public class Test {
public static void main(String[] args) {
Node node1 = new Node("node1");
Node node2 = new Node("node2");
Node node3 = new Node("node3");
node1.next = node2;
node2.previous = node1;
node2.next = node3;
node3.previous = node2;
node3.next = node1;
node1.previous = node3;
// 增加node4
Node node4 = new Node("node4");
node1.next = node4;
node4.previous = node1;
node4.next = node2;
node2.previous = node4;
// 删除node4
node1.next = node2;
node2.previous = node1;
node4.previous = null;
node4.next = null;
}
}
依赖倒置原理
[plain] viewplain copy
依赖应该尽量在抽象层进行,避免在具体层进行,
在实际开发中尽量使用接口类型的引用,避免采用具体类型的引用
案例
[java] view
plain copy
package com.itlwc;
import java.util.LinkedList;
import java.util.List;
public class Test {
//如果我们需要传入参数是ArrayList就需要改动代码
public void printLinkedList(LinkedList ll){
System.out.println(ll);
}
//如果我们传入参数是List的子类,我们不需要改动代码,灵活性大
public void printList(List l){
System.out.println(l);
}
}
将数组转换为列表
[java] viewplain copy
package com.itlwc;
import java.util.Arrays;
import java.util.List;
public class Test {
public static void main(String[] args) {
String[] str = { "l", "w", "c" };
//使用Java类库中java.util.Arrays类的静态方法asList()
List l = Arrays.asList(str);
System.out.println(str);
}
}
/*
打印结果:
[l, w, c]
*/
ArrayList VS LinkedList
[plain] viewplain copy
ArrayList底层采用数组实现,LinkedList底层采用双链表实现
如果为列表增加对象
ArrayList是ArrayList底层数组维护的,LinkedList是LinkedList底层Entry对象维护的
LinkedList底层Entry结构
Entry{
Entry previous;
Object element;
Entry next;
}
其中element就是我们添加的元素,最后将生成的Entry对象加入到链表中
插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好
List<Map>遍历
[java] viewplain copy
package com.itlwc;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
public class Test {
public static void main(String[] args) {
Map<Integer, String> map1 = new HashMap<Integer, String>();
map1.put(new Integer(1), "lwc");
map1.put(new Integer(2), "nxj");
Map<Integer, String> map2 = new HashMap<Integer, String>();
map2.put(new Integer(3), "tom");
map2.put(new Integer(4), "cat");
List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();
list.add(map1);
list.add(map2);
// 方法一
Iterator<Map<Integer, String>> ite1 = list.iterator();
while (ite1.hasNext()) {
Map<Integer, String> m = ite1.next();
System.out.println(m);
}
System.out.println("-----------------------------");
// 方法二(方法一的变形)
for (Iterator<Map<Integer, String>> ite2 = list.iterator(); ite2.hasNext();) {
Map<Integer, String> m = ite2.next();
System.out.println(m);
}
System.out.println("-----------------------------");
// 方法三:
for (Map<Integer, String> m : list) {
System.out.println(m);
}
}
}
/*
打印结果:
{1=lwc, 2=nxj}
{3=tom, 4=cat}
-----------------------------
{1=lwc, 2=nxj}
{3=tom, 4=cat}
-----------------------------
{1=lwc, 2=nxj}
{3=tom, 4=cat}
*/
Set
[plain] viewplain copy
实现类
HashSet,LinkedHashSet
子接口
SortSet
实现类
TreeSet
不包含重复元素,最多包含一个null,元素没有顺序
HashSet
[plain] viewplain copy
HashSet不是Ordered也不是Sorted,存储对象引用时是按照哈希策略来实现的,
HashSet中是否存在一个对象是通过equals()和hashCode()协同判断
不保证顺序
构造方法
public HashSet()
public HashSet(int initialCapacity)
public HashSet(Collection c)
HashSet底层是使用HashMap实现的
HashSet的add()方法详解:
判断已经存储在集合中的对象hashCode值是否与增加对象的hashCode值一致
如果不一致,直接加进去
如果一致,再进行equals()比较
如果equals()返回true,对象已经存在不增加进去
如果equals()返回false,把对象增加进去
LinkedHashSet
[plain] viewplain copy
LinkedHashSet是Ordered,采用双链表实现的
有固定顺序,也就是插入顺序
LinkedHashSet底层是使用LinkedHashMap实现的
构造方法
public LinkedHashSet()
public LinkedHashSet(int initialCapacity)
public LinkedHashSet(Collection c)
SortedSet接口
[plain] viewplain copy
保证迭代器按照元素递增顺序遍历的集合,可以按照元素的自然顺序进行排序
常用方法
Object first()
返回此有序集合中当前第一个(最小的)元素
Object last()
返回此有序集合中最后一个(最大的)元素
SortedSet headSet(Object toElement)
返回此有序集合的部分视图,其元素严格小于toElement
SortedSet tailSet(Object fromElement)
返回此有序集合的部分视图,其元素大于或等于fromElement
SortedSet subSet(Object fromElement,Object toElement)
返回此有序集合的部分视图,元素范围从fromElement(包括)到toElement(不包括)
Comparator comparator()
返回与此有序集合关联的比较器,如果使用元素的自然顺序,则返回 null
TreeSet
[java] viewplain copy
TreeSet是SortedSet接口的实现,元素不论以什么元素插入,在遍历的时候,都会以天然顺序遍历
TreeSet底层是使用TreeMap实现的
构造方法
public TreeSet()
public TreeSet(SortedSet s)
public TreeSet(int initialCapacity)
public TreeSet(Comparator<? super E>)
public TreeSet(Collection c)
因为TreeSet是带排序的,所以想要为TreeSet增加自定义类型,必须指定排序规则
TreeSet排序规则Comparator案例
[java] viewplain copy
package com.itlwc;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
TreeSet set = new TreeSet(new PersonComparator());
set.add(new Person("lwc", 80));
set.add(new Person("nxj", 70));
set.add(new Person("lp", 60));
set.add(new Person("fy", 75));
Iterator ite = set.iterator();
while (ite.hasNext()) {
Person p = (Person)ite.next();
System.out.println(p.name);
}
}
}
class Person {
String name;
int score;
public Person(String name, int score) {
this.name = name;
this.score = score;
}
}
class PersonComparator implements Comparator {
public int compare(Object o1, Object o2) {
Person p1 = (Person) o1;
Person p2 = (Person) o2;
return p1.score - p2.score;
}
}
Collections
[plain] viewplain copy
操作Collection类的工具类,类中方法都是静态的
Collections常用方法
[java] viewplain copy
package com.itlwc;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Test {
public static void main(String[] args) {
// 将所有元素从一个列表复制到另一个列表
Collections.copy(new ArrayList(), new ArrayList());
// 如果两个指定collection中没有相同的元素,则返回 true
Collections.disjoint(new ArrayList(), new ArrayList());
// 使用指定元素替换指定列表中的所有元素
Collections.fill(new ArrayList(), new Object());
// 返回指定 collection 中等于指定对象的元素数
Collections.frequency(new ArrayList(), new Object());
// 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1
Collections.indexOfSubList(new ArrayList(), new ArrayList());
// 根据元素的自然顺序,返回给定 collection 的最大元素
Collections.max(new ArrayList());
// //根据元素的自然顺序,返回给定 collection 的最大元素
Collections.min(new ArrayList());
// 使用另一个值替换列表中出现的所有某一指定值
Collections.replaceAll(new ArrayList(), "oldVal", "newVal");
// 反转指定列表中元素的顺序
Collections.reverse(new ArrayList());
// 返回一个比较器,它强行反转
Collections.reverseOrder();
// 返回一个比较器,它强行反转指定比较器的顺序
Collections.reverseOrder(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return 0;
}
});
// 使用默认随机源随机更改指定列表的序列
Collections.shuffle(new ArrayList());
// 根据元素的自然顺序对指定列表按升序进行排序
Collections.sort(new ArrayList());
// 根据元素的自然顺序对指定列表按降序进行排序
Collections.sort(new ArrayList(), Collections.reverseOrder());
// 在指定列表的指定位置处交换元素
Collections.swap(new ArrayList(), 1, 2);
}
}
相关文章推荐
- SSM整合最新版,spring4.2,springmvc4.2,mybatis3.2整合
- eclipse加速之禁用JS、jsp等文件的语法验证,eclipsejs
- Java多线程之使用volatile优雅地实现单例
- Spring ---annotation (重点)--AutoWired 不常用
- Java再学习-java集合(一)
- eclipse使用svn插件设置忽略文件的几种方式
- java 多线程 CountDownLatch用法
- Java基础知识IO流(File)
- Java学习_int和Integer的区别+包装类
- Spring AOP之通过xml定义aop
- JDK 源码解析 —— Semaphore
- 20150503-struts2入门-标签
- 在Java中如何遍历Map对象
- 深入理解Java的接口和抽象类
- java.net.ConnectException: Connection refused
- 深刻理解JAVA中堆栈和内存是如何分配地址;有助于学习Java语言。
- JAVA中引用数据类型的参数传递
- Java中List Set Map 是否有序等总结
- Spring 4集成 Quartz2(转)
- spark提交任务:java.net.UnknownHostException: cluster1