Java - Collection

http://blog.csdn.net/itlwc/article/details/10148321

Java - Collection

2013-08-21 15:13 4389人阅读 评论(3) 收藏 举报

 分类：

JavaSE（30） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

Collection层次结构

Collection

[plain] view plain copy

  1. 子接口
  2. Set,List
  3. 集合中只能放置对象的引用,不能放置原生数据类型,
  4. 我们需要使用原生数据类型的封装类才能加入到集合中

Ordered与Sorted接口

[plain] view plain copy

  1. Ordered排序,按照某种由具体情况决定的顺序排序,是后天指定的
  2. Sorted排序,按照天然顺序进行排序,是先天指定的

List

[plain] view plain copy

  1. 实现类包括
  2. LinkedList,Vector,ArrayList
  3. 列表接口,继承与Collection,可以按索引的顺序访问,有索引的Collection
  4. 具有列表的功能,元素顺序均是按添加的先后进行排列的,
  5. 允许重复的元素,允许多个null元素

List常用方法

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. public class Test {
  5. public static void main(String[] args) {
  6. List list = new ArrayList();
  7. // 向列表的尾部追加指定的元素
  8. list.add("lwc");
  9. // 在列表的指定位置插入指定元素
  10. list.add(1, "nxj");
  11. // 追加指定 collection 中的所有元素到此列表的结尾
  12. list.addAll(new ArrayList());
  13. // 从列表中移除所有元素
  14. list.clear();
  15. // 如果列表包含指定的元素,则返回true
  16. list.contains("nxj");
  17. // 如果列表包含指定 collection 的所有元素,则返回 true
  18. list.containsAll(new ArrayList());
  19. // 比较指定的对象与列表是否相等
  20. list.equals(new ArrayList());
  21. // 返回列表中指定位置的元素
  22. list.get(0);
  23. // 返回列表的哈希码值
  24. list.hashCode();
  25. // 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1
  26. list.indexOf("lwc");
  27. // 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1
  28. list.lastIndexOf("lwc");
  29. // 如果列表不包含元素,则返回 true
  30. list.isEmpty();
  31. // 移除列表中指定位置的元素
  32. list.remove(0);
  33. // 移除列表中出现的首个指定元素
  34. list.remove("lwc");
  35. // 从列表中移除指定 collection 中包含的所有元素
  36. list.removeAll(new ArrayList());
  37. // 用指定元素替换列表中指定位置的元素
  38. list.set(0, "lp");
  39. // 返回列表中的元素数
  40. list.size();
  41. // 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图
  42. list.subList(1, 2);
  43. // 返回以正确顺序包含列表中的所有元素的数组
  44. list.toArray();
  45. // 返回以正确顺序包含列表中所有元素的数组
  46. list.toArray(new String[] { "a", "b" });
  47. }
  48. }

ArrayList

[plain] view plain copy

  1. 构造方法
  2. public ArrayList()
  3. public ArrayList(int initialCapacity)
  4. public ArrayList(Collection c)
  5. ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组
  6. 当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍+1,
  7. 然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,
  8. 当新数组无法容纳增加的元素,重复该过程
  9. ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,
  10. 因为操作之后后续元素需要移动

遍历ArrayList

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. public class Test {
  6. public static void main(String[] args) {
  7. List<String> list = new ArrayList<String>();
  8. list.add("lwc");
  9. list.add("nxj");
  10. // 方法一
  11. Iterator<String> ite1 = list.iterator();
  12. while (ite1.hasNext()) {
  13. String str = ite1.next();
  14. System.out.println(str);
  15. }
  16. System.out.println("---------------------");
  17. // 方法二(方法一的变形)
  18. for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {
  19. String str = ite2.next();
  20. System.out.println(str);
  21. }
  22. System.out.println("---------------------");
  23. // 方法三
  24. for(String s : list){
  25. System.out.println(s);
  26. }
  27. }
  28. }
  29. /*
  30. 打印结果:
  31. lwc
  32. nxj
  33. ---------------------
  34. lwc
  35. nxj
  36. ---------------------
  37. lwc
  38. nxj
  39. */

Vector

[plain] view plain copy

  1. 向量,历史比较悠久,Java诞生就有了,特点与ArrayList相同,
  2. 不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都使用ArrayList
  3. 构造方法
  4. public Vector()
  5. public Vector(int initialCapacity)
  6. public Vector(int initialCapacity,int capacityIncrement)
  7. 第一个参数是初始容量,第二个参数是当Vector满时的增量
  8. public Vector(Collection c)
  9. Vector也是依赖数组实现的

案例

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.Enumeration;
  3. import java.util.Vector;
  4. public class Test {
  5. public static void main(String[] args) {
  6. Vector v = new Vector();
  7. v.add("123");
  8. v.add("lwc");
  9. v.add("你好");
  10. // Vector转换为枚举
  11. Enumeration e = v.elements();
  12. while (e.hasMoreElements()) {
  13. System.out.println(e.nextElement());
  14. }
  15. }
  16. }

Stack

[java] view plain copy

  1. Vector的子类

案例

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.Enumeration;
  3. import java.util.Stack;
  4. public class Test {
  5. public static void main(String[] args) {
  6. Stack stack = new Stack();
  7. // 向栈里面压一个整数
  8. stack.push(new Integer(123));
  9. stack.push("lwc");
  10. stack.push(new Double(88.88));
  11. // 遍历
  12. Enumeration items = stack.elements();
  13. while (items.hasMoreElements()) {
  14. System.out.print(items.nextElement() + " ");
  15. }
  16. System.out.println();
  17. // 出栈
  18. while (stack.size() != 0) {
  19. System.out.print(stack.pop() + " ");
  20. }
  21. }
  22. }
  23. /*
  24. 打印结果:
  25. 123 lwc 88.88
  26. 88.88 lwc 123
  27. */

LinkedList

[plain] view plain copy

  1. LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,
  2. 因此有很好的插入和删除性能,但随机访问元素的性能很差
  3. 构造方法
  4. public LinkedList()
  5. public LinkedList(Collection c)
  6. LinkedList类中有一个Entry内部类,Entry内部类包含3个部分向前的引用,向后的引用,数据
  7. header.next = header.previous = header;

遍历LinkedList

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. import java.util.ListIterator;
  5. public class Test {
  6. public static void main(String[] args) {
  7. List link = new LinkedList();
  8. link.add(123);
  9. link.add("lwc");
  10. link.add(8.8);
  11. link.add("nxj");
  12. link.add(520);
  13. printList(link);
  14. printReversedList(link);
  15. }
  16. private static void printList(List link) {
  17. System.out.println("正序链表中的元素");
  18. // 的到链表的迭代器,位置指向链头
  19. ListIterator li = link.listIterator();
  20. // 判断迭代器中是否有下一个元素
  21. while (li.hasNext()) {
  22. // 返回下个元素
  23. System.out.print(li.next() + " ");
  24. }
  25. System.out.println();
  26. }
  27. private static void printReversedList(List link) {
  28. System.out.println("逆向链表中的元素");
  29. // 的到链表的迭代器,位置指向link.size()结尾
  30. ListIterator li = link.listIterator(link.size());
  31. // 判断迭代器中是否有前一个元素
  32. while (li.hasPrevious()) {
  33. // 返回前一个元素
  34. System.out.print(li.previous() + " ");
  35. }
  36. System.out.println();
  37. }
  38. }
  39. /*
  40. 打印结果:
  41. 正序链表中的元素
  42. 123 lwc 8.8 nxj 520
  43. 逆向链表中的元素
  44. 520 nxj 8.8 lwc 123
  45. */

自定义LinkedList结构

[java] view plain copy

  1. package com.itlwc;
  2. class Node {
  3. Node previous;// 前驱
  4. String data;// 数据
  5. Node next;// 后驱
  6. public Node(String data) {
  7. this.data = data;
  8. }
  9. }
  10. public class Test {
  11. public static void main(String[] args) {
  12. Node node1 = new Node("node1");
  13. Node node2 = new Node("node2");
  14. Node node3 = new Node("node3");
  15. node1.next = node2;
  16. node2.previous = node1;
  17. node2.next = node3;
  18. node3.previous = node2;
  19. node3.next = node1;
  20. node1.previous = node3;
  21. // 增加node4
  22. Node node4 = new Node("node4");
  23. node1.next = node4;
  24. node4.previous = node1;
  25. node4.next = node2;
  26. node2.previous = node4;
  27. // 删除node4
  28. node1.next = node2;
  29. node2.previous = node1;
  30. node4.previous = null;
  31. node4.next = null;
  32. }
  33. }

依赖倒置原理

[plain] view plain copy

  1. 依赖应该尽量在抽象层进行,避免在具体层进行,
  2. 在实际开发中尽量使用接口类型的引用,避免采用具体类型的引用

案例

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. public class Test {
  5. //如果我们需要传入参数是ArrayList就需要改动代码
  6. public void printLinkedList(LinkedList ll){
  7. System.out.println(ll);
  8. }
  9. //如果我们传入参数是List的子类,我们不需要改动代码,灵活性大
  10. public void printList(List l){
  11. System.out.println(l);
  12. }
  13. }

将数组转换为列表

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.Arrays;
  3. import java.util.List;
  4. public class Test {
  5. public static void main(String[] args) {
  6. String[] str = { "l", "w", "c" };
  7. //使用Java类库中java.util.Arrays类的静态方法asList()
  8. List l = Arrays.asList(str);
  9. System.out.println(str);
  10. }
  11. }
  12. /*
  13. 打印结果:
  14. [l, w, c]
  15. */

ArrayList VS LinkedList

[plain] view plain copy

  1. ArrayList底层采用数组实现,LinkedList底层采用双链表实现
  2. 如果为列表增加对象
  3. ArrayList是ArrayList底层数组维护的,LinkedList是LinkedList底层Entry对象维护的
  4. LinkedList底层Entry结构
  5. Entry{
  6. Entry previous;
  7. Object element;
  8. Entry next;
  9. }
  10. 其中element就是我们添加的元素,最后将生成的Entry对象加入到链表中
  11. 插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好

List<Map>遍历

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.ArrayList;
  3. import java.util.HashMap;
  4. import java.util.Iterator;
  5. import java.util.List;
  6. import java.util.Map;
  7. public class Test {
  8. public static void main(String[] args) {
  9. Map<Integer, String> map1 = new HashMap<Integer, String>();
  10. map1.put(new Integer(1), "lwc");
  11. map1.put(new Integer(2), "nxj");
  12. Map<Integer, String> map2 = new HashMap<Integer, String>();
  13. map2.put(new Integer(3), "tom");
  14. map2.put(new Integer(4), "cat");
  15. List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();
  16. list.add(map1);
  17. list.add(map2);
  18. // 方法一
  19. Iterator<Map<Integer, String>> ite1 = list.iterator();
  20. while (ite1.hasNext()) {
  21. Map<Integer, String> m = ite1.next();
  22. System.out.println(m);
  23. }
  24. System.out.println("-----------------------------");
  25. // 方法二(方法一的变形)
  26. for (Iterator<Map<Integer, String>> ite2 = list.iterator(); ite2.hasNext();) {
  27. Map<Integer, String> m = ite2.next();
  28. System.out.println(m);
  29. }
  30. System.out.println("-----------------------------");
  31. // 方法三:
  32. for (Map<Integer, String> m : list) {
  33. System.out.println(m);
  34. }
  35. }
  36. }
  37. /*
  38. 打印结果:
  39. {1=lwc, 2=nxj}
  40. {3=tom, 4=cat}
  41. -----------------------------
  42. {1=lwc, 2=nxj}
  43. {3=tom, 4=cat}
  44. -----------------------------
  45. {1=lwc, 2=nxj}
  46. {3=tom, 4=cat}
  47. */

Set

[plain] view plain copy

  1. 实现类
  2. HashSet,LinkedHashSet
  3. 子接口
  4. SortSet
  5. 实现类
  6. TreeSet
  7. 不包含重复元素,最多包含一个null,元素没有顺序

HashSet

[plain] view plain copy

  1. HashSet不是Ordered也不是Sorted,存储对象引用时是按照哈希策略来实现的,
  2. HashSet中是否存在一个对象是通过equals()和hashCode()协同判断
  3. 不保证顺序
  4. 构造方法
  5. public HashSet()
  6. public HashSet(int initialCapacity)
  7. public HashSet(Collection c)
  8. HashSet底层是使用HashMap实现的
  9. HashSet的add()方法详解:
  10. 判断已经存储在集合中的对象hashCode值是否与增加对象的hashCode值一致
  11. 如果不一致,直接加进去
  12. 如果一致,再进行equals()比较
  13. 如果equals()返回true,对象已经存在不增加进去
  14. 如果equals()返回false,把对象增加进去

LinkedHashSet

[plain] view plain copy

  1. LinkedHashSet是Ordered,采用双链表实现的
  2. 有固定顺序,也就是插入顺序
  3. LinkedHashSet底层是使用LinkedHashMap实现的
  4. 构造方法
  5. public LinkedHashSet()
  6. public LinkedHashSet(int initialCapacity)
  7. public LinkedHashSet(Collection c)

SortedSet接口

[plain] view plain copy

  1. 保证迭代器按照元素递增顺序遍历的集合,可以按照元素的自然顺序进行排序
  2. 常用方法
  3. Object first()
  4. 返回此有序集合中当前第一个(最小的)元素
  5. Object last()
  6. 返回此有序集合中最后一个(最大的)元素
  7. SortedSet headSet(Object toElement)
  8. 返回此有序集合的部分视图,其元素严格小于toElement
  9. SortedSet tailSet(Object fromElement)
  10. 返回此有序集合的部分视图,其元素大于或等于fromElement
  11. SortedSet subSet(Object fromElement,Object toElement)
  12. 返回此有序集合的部分视图,元素范围从fromElement(包括)到toElement(不包括)
  13. Comparator comparator()
  14. 返回与此有序集合关联的比较器,如果使用元素的自然顺序,则返回 null

TreeSet

[java] view plain copy

  1. TreeSet是SortedSet接口的实现,元素不论以什么元素插入,在遍历的时候,都会以天然顺序遍历
  2. TreeSet底层是使用TreeMap实现的
  3. 构造方法
  4. public TreeSet()
  5. public TreeSet(SortedSet s)
  6. public TreeSet(int initialCapacity)
  7. public TreeSet(Comparator<? super E>)
  8. public TreeSet(Collection c)
  9. 因为TreeSet是带排序的,所以想要为TreeSet增加自定义类型,必须指定排序规则

TreeSet排序规则Comparator案例

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.Comparator;
  3. import java.util.Iterator;
  4. import java.util.TreeSet;
  5. public class Test {
  6. public static void main(String[] args) {
  7. TreeSet set = new TreeSet(new PersonComparator());
  8. set.add(new Person("lwc", 80));
  9. set.add(new Person("nxj", 70));
  10. set.add(new Person("lp", 60));
  11. set.add(new Person("fy", 75));
  12. Iterator ite = set.iterator();
  13. while (ite.hasNext()) {
  14. Person p = (Person)ite.next();
  15. System.out.println(p.name);
  16. }
  17. }
  18. }
  19. class Person {
  20. String name;
  21. int score;
  22. public Person(String name, int score) {
  23. this.name = name;
  24. this.score = score;
  25. }
  26. }
  27. class PersonComparator implements Comparator {
  28. public int compare(Object o1, Object o2) {
  29. Person p1 = (Person) o1;
  30. Person p2 = (Person) o2;
  31. return p1.score - p2.score;
  32. }
  33. }

Collections

[plain] view plain copy

  1. 操作Collection类的工具类,类中方法都是静态的

Collections常用方法

[java] view plain copy

  1. package com.itlwc;
  2. import java.util.ArrayList;
  3. import java.util.Collections;
  4. import java.util.Comparator;
  5. public class Test {
  6. public static void main(String[] args) {
  7. // 将所有元素从一个列表复制到另一个列表
  8. Collections.copy(new ArrayList(), new ArrayList());
  9. // 如果两个指定collection中没有相同的元素,则返回 true
  10. Collections.disjoint(new ArrayList(), new ArrayList());
  11. // 使用指定元素替换指定列表中的所有元素
  12. Collections.fill(new ArrayList(), new Object());
  13. // 返回指定 collection 中等于指定对象的元素数
  14. Collections.frequency(new ArrayList(), new Object());
  15. // 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1
  16. Collections.indexOfSubList(new ArrayList(), new ArrayList());
  17. // 根据元素的自然顺序，返回给定 collection 的最大元素
  18. Collections.max(new ArrayList());
  19. // //根据元素的自然顺序，返回给定 collection 的最大元素
  20. Collections.min(new ArrayList());
  21. // 使用另一个值替换列表中出现的所有某一指定值
  22. Collections.replaceAll(new ArrayList(), "oldVal", "newVal");
  23. // 反转指定列表中元素的顺序
  24. Collections.reverse(new ArrayList());
  25. // 返回一个比较器,它强行反转
  26. Collections.reverseOrder();
  27. // 返回一个比较器,它强行反转指定比较器的顺序
  28. Collections.reverseOrder(new Comparator() {
  29. @Override
  30. public int compare(Object o1, Object o2) {
  31. return 0;
  32. }
  33. });
  34. // 使用默认随机源随机更改指定列表的序列
  35. Collections.shuffle(new ArrayList());
  36. // 根据元素的自然顺序对指定列表按升序进行排序
  37. Collections.sort(new ArrayList());
  38. // 根据元素的自然顺序对指定列表按降序进行排序
  39. Collections.sort(new ArrayList(), Collections.reverseOrder());
  40. // 在指定列表的指定位置处交换元素
  41. Collections.swap(new ArrayList(), 1, 2);
  42. }
  43. }
时间： 2024-10-08 09:22:07

Java - Collection的相关文章

JAVA Collection 源码分析(一)之ArrayList

到今天为止,差不多已经工作一年了,一直在做的是javaweb开发,一直用的是ssh(sh)别人写好的框架,总感觉自己现在高不成低不就的,所以就像看看java的源码,顺便学习一下大牛的思想和架构,read and write一直是提高自己编程水平的不二法门,写博客只是记录自己的学习历程,方便回顾,写的不好的地方,请多多包含,不喜勿喷,好了废话少说,现在让我们开始我们的历程把,Let's go!!!!!!!! 想看源码无从下手,不知道有没有跟我一样感觉的人们,今天用Intellij发现了可以找出类与

Java Collection源码学习

Java集合类的顶层是Collection<E>接口, Collection接口是最基本的容器接口,继承至Iterable接口(主要通过其进行产生迭代器逐一的进行元素访问).其中的元素允许重复,可以无序. JDK没有提供直接实现Collection接口的实现类,它提供更具体的子接口如List.Set等. 继承自它的子接口包括BeanContext, BeanContextServices, BlockingDeque<E>, BlockingQueue<E>, Dequ

Java Collection Framework : List

摘要: List 是 Java Collection Framework的重要成员,详细包括List接口及其全部的实现类.由于List接口继承了Collection接口,所以List拥有Collection的全部操作. 同一时候.又由于List是列表类型,所以List本身还提供了一些适合自身的方法.ArrayList 是一个动态数组.实现了数组动态扩容,随机訪问效率高:LinkedList是一个双向链表,随机插入和删除效率高,可用作队列的实现. 一. 要点 List 基础特性与框架 ArrayL

Java集合框架介绍。Java Collection Frameworks = JCF

Java集合框架 = Java Collection Frameworks  = JCF . 为了方便理解,我画了一张思维脑图.

Java collection 的一些介绍 集合

collections主要提供一些,排序的算法,随机的,反向的,  collection 是容器的祖先接口 线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构.这些类均在java.util包中.本文试图通过简单的描述,向读者阐述各个类的作用以及如何正确使用这些类. Collection ├List │├LinkedList │├ArrayList │└Vector │ └Stack └Set Map ├Hashtable ├Has

Java Collection Framework概述

文章出自:听云博客 Collection概述 Java collection是java提供的工具包,包含了常用的数据结构:集合.链表.队列.栈.数组.映射等. Java集合主要可以划分为4个部分:List列表.Set集合.Map映射.工具类(Iterator.Arrays和Collections). Java collection 结构图 通过上图我们可以看出 Collection是一个interface Collection有List和Set两大分支. List<E>是一个队列,根据下标索引

Java Collection 集合类大小调整带来的性能消耗

Java Collection类的某些具体实现由于底层数据存储基于数组,随着元素数量的增加,调整大小的代价很大.随着Collection元素增长到某个上限,调整其大小可能出现性能问题. 当Collection元素达到内部数组达到最大值后,需要创建新数组,并且将旧数组元素通过Arrays.copyOf方法拷贝到新数组,这就消耗了CPU时间片,并且还需要进行垃圾回收,特别是当Collection对象生命周期较长,已经处于老年代,需要经历一次Full GC才能释放内存.新数组的内存会在年轻代的Eden

JAVA Collection 源码分析(二)之SubList

昨天我们分析了ArrayList的源码,我们可以看到,在其中还有一个类,名为SubList,其继承了AbstractList. // AbstractList类型的引用,所有继承了AbstractList都可以传进来 private final AbstractList<E> parent; // 这个是其实就是parent的偏移量,从parent中的第几个元素开始的 private final int parentOffset; private final int offset; int s

Java Collection API

在 Java2中,有一套设计优良的接口和类组成了Java集合框架Collection,使程序员操作成批的数据或对象元素极为方便.这些接口和类有很多对抽象数据类型操作的API,而这是我们常用的且在数据结构中熟知的.例如Map,Set,List等.并且Java用面向对象的设计对这些数据结构和算法进行了封装,这就极大的减化了程序员编程时的负担.程序员也可以以这个集合框架为基础,定义更高级别的数据抽象,比如栈.队列和线程安全的集合等,从而满足自己的需要. Java2的集合框架,抽其核心,主要有三种:Li