汇合
- 提供一种存储空间可变的存储模型，存储的数据容量能够依据需要产生扭转
Collect 接口
- Collection 汇合，首先是一个接口。是 Java 中所有汇合的总接口。一个 Collection 接口代表一组 Object 类，即 Collection 接口的元素。
- Java 不提供间接继承自 Collection 接口的类，只提供继承于的子接口(如 List 接口和 set 接口)。
- Collection 接口存储一组不惟一，无序的对象。
List 接口
- List 接口是一个有序的 Collection 接口，应用此接口可能准确的管制每个元素插入的地位，可能通过索引 (元素在 List 中地位，相似于数组的下标) 来拜访 List 中的元素，第一个元素的索引为 0，而且容许有雷同的元素。
- List 接口存储一组不惟一，有序（插入程序）的对象。
实现类
-
ArrayList
-
ArrayList 汇合的底层逻辑是数组。该类也是实现了 List 接口，实现了可变大小的数组，随机拜访和遍历元素时，提供更好的性能。该类也是非同步的, 在多线程的状况下不要应用。ArrayList 增长以后长度的 50%，插入删除效率低。
代码
package com.collection; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Collection {public static void main(String[] args) { //ArrayList<E> 一般的可变长的数组 元素有序，可反复 List arrayList = new ArrayList(); arrayList.add(true); arrayList.add(123); arrayList.add(123.456); arrayList.add("String"); arrayList.add(true); arrayList.add(123); arrayList.add(123.456); arrayList.add("String"); // 汇合间接打印 System.out.print("----ArrayList 汇合间接打印 ----" + "\n" + arrayList + "\t"); // 一般 for 循环打印 System.out.println("\n----ArrayList 汇合一般 for 循环打印 ----"); for (int i = 0; i < arrayList.size(); i++) {System.out.print(arrayList.get(i)+"\t"); } // 迭代器打印 Iterator iterator = arrayList.iterator(); System.out.println("\n----ArrayList 汇合迭代器打印 ----"); while (iterator.hasNext()) {System.out.print(iterator.next() + "\t"); } //for-each 循环打印 System.out.println("\n----ArrayList 汇合 for-each 循环打印 ----"); for (Object i : arrayList) {System.out.print(i+"\t"); } /* ----ArrayList 汇合间接打印 ---- [true, 123, 123.456, String, true, 123, 123.456, String] ----ArrayList 汇合一般 for 循环打印 ---- true 123 123.456 String true 123 123.456 String ----ArrayList 汇合迭代器打印 ---- true 123 123.456 String true 123 123.456 String ----ArrayList 汇合 for-each 循环打印 ---- true 123 123.456 String true 123 123.456 String */ } }办法 形容 add() 将元素插入到指定地位的 arraylist 中 addAll() 增加汇合中的所有元素到 arraylist 中 clear() 删除 arraylist 中的所有元素 clone() 复制一份 arraylist contains() 判断元素是否在 arraylist get() 通过索引值获取 arraylist 中的元素 indexOf() 返回 arraylist 中元素的索引值 removeAll() 删除存在于指定汇合中的 arraylist 里的所有元素 remove() 删除 arraylist 里的单个元素 -
LinkedList
- 该类实现了 List 接口，容许有 null（空）元素。次要用于创立链表数据结构，LinkedList 查找效率低。
-
该类没有同步办法，如果多个线程同时拜访一个 List，则必须本人实现拜访同步，解决办法就是在创立 List 时候结构一个同步的 List。例如：
List list=Collections.synchronizedList(newLinkedList(...));代码
package com.collection; import java.util.Iterator; import java.util.LinkedList; import java.util.List; public class Collection {public static void main(String[] args) { //LinkedList<E> 底层为双向链表的汇合构造 , 元素有序，可反复 List linkedList = new LinkedList(); linkedList.add(true); linkedList.add(123); linkedList.add(123.456); linkedList.add("String"); linkedList.add(true); linkedList.add(123); linkedList.add(123.456); linkedList.add("String"); // 汇合间接打印 System.out.print("----linkedList 汇合间接打印 ----" + "\n" + linkedList + "\t"); // 一般 for 循环打印 System.out.println("\n----linkedList 一般 for 循环打印 ----"); for (int i = 0; i < linkedList.size(); i++) {System.out.print(linkedList.get(i) + "\t"); } // 迭代器打印 Iterator iterator = linkedList.iterator(); System.out.println("\n----linkedList 汇合迭代器打印 ----"); while (iterator.hasNext()) {System.out.print(iterator.next() + "\t"); } //for-each 循环打印 System.out.println("\n----linkedList 汇合 for-each 循环打印 ----"); for (Object i : linkedList) {System.out.print(i + "\t"); } /* ----linkedList 汇合间接打印 ---- [true, 123, 123.456, String, true, 123, 123.456, String] ----linkedList 一般 for 循环打印 ---- true 123 123.456 String true 123 123.456 String ----linkedList 汇合迭代器打印 ---- true 123 123.456 String true 123 123.456 String ----linkedList 汇合 for-each 循环打印 ---- true 123 123.456 String true 123 123.456 String */ } }办法 形容 public boolean add(E e) 链表开端增加元素，返回是否胜利，胜利为 true，失败为 false。 public void add(int index, E element) 向指定地位插入元素。 public boolean addAll(Collection c) 将一个汇合的所有元素增加到链表前面，返回是否胜利，胜利为 true，失败为 false。 public boolean addAll(int index, Collection c) 将一个汇合的所有元素增加到链表的指定地位前面，返回是否胜利，胜利为 true，失败为 false。 public void addFirst(E e) 元素增加到头部。 public void addLast(E e) 元素增加到尾部。 public boolean offer(E e) 向链表开端增加元素，返回是否胜利，胜利为 true，失败为 false。 public boolean offerFirst(E e) 头部插入元素，返回是否胜利，胜利为 true，失败为 false。 public boolean offerLast(E e) 尾部插入元素，返回是否胜利，胜利为 true，失败为 false。 public void clear() 清空链表。 public E removeFirst() 删除并返回第一个元素。 public E removeLast() 删除并返回最初一个元素。 public boolean remove(Object o) 删除某一元素，返回是否胜利，胜利为 true，失败为 false。 public E remove(int index) 删除指定地位的元素。 public E poll() 删除并返回第一个元素。 public E remove() 删除并返回第一个元素。 public boolean contains(Object o) 判断是否含有某一元素。 public E get(int index) 返回指定地位的元素。 public E getFirst() 返回第一个元素。 public E getLast() 返回最初一个元素。 public int indexOf(Object o) 查找指定元素从前往后第一次呈现的索引。 public int lastIndexOf(Object o) 查找指定元素最初一次呈现的索引。 public E peek() 返回第一个元素。 public E element() 返回第一个元素。 public E peekFirst() 返回头部元素。 public E peekLast() 返回尾部元素。 public E set(int index, E element) 设置指定地位的元素。 public Object clone() 克隆该列表。 public Iterator descendingIterator() 返回倒序迭代器。 public int size() 返回链表元素个数。 public ListIterator listIterator(int index) 返回从指定地位开始到开端的迭代器。 public Object[] toArray() 返回一个由链表元素组成的数组。 public T[] toArray(T[] a) 返回一个由链表元素转换类型而成的数组。 -
Vector
-
该类和 ArrayList 十分类似，然而该类是同步的，能够用在多线程的状况，该类容许设置默认的增长长度，默认扩容形式为原来的 2 倍。
代码
package com.collection; import java.util.Iterator; import java.util.List; import java.util.Vector; public class Collection {public static void main(String[] args) { //vector<E> 一般的可变长的数组 元素有序，可反复，容许多线程 List vector = new Vector(); vector.add(true); vector.add(123); vector.add(123.456); vector.add("String"); vector.add(true); vector.add(123); vector.add(123.456); vector.add("String"); // 汇合间接打印 System.out.print("----vector 汇合间接打印 ----" + "\n" + vector + "\t"); // 一般 for 循环打印 System.out.println("\n----vector 汇合一般 for 循环打印 ----"); for (int i = 0; i < vector.size(); i++) {System.out.print(vector.get(i)); } // 迭代器打印 Iterator iterator = vector.iterator(); System.out.println("\n----vector 汇合迭代器打印 ----"); while (iterator.hasNext()) {System.out.print(iterator.next() + "\t"); } //for-each 循环打印 System.out.println("\n----vector 汇合 for-each 循环打印 ----"); for (Object i : vector) {System.out.print(i + "\t"); } /* ----vector 汇合间接打印 ---- [true, 123, 123.456, String, true, 123, 123.456, String] ----vector 汇合一般 for 循环打印 ---- true123123.456Stringtrue123123.456String ----vector 汇合迭代器打印 ---- true 123 123.456 String true 123 123.456 String ----vector 汇合 for-each 循环打印 ---- true 123 123.456 String true 123 123.456 String */ } }
Set 接口
- Set 具备与 Collection 齐全一样的接口，只是行为上不同，Set 不保留反复的元素。
- Set 接口存储一组惟一，无序的对象。
- Set 没有带索引的办法，因而不能应用一般 for 循环
实现类
-
HashSet
-
HashSet 类实现了 Set 接口，不容许呈现反复元素，不保障汇合中元素的程序，容许蕴含值为 null 的元素，但最多只能一个。
代码
package com.collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Collection {public static void main(String[] args) {
//HashSet<E> 底层存储数据的构造是一个哈希表 元素无序，不可反复
Set hashSet = new HashSet();
hashSet.add(true);
hashSet.add(123);
hashSet.add(123.456);
hashSet.add("String");
hashSet.add(true);
hashSet.add(123);
hashSet.add(123.456);
hashSet.add("String");
// 汇合间接打印
System.out.print("----HashSet 汇合间接打印 ----" + "\n" + hashSet + "\t");
//Set 没有带索引的办法，因而不能应用一般 for 循环
// 迭代器打印
System.out.println("\n----HashSet 汇合迭代器打印 ----");
Iterator iterator = hashSet.iterator();
while (iterator.hasNext()) {System.out.print(iterator.next() + "\t");
}
//for-each 循环打印
System.out.println("\n----HashSet 汇合 for-each 循环打印 ----");
for (Object i : hashSet) {System.out.print(i + "\t");
}
/*
----HashSet 汇合间接打印 ----
[123.456, 123, String, true]
----HashSet 汇合迭代器打印 ----
123.456 123 String true
----HashSet 汇合 for-each 循环打印 ----
123.456 123 String true
*/
}
}-
LinkedHashSet
- 哈希表和链表实现的 Set 接口，具备可预测的迭代程序。
- 由链表保障存入和取出的程序统一
-
由哈希表保障存入的元素不容许反复
代码
package com.collection; import java.util.LinkedHashSet; import java.util.Iterator; public class Collection {public static void main(String[] args) { //linkedHashSet<E> 底层存储数据的构造是哈希表和链表 链表保障元素有序，哈希表保障元素惟一 LinkedHashSet linkedHashSet = new LinkedHashSet(); linkedHashSet.add(true); linkedHashSet.add(123); linkedHashSet.add(123.456); linkedHashSet.add("String"); linkedHashSet.add(true); linkedHashSet.add(123); linkedHashSet.add(123.456); linkedHashSet.add("String"); // 汇合间接打印 System.out.print("----linkedHashSet 汇合间接打印 ----" + "\n" + linkedHashSet + "\t"); //Set 没有带索引的办法，因而不能应用一般 for 循环 // 迭代器打印 System.out.println("\n----linkedHashSet 汇合迭代器打印 ----"); Iterator iterator = linkedHashSet.iterator(); while (iterator.hasNext()) {System.out.print(iterator.next() + "\t"); } //for-each 循环打印 System.out.println("\n----linkedHashSet 汇合 for-each 循环打印 ----"); for (Object i : linkedHashSet) {System.out.print(i + "\t"); } /* ----linkedHashSet 汇合间接打印 ---- [true, 123, 123.456, String] ----linkedHashSet 汇合迭代器打印 ---- true 123 123.456 String ----linkedHashSet 汇合 for-each 循环打印 ---- true 123 123.456 String */ } } -
哈希值
- 哈希值是 JDK 依据对象的地址或字符串或数字算进去的 int 类型的一个数字值
-
Object 类中有一个办法能够取得对象的哈希值 — public int hashCode(T o)
代码
package com.collection;
public class HashCode {public static void main(String[] args) {
String s = "String";
System.out.println("字符串 s 的哈希值 1：" + s.hashCode());
System.out.println("字符串 s 的哈希值 2：" + s.hashCode());
/*
字符串 s 的哈希值 1：-1808118735
字符串 s 的哈希值 2：-1808118735
*/
Person p = new Person("AAA", 20);
System.out.println("人员类对象 p 的哈希值 1：" + p.hashCode());
System.out.println("人员类对象 p 的哈希值 2：" + p.hashCode());
/*
人员类对象 p 的哈希值 1：460141958
人员类对象 p 的哈希值 2：460141958
*/
// 论断：默认状况下同一对象不必次调用 hashCode()办法取得的哈希值是雷同的
System.out.println("----------------------------");
String s1 = "String";
String s2 = "String";
System.out.println("字符串 s1 的哈希值：" + s1.hashCode());
System.out.println("字符串 s2 的哈希值：" + s2.hashCode());
/*
字符串 s1 的哈希值：-1808118735
字符串 s2 的哈希值：-1808118735
*/
// 论断：默认状况下雷同数据类型雷同值，调用 hashCode()办法取得的哈希值是雷同的
Person p1 = new Person("AAA", 20);
Person p2 = new Person("AAA", 20);
System.out.println("人员类对象 p1 的哈希值：" + p1.hashCode());
System.out.println("人员类对象 p2 的哈希值：" + p2.hashCode());
/*
人员类对象 p1 的哈希值：1163157884
人员类对象 p2 的哈希值：1956725890
*/
// 论断：默认状况下不同自定义对象雷同值，调用 hashCode()办法取得的哈希值是不同的
// 非凡状况
System.out.println("重地".hashCode());
System.out.println("通话".hashCode());
// 二者哈希值雷同
//1179395
//1179395
}
}
-
TreeSet
-
该类实现了 Set 接口，由哈希表反对，能够实现排序等性能。
代码
package com.collection; import java.util.TreeSet; import java.util.Iterator; import java.util.Set; public class Collection {public static void main(String[] args) { //treeSet<E> 底层存储数据的构造是一个哈希表 元素无序，不可反复 Set treeSet = new TreeSet(); treeSet.add("AAA"); treeSet.add("BBB"); treeSet.add("CCC"); treeSet.add("DDD"); treeSet.add("AAA"); treeSet.add("CCC"); // 汇合间接打印 System.out.print("----treeSet 汇合间接打印 ----" + "\n" + treeSet + "\t"); //Set 没有带索引的办法，因而不能应用一般 for 循环 // 迭代器打印 System.out.println("\n----treeSet 汇合迭代器打印 ----"); Iterator iterator = treeSet.iterator(); while (iterator.hasNext()) {System.out.print(iterator.next() + "\t"); } //for-each 循环打印 System.out.println("\n----treeSet 汇合 for-each 循环打印 ----"); for (Object i : treeSet) {System.out.print(i + "\t"); } /* ----treeSet 汇合间接打印 ---- [AAA, BBB, CCC, DDD] ----treeSet 汇合迭代器打印 ---- AAA BBB CCC DDD ----treeSet 汇合 for-each 循环打印 ---- AAA BBB CCC DDD */ } }Tree Set 详解（有参结构与无参结构）
// 自定义人员类 package com.collection; public class Person implements Comparable<Person> { private String name; private int age; public Person() {} public Person(String name, int age) { this.name = name; this.age = age; } public String getName() {return name;} public void setName(String name) {this.name = name;} public int getAge() {return age;} public void setAge(int age) {this.age = age;} //TreeSet 接口是间接的实现了 Set 接口。TreeSet 汇合的元素应用 Compilable 接口进行天然排序。// 这个天然排序的类称之为天然排序类，该类的 compileTo 办法称为天然排序办法 //Compilable 接口会对实现它的每一个类强加一个天然排序 // 因而自定义的学生类要先实现 Compilable 接口，重写 compareTo 办法 @Override public int compareTo(Person p) { /* compareTo 办法 返回 0: 示意该元素与上一元素的比照后果为：两个元素相等 返回负数：示意该元素与上一元素的比照后果为：后者大于前者 返回正数：示意该元素与上一元素的比照后果为：前者大于后者 return 0; return 1; return -1; 如果 compareTo 办法返回后果写死是 0，则视为 TreeSet 汇合存储的元素全副相等。因而不会反复存储。这会导致输入 TreeSet 汇合的值会只有第一个增加的元素 如果 compareTo 办法返回后果写死是负数，则视为 TreeSet 汇合存储的元素后者始终大于前者，因而会依照增加的顺序存储。这导致会依照增加的程序输入 TreeSet 汇合的值 如果 compareTo 办法返回后果写死是正数，则视为 TreeSet 汇合存储的元素后者始终小于前者，因而会依照增加的相同顺序存储。这导致会依照增加的相同程序输入 TreeSet 汇合的值 */ // 需要：依照人员的年龄进行升序排序，年龄相等依照名字升序排序 int num = this.age - p.age; // this.age 为后者，s.age 为前者。如果 num > 0 则后者比前者年龄大 //compareTo 办法自身就能够用于比拟 String 类型字符串。例：a.compareTo(b): 若 a 大于 b, 则返回负数，反之返回正数 // 三元运算符：如果 num=0，则返回 this.name.compareTo(p.name) 的比拟后果的值，如果 num!=0，则返回 num 的值 return (num == 0 ? this.name.compareTo(p.name) : num); } } //TreeSet 测试类 package com.collection; import java.util.Comparator; import java.util.Set; import java.util.TreeSet; public class TreeSetTest {public static void main(String[] args) {System.out.println("TreeSet 汇合应用无参结构定义"); TreeSetTestNoParameter(); System.out.println("TreeSet 汇合应用有参结构定义"); TreeSetTestHasParameter();} public static void TreeSetTestNoParameter() { //TreeSet 汇合应用无参结构定义 Set<Person> treeSet = new TreeSet<Person>(); Person p1 = new Person("AAA", 20); Person p2 = new Person("BBB", 21); Person p3 = new Person("CCC", 22); Person p4 = new Person("DDD", 21); Person p5 = new Person("ABC", 22); Person p6 = new Person("ABC", 22); // 增加赋值元素的值 treeSet.add(p1); treeSet.add(p2); treeSet.add(p3); treeSet.add(p4); treeSet.add(p5); treeSet.add(p6); for (Person i : treeSet) {System.out.println("Name:" + i.getName() + "\tAge:" + i.getName()); // 只能通过 getter()办法获取 Perso 类的公有成员变量} /* TreeSet 汇合应用无参结构定义 Name:AAA Age:20 Name:BBB Age:21 Name:DDD Age:21 Name:ABC Age:22 Name:CCC Age:22 论断：用 TreeSet 汇合存储自定义对象，无参构造方法应用的是天然排序对汇合元素进行排序的 天然排序就是让元素所属的类 (该例子为 Person 类) 实现 Compilable 接口，重写 CompileTo(T o)办法 重写办法时，能够依据排序要求的中药条件和主要条件来实现排序逻辑 */ } public static void TreeSetTestHasParameter() { //TreeSet 汇合应用有参结构定义 TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() { // 匿名外部类 @Override public int compare(Person p1, Person p2) { //p1 示意正在存入汇合的元素，为后者。p2 示意已存入汇合的元素，为前者 int num = p1.getAge() - p2.getAge(); // 判断量人员类元素的年龄是否相等 return (num == 0 ? p1.getName().compareTo(p2.getName()) : num); // 三元运算符：判断如果年龄相等则比拟名字，否则返回年龄比拟的后果值 } }); Person p1 = new Person("AAA", 20); Person p2 = new Person("BBB", 21); Person p3 = new Person("CCC", 22); Person p4 = new Person("DDD", 21); Person p5 = new Person("ABC", 22); Person p6 = new Person("ABC", 22); // 增加赋值元素的值 treeSet.add(p1); treeSet.add(p2); treeSet.add(p3); treeSet.add(p4); treeSet.add(p5); treeSet.add(p6); for (Person i : treeSet) {System.out.println("Name:" + i.getName() + "\tAge:" + i.getName()); } /* TreeSet 汇合应用有参结构定义 Name:AAA Age:20 Name:BBB Age:21 Name:DDD Age:21 Name:ABC Age:22 Name:CCC Age:22 论断：用 TreeSet 汇合存储自定义对象，有参构造方法应用的是比拟器 (Comparator) 排序对汇合元素进行排序的 比拟器排序就是让汇合构造方法接管 Comparator 的实现类对象，compare(T o1,T o2)办法 重写办法时，能够依据排序要求的次要条件和主要条件来实现排序逻辑 */ } }
Map 接口
- Map 接口存储一组键值对象，提供 key（键）到 value（值）的映射。Map<K,V>
- 一张 Map 不能蕴含反复的键，每个键能够映射到至少一个值。
实现类
-
HashMap
- HashMap 是一个散列表，它存储的内容是键值对 (key-value) 映射。
-
该类实现了 Map 接口，依据键的 HashCode 值存储数据，具备很快的访问速度，最多容许一条记录的键为 null，不反对线程同步。
办法 形容 clear() 删除 hashMap 中的所有键 / 值对 clone() 复制一份 hashMap isEmpty() 判断 hashMap 是否为空 size() 计算 hashMap 中键 / 值对的数量 put() 将键 / 值对增加到 hashMap 中 putAll() 将所有键 / 值对增加到 hashMap 中 putIfAbsent() 如果 hashMap 中不存在指定的键，则将指定的键 / 值对插入到 hashMap 中。 remove() 删除 hashMap 中指定键 key 的映射关系 containsKey() 查看 hashMap 中是否存在指定的 key 对应的映射关系。 containsValue() 查看 hashMap 中是否存在指定的 value 对应的映射关系。 replace() 替换 hashMap 中是指定的 key 对应的 value。 replaceAll() 将 hashMap 中的所有映射关系替换成给定的函数所执行的后果。 get() 获取指定 key 对应对 value getOrDefault() 获取指定 key 对应对 value，如果找不到 key，则返回设置的默认值 forEach() 对 hashMap 中的每个映射执行指定的操作。 entrySet() 返回 hashMap 中所有映射项的汇合汇合视图。 keySet() 返回 hashMap 中所有 key 组成的汇合视图。 values() 返回 hashMap 中存在的所有 value 值。 merge() 增加键值对到 hashMap 中 compute() 对 hashMap 中指定 key 的值进行从新计算 computeIfAbsent() 对 hashMap 中指定 key 的值进行从新计算，如果不存在这个 key，则增加到 hasMap 中 computeIfPresent() 对 hashMap 中指定 key 的值进行从新计算，前提是该 key 存在于 hashMap 中。 代码
package com.collection; import java.util.Collection; import java.util.Iterator; import java.util.Map; import java.util.Set; public class HashMap {public static void main(String[] args) { //HashMap 是无序的，即不会记录插入的程序。// 存储的内容是键值对 (key-value) 映射 // 一张 Map 不能蕴含反复的键，每个键能够映射到至少一个值。java.util.HashMap<Integer, String> hashMap = new java.util.HashMap<Integer, String>(); // 增加元素值 hashMap.put(111, "AAA"); hashMap.put(222, "BBB"); hashMap.put(333, "CCC"); hashMap.put(444, "DDD"); System.out.println("-------- 间接打印 hashMap 的值 ------"); System.out.println(hashMap); /* -------- 间接打印 hashMap 的值 ------ {444=DDD, 333=CCC, 222=BBB, 111=AAA} */ // 通过 keySet()办法能够获取 Map 汇合的 key 值汇合视图，返回的是一个 Set 汇合 System.out.println("-------- 打印 hashMap 的 key 汇合视图 ------"); Set<Integer> keySet = hashMap.keySet(); System.out.println(keySet); /* -------- 打印 hashMap 的 key 汇合视图 ------ [444, 333, 222, 111] */ // 通过 values()办法能够获取 Map 汇合的 value 值汇合视图，返回的是一个 Collection 汇合 System.out.println("-------- 打印 hashMap 的 value 汇合视图 ------"); Collection<String> values = hashMap.values(); for (Object v : values) {System.out.print(v + "\t"); } /* -------- 打印 hashMap 的 value 汇合视图 ------ DDD CCC BBB AAA */ // 通过 entrySet()办法能够获取 Map 汇合的 key-value 对汇合视图，返回的是一个 Set 汇合 System.out.println("\n-------- 打印 hashMap 的 key-value 对汇合视图 ------"); Set<Map.Entry<Integer, String>> entrySet = hashMap.entrySet(); for (Map.Entry<Integer, String> i : entrySet) {Integer num = i.getKey(); String str = i.getValue(); System.out.print(num + "=" + str + "\t"); } /* -------- 打印 hashMap 的 key-value 对汇合视图 ------ 444=DDD 333=CCC 222=BBB 111=AAA */ System.out.println("\n-------- 打印 hashMap 的值(加强 for 遍历 key 汇合视图)------"); // 因为 Map 汇合是通过键 (key) 来获取值(value)，因而先通过 .keySet() 办法获取 hashMap 中所有 key 组成的汇合视图。// 返回的汇合试图没有索引，因而不能应用一般 for 循环遍历，只能应用加强 for 循环或者迭代器进行遍历 // 遍历 key 汇合视图，利用.get()办法以 key 作为参数获取 hashMap 汇合的 value 值 for (Integer i : hashMap.keySet()) {System.out.print(i + "=" + hashMap.get(i) + "\t"); } /* -------- 打印 hashMap 的值(加强 for 遍历 key 汇合视图)------ 444=DDD 333=CCC 222=BBB 111=AAA */ System.out.println("\n-------- 打印 hashMap 的值(迭代器遍历 key 汇合视图)------"); Iterator<Integer> iterator = keySet.iterator(); while (iterator.hasNext()) {Integer key = iterator.next(); System.out.print(key + "=" + hashMap.get(key) + "\t"); } /* -------- 打印 hashMap 的值(迭代器遍历 key 汇合视图)------ 444=DDD 333=CCC 222=BBB 111=AAA */ System.out.println("\n-------- 再增加两个值 --------"); hashMap.put(444, "EEEE"); hashMap.put(555, "CCCC"); System.out.println("-------- 增加值后间接打印 hashMap 的值 ------"); System.out.println(hashMap); /* -------- 再增加两个值 -------- -------- 增加值后间接打印 hashMap 的值 ------ {555=CCCC, 444=EEEE, 333=CCC, 222=BBB, 111=AAA} */ // 论断：因为 Map 汇合会保障 key 值的唯一性，因而如果 put 入 Map 汇合元素的 key 值与已有 key 值反复，则会将后者元素的 value 值笼罩掉雷同 key 值元素映射的 value 值 //Map 只是不容许元素 key 值反复，然而容许不同 key 值的元素对应的 value 值相等 } }