java库中实际集合,java中实际集合

by admin on 2019年2月18日

ArrayList 一种可以动态增进和压缩的目录连串

1.ArrayList   可以动态拉长和压缩的目录种类

1.java  Iterator 迭代器

    1.   
Java集合类库中最重点的四个接口Collection<E>和Map<K,V>,其中Collection接口又重新划分为
List和Set两大子接口,List中得以蕴含重复的要素,Set中则不得以。以下列举出有个别常用的汇聚落成类,他们均分别继承自那三个接口:
    1)    ArrayList:
一种可以动态拉长和压缩的目录连串(动态数组,类似于C++中的vector);
    2)    LinkedList:
一种可以在其余地点举行飞快的插入和删除操作的静止种类(类似于C++中list);
    3)    ArrayDeque:
一种用循环数组已毕的双端队列(类似于C++中的deque);
    4)   
HastSet:一种没有重新成分的无序聚集(C++的标准库中从未提供hashset集合,不过Windows的VC和Linux平台下的gcc均各自提供了hashset容器);
    5)    TreeSet: 一种有序集(类似于C++中的set);
    6)    EnumSet: 一种含有枚举类型值的集;
    7)    LinkedHashSet:
一种可以记住成分插入次序的集,在其里面由LinkedList负责维护插入的程序,HashSet来保安Hash;
    8)   
HashMap:一种存储键值对关系的数据结构(C++的标准库中从不提供hashmap集合,可是Windows的VC和Linux平台下的gcc均分别提供了hashmap容器);
    9)    TreeMap:一种键值有序排列的映射表(类似于C++中的map);
    10)   EnumMap:一种键值属于枚举类型的映射表;
    11)   LinkedHashMap:一种可以记住键值项插入次序的映射表;
    2.   
ArrayList:该集合的平底是由此动态数组来兑现的,集合构造的时候可以钦命三个早先体积,当插入的要素过多导致已有的体量无法包容新成分是,其底
层数组的体积将电动增加原有容积的1.5
倍,那样会带来一定的上空浪费,然而为了防止平时扩展而带来的品质成本,只好是用空间换取时间了。假设在容器的中级添加或然去除二个因素都将会促成前边的
成分向后或向前挪动1个职分,即使成分数量较多且该操作相比频仍,将会导致系统的性质下跌,但是对于容器中成分的即兴访问品质较好,以下为
ArrayList的常用示例代码:

LinkedList 一种可以在其他地方展开疾速地插入和删除操作的逐步体系

2.LinkedList 可以在其余岗位火速插入和删除错左的雷打不动体系

迭代器是一种设计形式,它是1个对象,它可以遍历并接纳种类中的对象,而开发人士不须要通晓该种类的底部结构。迭代器平常被叫做“轻量级”对象,因为创造它的代价小。

  1     public static void showIterator() {
  2         ArrayList<String> list = new ArrayList<String>();
  3         list.add("Monday");
  4         list.add("Tuesdag");
  5         list.add("Wednesday");
  6         Iterator<String> iterator = null;
  7         iterator = list.iterator();
  8         //while
  9         while (iterator.hasNext()) {
 10             String element = iterator.next();
 11             System.out.println(element);
 12         }
 13         //for
 14         for (iterator = list.iterator(); iterator.hasNext();) {
 15             String element = iterator.next();
 16             System.out.println(element);
 17         }
 18         //for each
 19         for (String element : list) {
 20             System.out.println(element);
 21         }
 22     }
 23 
 24     public static void showSetAndGet() {
 25         ArrayList<String> nums = new ArrayList<String>();
 26         nums.clear();
 27         nums.add("One");
 28         nums.add("Two");
 29         nums.add("Three");
 30         System.out.println(nums);
 31         nums.set(0, "Uno");
 32         nums.set(1, "Dos");
 33         nums.set(2, "Tres");
 34         for (int i = 0; i < nums.size(); ++i)
 35             System.out.println(nums.get(i));
 36     }
 37     
 38     public static void showRemoveAndSize() {
 39         ArrayList<String> al = new ArrayList<String>();
 40         System.out.println("Initial size of al: " + al.size());
 41         al.add("C");
 42         al.add("A");
 43         al.add("E");
 44         al.add("B");
 45         al.add(1, "A2");
 46         System.out.println("Size of al after additions: " + al.size());
 47         System.out.println("Contents of al: " + al);
 48         al.remove("F");
 49         al.remove(2);
 50         System.out.println("Size of al after deletions: " + al.size());
 51         System.out.println("Contents of al: " + al);
 52         Iterator<String> it = al.iterator();
 53         //Notes:remove() must be called after next()
 54         it.next();
 55         it.remove();
 56         System.out.println("Size of al after deletions: " + al.size());
 57         System.out.println("Contents of al: " + al);        
 58     }
 59     
 60     public static void showSubListAndCopyToArray() {
 61         ArrayList<String> arrayList = new ArrayList<String>();
 62         arrayList.add("1");
 63         arrayList.add("2");
 64         arrayList.add("3");
 65         arrayList.add("4");
 66         arrayList.add("5");
 67         List<String> lst = arrayList.subList(1, 3);
 68         for (int i = 0; i < lst.size(); i++)
 69             System.out.println(lst.get(i));        
 70         // remove one element from sub list
 71         String obj = lst.remove(0);
 72         System.out.println(obj + " is removed");
 73         for (String str: arrayList)
 74             System.out.println(str);
 75         //get object array with normal method
 76         Object[] objArray = arrayList.toArray();
 77         for (Object obj1 : objArray)
 78             System.out.println(obj1);
 79         //get object array with generic method
 80         String[] strArray = arrayList.toArray(new String[0]);
 81         for (String str : strArray)
 82             System.out.println(str); 
 83     }
 84     
 85     public static void showListIterator() {
 86         ArrayList<String> aList = new ArrayList<String>();
 87         aList.add("1");
 88         aList.add("2");
 89         aList.add("3");
 90         aList.add("4");
 91         aList.add("5");
 92         
 93         ListIterator<String> listIterator = aList.listIterator();
 94         while (listIterator.hasNext()) {
 95             System.out.println(listIterator.next());
 96             System.out.println("Previous: " + listIterator.previousIndex());
 97             System.out.println("Next: " + listIterator.nextIndex());
 98         }
 99         while (listIterator.hasPrevious()) {
100             System.out.println(listIterator.previous());
101             System.out.println("Previous: " + listIterator.previousIndex());
102             System.out.println("Next: " + listIterator.nextIndex());
103         }
104         listIterator = aList.listIterator(2);
105         listIterator.next();
106         listIterator.set("100");
107         listIterator.next();
108         listIterator.remove();
109         for (String str : aList)
110             System.out.println(str);
111 
112         if (aList.contains("4"))
113             System.out.println("True");
114         else
115             System.out.println("False");
116     }
117     
118     public static void showFillAndReplace() {
119         ArrayList<String> arrayList = new ArrayList<String>();
120         arrayList.add("A");
121         arrayList.add("B");
122         arrayList.add("A");
123         arrayList.add("C");
124         arrayList.add("D");
125         Collections.replaceAll(arrayList, "A", "Replace All");
126         System.out.println(arrayList);
127         Collections.fill(arrayList, "REPLACED");
128         System.out.println(arrayList);
129     }
130 
131     public static void showCollectionOperation() {
132         List<String> colours = new ArrayList<String>();
133         colours.add("red");
134         colours.add("green");
135         colours.add("blue");
136 
137         System.out.println(colours);
138         Collections.swap(colours, 0, 2);
139         System.out.println(colours);
140 
141         Collections.reverse(colours);
142         System.out.println(colours);
143 
144         Collections.sort(colours);
145         System.out.println(Arrays.toString(colours.toArray()));
146         Collections.sort(colours, Collections.reverseOrder());
147         System.out.println(Arrays.toString(colours.toArray()));
148 
149         int index = Collections.binarySearch(colours, "green");
150         System.out.println("Element found at : " + index);
151         ArrayList<Integer> arrayList = new ArrayList<Integer>();
152         arrayList.add(new Integer("3"));
153         arrayList.add(new Integer("1"));
154         arrayList.add(new Integer("8"));
155         arrayList.add(new Integer("3"));
156         arrayList.add(new Integer("5"));
157         System.out.println(Collections.min(arrayList));
158         System.out.println(Collections.max(arrayList));
159     }
160     
161     public static void showMinMax() {
162         ArrayList<Integer> arrayList = new ArrayList<Integer>();
163         arrayList.add(new Integer("3"));
164         arrayList.add(new Integer("1"));
165         arrayList.add(new Integer("8"));
166         arrayList.add(new Integer("3"));
167         arrayList.add(new Integer("5"));
168         System.out.println(Collections.min(arrayList));
169         System.out.println(Collections.max(arrayList));
170     }
171     
172     public static void showSynchronizedList() {
173         ArrayList arrayList = new ArrayList();
174         List list = Collections.synchronizedList(arrayList);
175         //list之后的并发操作将不再需要synchronized关键字来进行同步了。
176     }

ArrayDeque  一种用循环数组达成的双端队列

3.HashSet  没有再度成分的无序集聚

  Java中的Iterator成效相比较简单,并且只能够单向运动:

    3.    LinkedList:   
该集合是通过双向链表来兑现的,对于指定地点成分的遍历其内部做了3个小的优化,即使position大于len/2,由于其中的数据结构是双向链表,因此可以从后迈入遍历,以调减遍历进度中节点跳转的次数。ArrayList中的一大半代码示例都适用于LinkedList,以下近给出
LinkedList特有的常用示例代码:

HashSet 一种没有再一次成分的无序集聚

4.TreeSet   有序集

  (1)
使用办法iterator()需求容器再次来到三个Iterator。第二回调用Iterator的next()方法时,它回到种类的率先个要素。注意:iterator()方法是java.lang.Iterable接口,被Collection继承。

 1     public static void showNewFeatures(String[] args) {
 2         LinkedList<String> lList = new LinkedList<String>();
 3         lList.add("1");
 4         lList.add("2");
 5         lList.add("3");
 6         lList.add("4");
 7         lList.add("5");
 8         
 9         System.out.println("First element of LinkedList is : " + lList.getFirst());
10         System.out.println("Last element of LinkedList is : " + lList.getLast());
11         System.out.println(lList);
12         
13         String str = lList.removeFirst();
14         System.out.println(str + " has been removed");
15         System.out.println(lList);
16         str = lList.removeLast();
17         System.out.println(str + " has been removed");
18         System.out.println(lList);
19         
20         lList.addFirst("1");
21         System.out.println(lList);
22         lList.addLast("5");
23         System.out.println(lList);    
24     }

TreeSet 一种有序集

5.HashMap  键值对关联的数据结构

  (2)
使用next()得到种类中的下3个要素。

    4.    ArrayList和LinkedList的相同点:
java库中实际集合,java中实际集合。    1)    都以接口List<E>的兑现类;
    2)   
都可以通过iterator()方法重返Iterator<E>迭代器对象,并可以透过该对象遍历容器中的成分;
    3)   
即使八个Iterator<E>实例同时援引同三个汇集对象,那么当有三个正值遍历,而除此以外多个修改(add/remove)了汇聚对象中的
成分,对于第一个迭代器再拓展迭代时将会吸引ConcurrentModificationException非常的发生。
    5.    ArrayList和LinkedList的不一样点:
    1)   
对ArrayList和LinkedList而言,在列表末尾伸张3个成分所花的开发都以原则性的。对ArrayList而言,紧假如在里头数组中加进一
项,指向所添加的因素,偶尔大概会导致对数组重新开展分配;而对LinkedList而言,这些开支是统一的,分配一个里边Entry对象。
    2)   
在ArrayList的中档插入或删除二个元素意味着这些列表中多余的因素都会被活动;而在LinkedList的中间插入或删除三个成分的费用是稳定的。
    3)    LinkedList不协助高效的私行成分访问。
    4)   
ArrayList的长空浪费主要反映在在list列表的尾声预留一定的体积空间,而LinkedList的空中花费则反映在它的每三个因素都亟需开支卓殊的上空
   
在C++的标准库中,ArrayList和LinkedList之间的利用差距以及个其余得失也同等呈现于vector和list。
    6.    HashSet:
散列表为每一种对象计算出三个整数(通过Object缺省的或类重载的hashCode域方法),称为散列码。在Java中,散列表是行使链表的数组来落实的,每一种链表被叫作二个哈希桶。即使想在哈希表中搜索一个目的,则须要先总计对象的hashCode,之后对表内的桶数取余数,得到的结果就是哈希桶的索
引,此时只要该桶为空桶,就可以直接将该对象插入到该桶中,倘使已经有目的存在了,则必要各类举行相比,一旦发现该与该目的相等的目的(equals()
重临true),就会放弃本次插入操作,否则将该对象插入到该桶的末尾。HashSet在布局的时候提供八个参数,三个是initialCapacity
指定了桶的多寡(实际的桶数为2的initialCapacity次幂),另二个是loadFactortian(0.0–1.0,推荐值为
0.75),当桶的填写百分比达到该值后,哈希表内的哈希桶数将double,重新填写已有对象,该操作被叫做rehash,rehash是格外震慑功用的操作,因为为了尽量防止该事件的发生,因可能在布局HashSet的时候给出多个理所当然的参数。以下为HashSet的常用示例代码:

LinkHashSet 一种能够记住成分插入次序的聚众

6.TreeMap  键值有序排列的映射表

  (3)
使用hasNext()检查种类中是还是不是还有成分。

 1     public static void showAddAndIterator() {
 2         HashSet<String> hs = new HashSet<String>();
 3         hs.add("B");
 4         hs.add("A");
 5         hs.add("D");
 6         hs.add("E");
 7         hs.add("C");
 8         hs.add("F");
 9         System.out.println(hs);
10         Iterator<String> it = hs.iterator();
11         while (it.hasNext())
12             System.out.println(it.next());
13     }
14     public static void showRemoveAndClearAndContains() {
15         HashSet<Integer> hSet = new HashSet<Integer>();
16         hSet.add(new Integer("1"));
17         hSet.add(new Integer("2"));
18         hSet.add(new Integer("3"));
19         System.out.println(hSet.contains(new Integer("3")));
20         System.out.println(hSet);
21         boolean blnRemoved = hSet.remove(new Integer("2"));
22         System.out.println(hSet.contains(new Integer("2")));
23         System.out.println(blnRemoved);
24         System.out.println(hSet);    
25         hSet.clear();
26         System.out.println(hSet);
27         System.out.println(hSet.isEmpty());
28     }
29     
30     public static void showToArrayListAndArray() {
31         HashSet<String> hs = new HashSet<String>();
32         hs.add("B");
33         hs.add("A");
34         hs.add("D");
35         System.out.println(hs);
36         List<String> list = new ArrayList<String>(hs);
37         Object[] objects = list.toArray();
38         for (Object obj : objects)
39             System.out.println("Object = " + obj);
40         String[] strs = list.toArray(new String[0]);
41         for (String str : strs)
42             System.out.println("String = " + str);
43     }
44 
45     public static void showToHashSetAndRemoveDuplicate() {
46         Integer[] numbers = { 7, 7, 8, 9, 10, 8, 8, 9, 6, 5, 4 };
47         List<Integer> list = Arrays.asList(numbers);
48         Set<Integer> set = new HashSet<Integer>(list);
49         for (Integer o : set)
50             System.out.print(o + ", ");
51     }
52     
53     public static void showMinMax() {
54         HashSet<Long> hashSet = new HashSet<Long>();
55         hashSet.add(new Long("9"));
56         hashSet.add(new Long("4"));
57         hashSet.add(new Long("2"));
58         hashSet.add(new Long("2"));
59         hashSet.add(new Long("3"));
60         Object objMin = Collections.min(hashSet);
61         System.out.println("Minimum Element of Java HashSet is : " + objMin);
62         Object objMax = Collections.max(hashSet);
63         System.out.println("Maximum Element of Java HashSet is : "+ objMax);
64     }
65 
66     public static void showSynchronizedSet() {
67         HashSet hashSet = new HashSet();
68         Set set = Collections.synchronizedSet(hashSet);
69         //set之后的并发操作将不再需要synchronized关键字来进行同步了。
70     }

PriorityQueue 一种可以快捷去除最小成分的聚集

7.  EunmMap  枚举类型的映射表

  (4)
使用remove()将迭代器新回到的要素删除。

    7.   
TreeSet:该集合为平稳聚集,数据在插入集合后便依照自定义的排序规则将插入的目的开展排序,该集合紧即使透过三种艺术排序插入对象的,一种是讲求
集合成分类必须是Comparable<T>的完毕类,那样在插入对象的时候,集合可以依照compareTo方法的再次来到值来规定新插入对象
的职务,别的一种方式是由此在结构该集合对象的时候,传入Comparator<T>的兑现类作为参数,之后全体插入的目的都以透过
Comparator<T>的compare方法的重回值来支配新对象的职位。该集合是经过RBTree(红黑树)来促成排序的,这点和
C++标准库中的set和map是一样的。由于目标插入集合之后是不变的,由此该集合的插入功效要自愧不如HashSet的插入功效。TreeSet和
HashSet相比较根本的差距来自于对象的排序规则,以上HashSet的演示代码均适用于TreeSet,上面只是列出目的比较的代码:

HashMap 一种存储key:value关联的映照

java库中实际集合,java中实际集合。8.EnumSet   包罗枚举类型值的值

  Iterator是Java迭代器最简易的完毕,为List设计的ListIterator具有越来越多的效果,它可以从五个方向遍历List,也足以从List中插入和删除成分。

 1     public class Item implements Comparable<Item> {
 2         public int compareTo(Item other) {
 3             return partNumber - other.partNumber;
 4         }
 5     }
 6     public static void main(String[] args) {
 7         SortedSet<Item> parts = new TreeSet<Item>();
 8         parts.add(new Item("Toaster",1234));
 9         parts.add(new Item("Widget",4562));
10         parts.add(new Item("Modem",9912));
11         System.out.println(parts);
12         
13         SortedSet<Item> sortByDescription = new TreeSet<Item>(new Comparator<Item>() {
14             public int compare(Item a,Item b) {
15                 String descA = a.getDescription();
16                 String descB = b.getDescription();
17                 return descA.compareTo(descB);
18             }
19         });
20         sortByDescription.addAll(parts);
21         System.out.println(sortByDescription);
22     }

TreeMap 一种key有序的映射

9.ArrayQueue  循环数组达成的双端队列

迭代器应用:

    8.    PriorityQueue(优先级对象):
该容器也是雷打不动聚集,和TreeSet不相同的是,该集合只是保障当从集合的头顶取出数据的时候,总是取出队列中小小的(优先级最高)的因素。该集合内部是通
过”堆”的数据结构完成的,该协会只有首先个元素(尾部成分)保证为该集合中最大的或不大的因素,其余成分没有平昔的顺序,不过当集合有新的靶子从底部插
入或是从头顶取出时,集合内部的有关要素会进展比较的可比最后再一次决定出什么人是最大或不大的因素作为尾部成分。在JDK提供的classes中Timer是
通过该数据结构完毕的,从而确保了Timer每一次拿到职责时都是最应该被调度的TimerTask,见如下代码:

LinkedHashMap 一种可以记住插入次序的照射

10.PriorityQueue  允许高效去除最小成分的聚众

 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }
 /*迭代器用于while循环
 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }
 */
 1     public class TestMain {
 2         public static void main(String[] args) {
 3             PriorityQueue<String> pq = new PriorityQueue<String>();
 4             pq.add("1");
 5             pq.add("6");
 6             pq.add("4");
 7             pq.offer("5");
 8             pq.offer("3");
 9             pq.offer("2");
10             pq.offer("7");
11             //以下输出将以无序的结果输出
12             System.out.println(pq);
13             //以下输出将以有序的结果输出
14             while (pq.peek() != null) {
15                 String str = pq.poll();
16                 System.out.println(str);
17             }
18             int initCapacity = 20;
19             PriorityQueue<TestComparator> pq1 = new PriorityQueue<TestComparator>(initCapacity,
20                 new Comparator<TestComparator>() {
21                     public int compare(TestComparator t1, TestComparator t2) {
22                         return t1.getID() - t2.getID();
23                     }
24                 });
25             pq1.offer(new TestComparator(1));
26             pq1.offer(new TestComparator(6));
27             pq1.offer(new TestComparator(4));
28             pq1.offer(new TestComparator(5));
29             pq1.offer(new TestComparator(3));
30             pq1.offer(new TestComparator(2));
31             pq1.offer(new TestComparator(7));
32             System.out.println("The following is for TestComparator.");
33             System.out.println(pq1);
34             while (pq1.peek() != null) {
35                 int id = pq1.poll().getID();
36                 System.out.println(id);
37             }
38         }
39     }
40     
41     class TestComparator {
42         public TestComparator(int id) {
43             _id = id;
44         }
45         public int getID() {
46             return _id;
47         }
48         public String toString() {
49             return Integer.toString(_id);
50         }
51         private int _id;
52     }

11.LinkedHashMap  可以记住键值添加次序的映射表

 

    9.   
HashMap:其中间数据结构的逻辑类似于HashSet,只是Map存储的都以key/value的键值映射关系,key相当于HashSet中的对
象,value只是附着于key的对象,使用者一般都是通过key的值去HashMap中搜索,找到并回到该key以及相关联的value,其中间贯彻机
制可参看HashSet。在接口方面根本的差别点是Map对象足以变更一个汇集的视图(仅仅是视图,没有目的copy,视图的底层容器还是来自于原映射对
象集合,即使在其中专擅视图或原集合删除和增加数据都会立即反应与其它视图和照耀集合)。该规则一样适用于TreeMap。见之下常用代码示例:

12.WeakHashMap  可以被垃圾回收期回收的映射表

 

 1     public static void showGetAndPut() {
 2         HashMap<String, Double> hm = new HashMap<String, Double>();
 3         hm.put("A", new Double(3.34));
 4         hm.put("B", new Double(1.22));
 5         hm.put("C", new Double(1.00));
 6         hm.put("D", new Double(9.22));
 7         hm.put("E", new Double(-19.08));
 8         //随机的获取HashMap中的数据
 9         Set<Map.Entry<String, Double>> set = hm.entrySet();
10         for (Map.Entry<String, Double> me : set) {
11             System.out.print(me.getKey() + ": ");
12             System.out.println(me.getValue());
13         }
14         double balance = hm.get("A");
15         //输出1003.34
16         hm.put("A", balance + 1000);
17         System.out.println(hm.get("A"));
18     }
19     
20     public static void showContainsAndRemove() {
21         HashMap<String, String> hashMap = new HashMap<String, String>();
22         hashMap.put("1", "One");
23         hashMap.put("2", "Two");
24         hashMap.put("3", "Three");
25         System.out.println(hashMap.containsValue("Three"));
26         String str = hashMap.remove("2");
27         System.out.println("old value of 2 = " + str);
28         System.out.println(hashMap.containsValue("Two"));
29         Set<String> st = hashMap.keySet();
30         st.remove("1");
31         System.out.println("The size is equal to " + hashMap.size());
32         System.out.println(hashMap.containsKey("3"));
33     }
34     /* 结果如下
35         true
36         old value of 2 = Two
37         false 
38         The size is equal to 1 
39         true */
40         
41     public static void showIterator() {
42         String names[] = { "Mercury", "Venus", "Earth", "Mars", "Jupiter"
43             , "Saturn", "Uranus", "Neptune", "Pluto" };
44         float diameters[] = { 4800f, 12103.6f, 12756.3f, 6794f, 142984f
45             , 120536f, 51118f, 49532f, 2274f };
46         Map<String,Float> map = new HashMap<String,Float>();
47         for (int i = 0, n = names.length; i < n; i++)
48             map.put(names[i], new Float(diameters[i]));
49         Iterator<String> it = map.keySet().iterator();
50         while (it.hasNext()) {
51             String str = it.next();
52             System.out.println(str + ": " + map.get(str));
53         }
54     }
55 
56     public static void showSynchronizedMap() {
57         TreeMap<String,String> treeMap = new TreeMap<String,String>();
58         Map<String,String> map = Collections.synchronizedMap(treeMap);
59         //Map之后的并发操作将不再需要synchronized关键字来进行同步了。
60     }

13.IdentityHashMap   用==而不是equals相比键值的映射表

 

      10.   
TreeMap:TreeMap和TreeSet之间的相似性和严重性差别就如HashMap之于HashSet,见之下常用代码示例:

14.LinkedHashSet  可以记住插入次序的汇聚

2.java set

 1     public static void showSubMapAndHeadMapAndTailMap() {
 2         TreeMap<String, String> sortedMap = new TreeMap<String, String>();
 3         sortedMap.put("Adobe", "Mountain View, CA");
 4         sortedMap.put("IBM", "White Plains, NY");
 5         sortedMap.put("Learning Tree", "Los Angeles, CA");
 6         sortedMap.put("Microsoft", "Redmond, WA");
 7         sortedMap.put("Netscape", "Mountain View, CA");
 8         sortedMap.put("O'Reilly", "Sebastopol, CA");
 9         sortedMap.put("Sun", "Mountain View, CA");
10         System.out.println(sortedMap);
11         //firstKey and lastKey 是SortedMap中提供的方法,HashMap中没有。
12         String low = sortedMap.firstKey(), high = sortedMap.lastKey();
13         System.out.println(low);
14         System.out.println(high);
15         Iterator<String> it = sortedMap.keySet().iterator();
16         int i = 0;
17         while (it.hasNext()) {
18             if (i == 3)
19                 low = it.next();
20             if (i == 6)
21                 high = it.next();
22             else
23                 it.next();
24             i++;
25         }
26         System.out.println(low);
27         System.out.println(high);
28         //以下3个方法也是SortedMap中提供的方法,HashMap中没有。
29         System.out.println(sortedMap.subMap(low, high));
30         System.out.println(sortedMap.headMap(high));
31         System.out.println(sortedMap.tailMap(low));
32     }

在Java中动用Set,能够便宜地将索要的品类以聚众类型保存在一个变量中.主要使用在呈现列表.Set是一个不带有重复成分的
collection。更合适地讲,set 不含有满意 e1.equals(e2) 的因素对 e1 和
e2,并且最多带有三个 null 成分。

    11.   
LinkedHashSet和LinkedHashMap:那五个聚众与HashSet和HashMap唯一的异样是LinkedHashSet和LinkedHashMap通过中间贯彻的双向链表保留了集合成分的插入顺序,见如下代码:

JAVA集合可以储存和操作数目不稳定的一组数据。

 1     public static void main(String[] a) {
 2         Map<String, String> map = new LinkedHashMap<String, String>();
 3         map.put("1", "value1");
 4         map.put("2", "value2");
 5         map.put("3", "value3");
 6         map.put("2", "value4");
 7         for (Iterator<String> it = map.keySet().iterator(); it.hasNext();) {
 8             String key = it.next();
 9             String value = map.get(key);
10             System.out.println(value);
11         }
12     }
13     /* 结果如下:
14         value1
15         value4
16         value3 */
17 
18     //基于Values的排序后输出Keys
19     public static void main(String[] a) {
20         Map<String, String> yourMap = new HashMap<String, String>();
21         yourMap.put("1", "one");
22         yourMap.put("2", "two");
23         yourMap.put("3", "three");
24 
25         Map<String, String> map = new LinkedHashMap<String, String>();
26         List<String> keyList = new ArrayList<String>(yourMap.keySet());
27         List<String> valueList = new ArrayList<String>(yourMap.values());
28         Set<String> sortedSet = new TreeSet<String>(valueList);
29         String[] sortedArray = sortedSet.toArray(new String[0]);
30         int size = sortedArray.length;
31 
32         for (int i = 0; i < size; i++)
33             map.put(keyList.get(valueList.indexOf(sortedArray[i])), sortedArray[i]);
34 
35         Set<String> ref = map.keySet();
36         Iterator<String> it = ref.iterator();
37         while (it.hasNext()) {
38             String i = (String) it.next();
39             System.out.println(i);
40         }
41     }    

*   * 全部的JAVA集合都位于 java.util包中!
    JAVA集合只好存放引用类型的的多寡,不能存放基本数据类型.
    JAVA集合主要分为三连串型:
    Set(集)
    List(列表)
    Map(映射)
    Collection 接口
   
Collection是最宗旨的聚集接口,注明了适用于JAVA集合(只包罗Set和List)的通用方法。
    Set 和List 都持续了Conllection,Map没有
    Collection接口的方法:
    boolean add(Object o)   :向聚集中进入1个对象的引用
    void clear()                       
:删除集合中享有的目的,即不再抱有那个目的的引用
    boolean isEmpty()           :判断集合是不是为空
    boolean contains(Object o): 判断集合中是或不是具备一定目的的引用
    Iterartor iterator()              :
重临一个Iterator对象,能够用来遍历集合中的成分
    boolean remove(Object o):从集合中去除多少个对象的引用
    int size()                               :重返集合中成分的数目
    Object[] toArray()                
:再次回到2个数组,该数组中包涵集合中的全部因素
    关于:Iterator() 和toArray()
方法都用来集合的有着的因素,前者再次来到多少个Iterator对象,后者重返2个含有集合中负有因素的数组。
    Iterator接口申明了之类方法:     hasNext(): 判断集合中成分是不是遍历完成,若是没有,就赶回true
    next()       :重返下3个成分
    remove():从集合中删去上一个有next()方法再次来到的因素。
    Set(集合):
   
Set是最简便易行的一种集合。集合中的对象不按一定的不二法门排序,并且没有再度对象。
    Set接口重点达成了多少个落实类:
    HashSet : HashSet类依照哈希算法来存取集合中的对象,存取速度相比较快
    TreeSet   :
TreeSet类达成了SortedSet接口,可以对聚集中的对象开展排序。
    Set 的用法:     存放的是目的的引用,没有重新对象
   

    12.   
EnumSet和EnumMap,那三个汇聚可以作为是体系参数特化后的Set<E extends
Enum<E>>和Map<E extends
Enum<E>,V>,EnumSet没有显得的构造函数,而是经过一组工厂方法来创设了,见如下代码:

 Set set=new HashSet();
    String s1=new String("hello");
    String s2=s1;
    String s3=new String("world");
    set.add(s1);
    set.add(s2);
    set.add(s3);
    System.out.println(set.size());//打印集合中对象的数目 为 2。
 1     enum Weekdays {
 2         Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
 3     }
 4     public static void main(String[] a) {
 5         EnumSet<Weekdays> es1 = EnumSet.allOf(Weekdays.class);
 6         EnumSet<Weekdays> es2 = EnumSet.noneOf(Weekdays.class);
 7         EnumSet<Weekdays> es3 = EnumSet.range(Weekdays.Thursday, Weekdays.Sunday);
 8         EnumSet<Weekdays> es4 = EnumSet.of(Weekdays.Monday,Weekdays.Saturday);
 9         System.out.println("es1 = " + es1);
10         System.out.println("es2 = " + es2);
11         System.out.println("es3 = " + es3);
12         System.out.println("es4 = " + es4);
13     }
14     /* 结果如下:
15         es1 = [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
16         es2 = []
17         es3 = [Thursday, Friday, Saturday, Sunday]
18         es4 = [Monday, Saturday] */

    Set 的 add()方法是怎么判定目标是或不是早已存放在汇集中?

    13.   
集合视图:顾名思义,全体的集纳视图和数据库中的普通视图一样,并不存储真实是的器皿成分,而只是起家一套针对原有底层集合数据的引用机制,针对全数视图
的操作或尾部集合的操作都会同时相互影响,如插入和删除等,可是对于视图而言,插入操作假使效果于其范围之外将会掀起这几个。对于不一样品类的视图其操作也存
在区其他范围。
    1).    subList:获取底层集合中某一限量的要素,如List group2 =
staff.asList(10,20);
这第三个索引上的多少是被含有的,第1个目录的多寡是不被含有的。假使举行了group2.clear()操作情形了视图中的数据,那么staff中那段
范围内的数目也会被连同删除。对于有序聚集和映射表(Map),可以应用排序依次而不是因素地点建立子范围,如SortedSet接口注解的
SortedSet<E> subSet(E from,E to); SortedSet<E> headSet(E
to); SortedSet<E> tailSet(E from);
注意那2个参数的档次均不是因素的目录,而是对象自小编。SortedMap中也有近似的主意,如SortedMap<K,V>
subMap(K from,K to); SortedMap<K,V> headMap(K to);
SortedMap<K> tailMap(K
from)。在NavigableSet中提供更为丰盛的接口,如NavigableSet<E>
subSet(E from,boolean fromInclusive,E to,boolean toInclusive);
NavigableSet<E> headSet(E to,boolean toInclusive);
NavigableSet<E> tailSet(E from,boolean fromInclusive);
    2).    不可修改的视图:       
    Collections.unModifiableCollection();
    Collections.unModifiableList();        //用于ArrayList、LinkedList
    Collections.unModifiableSet();       
//用于HashSet、TreeSet、LinkedHashSet
    Collections.unModifiableSortedSet();//用于TreeSet
    Collections.unModifiableMap();       
//用于HashMap、TreeMap、LinkedHashMap
    Collections.unModifiableSortedMap();//用于TreeMap
    如List<String> staff = new LinkedList<String>();
List<String> unmodifiableList = new
Collections.unmodifiableList(staff);
那里unmodifiableList作为三个List对象,全部访问器的办法均可像一般List一样操作,不过对于更改器方法的调用将会掀起
UnsupportedOperationException万分。若是真的要求修改数据只能够通过原始集合来成功。
    3)    同步视图:
    Collections.synchronizedList();        //用于ArrayList、LinkedList
    Collections.synchronizedSet();       
//用于HashSet、TreeSet、LinkedHashSet
    Collections.synchronizedSortedMap();//用于TreeMap
    Collections.synchronizedSortedSet();//用于TreeSet
    Collections.synchronizedMap();       
//用于HashMap、TreeMap、LinkedHashMap
   
之后全部通过联合视图访问底层集合的操作都将是线程安全的,即synchronized关键字就不要求在聚集的表面添加了,但是对于底层集合的间接访问依然是线程不安全。
    4)   
被检查视图:见之下三种情景,第二种情景将会在联谊执行(String)rawList.get()操作时抛出ClassCastException万分,第二种意况则会在rawList.add()操作时就即刻抛出ClassCastException。

boolean isExists=false;
    Iterator iterator=set.iterator();
    while(it.hasNext())           {
    String oldStr=it.next();
    if(newStr.equals(oldStr)){
    isExists=true;
    }
    }
 1     public void uncheckedListTest() {
 2         ArrayList<String> strings = new ArrayList<String>();
 3         ArrayList rawList = strings;
 4         rawList.add(new Date()); //no exception is raised here.
 5         String ss = (String)rawList.get(0); //exception will be thrown here.
 6     }
 7 
 8     public void checkedListTest() {
 9         ArrayList<String> strings = new ArrayList<String>();
10         ArrayList<String> safeStrings = Collections.checkedList(strings,String.class);
11         ArrayList rawList = safeStrings;
12         rawList.add(new Date()); //exception will be thrown here.
13     }

List(列表):    
List的特色是其成分以线性方式存储,集合中得以存放重复对象。
    List接口主要达成类包罗:
    ArrayList() :
代表长度可以更改得数组。能够对成分举办任意的访问,向ArrayList()中插入与
    与删除成分的快逐渐。
    LinkedList():
在贯彻中应用链表数据结构。插入和删除速度快,访问速度慢。
    对于List的妄动访问以来,就是只随机来探寻位于特定岗位的成分。
    List 的 get(int index)
方法放回集合中由参数index指定的目录地点的目的,下标从“0” 初始。
    最大旨的三种检索集合中的全体目标的不二法门:     1: 用for循环和get()方法:

   
注:从集合框架的完整规划技术、伸张性、功能等地点综合比较,Java在此方面和C++的stl相比较依然存在必然的差距。越发是扩大性和效用方面,C++
的标准库定义了越多更灵活的模参增加。由于标准库都是由此沙盘的法子达成的,因而其实施效能要了解优化基于虚函数的虚指针和虚表的那种动态绑定的多态方式,其不足只是编译速度有点慢罢了。
bf88必发唯一官网,    14.    算法:
   
在C++中提供了一套泛型算法,主要包括排序、搜索和比较等通用操作,由于那么些泛型算法完全依照各类集合提供的迭代器(iterator)统一接口,由此可以完成一种中度的泛型操作,以及算法函数和汇集之间的完全松耦合。见如下C++代码:

 for(int i=0; i<list.size();i++){
    System.out.println(list.get(i));
    }
    2: 使用 迭代器(Iterator):
    Iterator it=list.iterator();
    while(it.hashNext){
    System.out.println(it.next);
    }
 1     #include <algorithm>
 2     #include <set>
 3     #include <vector>
 4     using namespace std;
 5     int main()
 6     {
 7         vector<int> v1;
 8         for (int i = 0; i < 10; ++i)
 9             v1.push_back(i);
10         set<int> s1;
11         for (int i = 0; i < 20; ++i)
12             s1.insert(i);
13         sort(v1.begin(),v1.end());
14         binary_search(v1.begin(),v1.end(),5);
15         binary_search(s1.begin(),s1.end(),5);
16         return 0;
17     }

    Map(映射):
    Map
是一种把键对象和值对象映射的聚合,它的每1个因素都蕴涵一对键目的和值对象。
    Map没有继续于Collection接口
    从Map集合中检索成分时,只要给出键对象,就会回去对应的值对象。
    Map 的常用方法:     1 加上,删除操作:
    Object put(Object key, Object value): 向集合中进入元素
    Object remove(Object key):   删除与KEY相关的要素
    void putAll(Map t):   将来自特定映像的保有因素添加给该映像
    void clear(): 从印象中删除全数映射
    2 询问操作:
    Object get(Object key): 得到与第贰字key相关的值
   
Map集合中的键对象不容许再一次,也就说,任意多个键对象通过equals()方法比较的结果都以false.
    不过可以将随意七个键独享映射到同3个值对象上。
    Conllections : 集合实用类
    Conllections提供了供JAVA集合实用的静态方法
    总结:    
JAVA集合的着力用法,都归结了,上边那个是平凡最常用的JAVA集合,具体的其余的,还要参考JDK帮衬文档了,呵呵
关于 Map的施用,还有众多,具体就是那一个,Conllections提供了不少 List /Map
实用的办法,对平庸开发极度有效。

   
在Java中相同提供了那般的泛型算法,不相同的是那几个算法函数都以Collections中静态方法。见如下Java代码:

boolean containsKey(Object key): 判断印象中是否存在主要字key
    boolean containsValue(Object value): 判断印象中是不是留存值value
    int size(): 再次来到当前印象中映射的多少
    boolean isEmpty() :判断影象中是或不是有其余映射
   
List按对象进入的依次保存对象,不做排序或编辑操作。Set对各样对象只接受几遍,并选用本身之中的排序方法(寻常,你只关注有个别成分是不是属于Set,而不敬服它的一一–否则应该运用List)。Map同样对种种成分保存一份,但那是基于”键”的,Map也有内置的排序,因此不关注成分添加的顺序。假设添比索素的相继对您很重大,应该使用
LinkedHashSet大概LinkedHashMap.
    List的听从方法     实际上有两种List:
一种是骨干的ArrayList,其独到之处在于随机走访成分,另一种是更强大的LinkedList,它并不是为高速随机走访安插的,而是具有一套更通用的方法。
    List :
次序是List最要紧的表征:它保证维护成分特定的顺序。List为Collection添加了很多方式,使得可以向List中间插入与移除元素(这只推荐LinkedList使用。)一个List可以生成ListIterator,使用它可以从七个趋势遍历List,也可以从List中间插入和移除成分。
    ArrayList :
由数组完毕的List。允许对成分举行快速随机访问,可是向List中间插入与移除成分的快慢很慢。ListIterator只应该用来由后迈入遍历ArrayList,而不是用来插入和移除成分。因为那比LinkedList费用要大过多。
    LinkedList :
对各类访问进行了优化,向List中间插入与删除的支付并不大。随机走访则相对较慢。(使用ArrayList代替。)还有着下列方法:addFirst(),
addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(),
这么些点子
(没有在其它接口或基类中定义过)使得LinkedList可以作为储藏室、队列和双向队列使用。
    Set的机能方法    
Set具有与Collection完全一样的接口,因而没有其余附加的效用,不像前面有七个不相同的List。实际上Set就是Collection,只是作为不一致。(那是一连与多态思想的第一名应用:表现各异的表现。)Set不保留重复的要素(至于何以判断元素相同则较为负责)
    Set :
存入Set的每一种成分都不能够不是绝无仅有的,因为Set不保留重复成分。参预Set的要素必须定义equals()方法以确保目的的唯一性。Set与Collection有一齐平等的接口。Set接口不保证维护成分的先后。
    HashSet :
为火速搜索设计的Set。存入HashSet的对象必须定义hashCode()。
    TreeSet : 保存次序的Set,
底层为树结构。使用它可以从Set中领到有序的行列。
    LinkedHashSet :
具有HashSet的询问速度,且其中拔取链表维护成分的种种(插入的程序)。于是在选取迭代器遍历Set时,结果会按要素插入的先后呈现。
    Map的效应方法     方法put(Object key, Object
value)添加壹个“值”(想要得东西)和与“值”相关联的“键”(key)(使用它来寻觅)。方法get(Object
key)重回与给定“键”相关联的“值”。可以用containsKey()和containsValue()测试Map中是还是不是含有某些“键”或“值”。标准的Java类库中带有了三种不一样的Map:HashMap,
TreeMap, LinkedHashMap, WeakHashMap,
IdentityHashMap。它们都有同一的中央接口Map,然则作为、效用、排序策略、保存对象的生命周期和判断“键”等价的国策等各差别。
   
执行效能是Map的2个大题材。看看get()要做什么事,就会精晓怎么在ArrayList中寻觅“键”是格外慢的。而那正是HashMap进步速度的地点。HashMap使用了独特的值,称为“散列码”(hash
code),来代表对键的迟缓搜索。“散列码”是“相对唯一”用以代表对象的int值,它是通过将该目的的一点音信举行更换而变更的。全数Java对象都能发出散列码,因为hashCode()是概念在基类Object中的方法。
   
HashMap就是使用对象的hashCode()举办飞速查询的。此措施可以显着进步品质。
    Map : 维护“键值对”的关联性,使您可以通过“键”查找“值”
    HashMap :
Map基于散列表的完毕。插入和询问“键值对”的费用是定点的。可以透过构造器设置容积capacity和负载因子load
factor,以调整容器的特性。
    LinkedHashMap :
类似于HashMap,不过迭代遍历它时,取得“键值对”的种种是其插入次序,可能是近些年至少使用(LRU)的顺序。只比HashMap慢一点。而在迭代做客时发而更快,因为它应用链表维护内部次序。
    TreeMap :
基于红黑树数据结构的落实。查看“键”或“键值对”时,它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的表征在于,你取得的结果是因此排序的。TreeMap是唯一的蕴涵subMap()方法的Map,它可以回来1个子树。
    WeakHashMao : 弱键(weak key)Map,Map中使用的靶子也被允许释放:
那是为化解特殊题材设计的。假如没有map之外的引用指向某些“键”,则此“键”可以被垃圾收集器回收。
    IdentifyHashMap : 使用==代替equals()对“键”作相比较的hash
map。专为消除特殊题材而设计。

 1     public static void main(String[] args) {
 2         List<Integer> v1 = new ArrayList<Integer>();
 3         for (int i = 0; i < 10; ++i)
 4             v1.add(i);
 5         
 6         List<Integer> l1 = new LinkedList<Integer>();
 7         for (int i = 0; i < 20; ++i)
 8             l1.add(i);
 9         
10         Collections.sort(v1);
11         Collections.sort(l1);
12         Collections.binarySearch(v1, 5);
13         Collections.binarySearch(l1, 5);
14     }

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图