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

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
倍,那样会推动一定的空间浪费,不过为了制止日常增添而带来的性子开支,只好是用空间换取时间了。假诺在容器的中等添加大概去除一个因素都将会招致后边的
成分向后或向前挪动贰个岗位,假设成分数量较多且该操作相比较频仍,将会导致系统的本性下落,不过对于容器中成分的私下访问品质较好,以下为
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:   
该集合是通过双向链表来促成的,对于钦赐地点成分的遍历其内部做了三个小的优化,假诺position大于len/2,由于个中的数据结构是双向链表,因此可以从后迈入遍历,以压缩遍历进程中节点跳转的次数。ArrayList中的大多数代码示例都适用于LinkedList,以下近给出
LinkedList特有的常用示例代码:

HashSet 一种没有重新元素的无序集聚

4.TreeSet   有序集

  (1)
使用情势iterator()须求容器重返2个Iterator。第3遍调用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()得到类别中的下四个因素。

    4.    ArrayList和LinkedList的相同点:
    1)    都以接口List<E>的落到实处类;
    2)   
都能够透过iterator()方法重返Iterator<E>迭代器对象,并能够通过该对象遍历容器中的成分;
    3)   
借使多个Iterator<E>实例同时援引同三个见面对象,那么当有三个正在遍历,而此外三个修改(add/remove)了聚众对象中的
成分,对于第一个迭代器再展开迭代时将会引发ConcurrentModificationException万分的发生。
    5.    ArrayList和LinkedList的分化点:
    1)   
对ArrayList和LinkedList而言,在列表末尾扩展三个成分所花的费用都以原则性的。对ArrayList而言,首假使在里面数组中增加一
项,指向所添加的要素,偶尔大概会导致对数组重新举办分配;而对LinkedList而言,这一个花费是统一的,分配三个内部Entry对象。
    2)   
在ArrayList的中间插入或删除3个成分意味着这么些列表中剩下的因素都会被挪动;而在LinkedList的中档插入或删除一个要素的付出是一贯的。
    3)    LinkedList不协助飞速的私自成分访问。
    4)   
ArrayList的空中浪费首要反映在在list列表的最终预留一定的体积空间,而LinkedList的上空开支则呈将来它的各个要素都亟待消耗一定的半空中
   
在C++的标准库中,ArrayList和LinkedList之间的施用差距以及分级的利害也一样突显于vector和list。
    6.    HashSet:
散列表为各样对象计算出一个平头(通过Object缺省的或类重载的hashCode域方法),称为散列码。在Java中,散列表是行使链表的数组来贯彻
的,每一种链表被喻为三个哈希桶。倘诺想在哈希表中检索3个指标,则要求先总计对象的hashCode,之后对表内的桶数取余数,得到的结果就是哈希桶的索
引,此时若是该桶为空桶,就足以一贯将该目的插入到该桶中,要是已经有对象存在了,则需求各类进行比较,一旦发觉该与该目的相等的靶子(equals()
重回true),就会扬弃本次插入操作,不然将该指标插入到该桶的末尾。HashSet在结构的时候提供多个参数,二个是initialCapacity
内定了桶的多寡(实际的桶数为2的initialCapacity次幂),另1个是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 一种能够长足去除最小成分的会晤

java库中实际集合,java中现实集合。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关联的映射

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)   :向聚集中投入一个指标的引用
    void clear()                       
:删除集合中有着的靶子,即不再具有这几个目的的引用
    boolean isEmpty()           :判断集合是或不是为空
    boolean contains(Object o): 判断集合中是不是享有一定对象的引用
    Iterartor iterator()              :
重临一个Iterator对象,能够用来遍历集合中的成分
    boolean remove(Object o):从集合中除去八个对象的引用
    int size()                               :重回集合中成分的数量
    Object[] toArray()                
:再次来到1个数组,该数组中归纳集合中的全部因素
    关于:Iterator() 和toArray()
方法都用于集合的全体的因素,前者再次回到3个Iterator对象,后者重临二个带有集合中装有因素的数组。
    Iterator接口证明了之类方法:     hasNext(): 判断集合中成分是还是不是遍历完成,若是没有,就回到true
    next()       :重回下1个因素
    remove():从集合中删除上2个有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);
那第②个索引上的多寡是被含有的,第四个目录的数据是不被含有的。假诺执行了group2.clear()操作情状了视图中的数据,那么staff中那段
范围内的数码也会被连同删除。对于有序聚集和映射表(Map),能够应用排序依次而不是因素地方建立子范围,如SortedSet接口注明的
SortedSet<E> subSet(E from,E to); SortedSet<E> headSet(E
to); SortedSet<E> tailSet(E from);
注意那几个参数的体系均不是因素的目录,而是对象自小编。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++
的标准库定义了越多更灵活的模参扩大。由于标准库都以透过沙盘的不二法门贯彻的,因而其实施效能要显著优于基于虚函数的虚指针和虚表的那种动态绑定的多态情势,其不足只是编写翻译速度有点慢罢了。
    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
是一种把键对象和值对象映射的聚众,它的每二个因素都包涵一对键指标和值对象。
    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.
    但是能够将轻易多个键独享映射到同二个值对象上。
    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的贰个大题材。看看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,它能够回来二个子树。
    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地图