一、UML(统一建模语言)集合框架类图

编辑

二、Java集合框架概述

三、List集合使用

四、Set集合的使用

五、Map集合详解

①HashMap集合：

②TreeMap集合：

一、UML(统一建模语言)集合框架类图

二、Java集合框架概述

　　集合可以看作是一种容器，用来存储对象信息。所有集合类都位于java.util包下，但支持多线程的集合类位于java.util.concurrent包下。

　　数组与集合的区别如下：

　　1）数组长度不可变化而且无法保存具有映射关系的数据；集合类用于保存数量不确定的数据，以及保存具有映射关系的数据。

　　2）数组元素既可以是基本类型的值，也可以是对象；集合只能保存对象。

　　Java集合类主要由两个根接口Collection和Map派生出来的，Collection派生出了三个子接口：List、Set、Queue（Java5新增的队列），因此Java集合大致也可分成List、Set、Queue、Map四种接口体系，（注意：Map不是Collection的子接口）。

　　其中List代表了有序可重复集合，可直接根据元素的索引来访问；Set代表无序不可重复集合，只能根据元素本身来访问；Queue是队列集合；Map代表的是存储key-value对的集合，可根据元素的key来访问value。

　　上图中淡绿色背景覆盖的是集合体系中常用的实现类，分别是ArrayList、LinkedList、ArrayQueue、HashSet、TreeSet、HashMap、TreeMap等实现类。

二、Java集合常见接口及实现类

1. Collection接口常见方法（来源于Java API）

2. Set集合

　　Set集合与Collection的方法相同，由于Set集合不允许存储相同的元素，所以如果把两个相同元素添加到同一个Set集合，则添加操作失败，新元素不会被加入，add()方法返回false。为了帮助理解，请看下面代码示例：

public class Test {public static void main(String[] args) {Set<String> set = new HashSet<String>();set.add("hello world");set.add("hello 美好的世界");set.add("hello 美好的世界");//添加不进去System.out.println("集合中元素个数："+set.size());System.out.println("集合中元素为："+set.toString());}
}

运行结果如下：

集合中元素个数：2
集合中元素为：[hello world, hello 美好的世界]

分析：由于String类中重写了hashCode()和equals()方法，用来比较指向的字符串对象所存储的字符串是否相等。所以这里的第二个"hello 美好的世界"是加不进去的。

下面着重介绍Set集合几个常用实现类：

1）HashSet类

　　HashSet是Set集合最常用实现类，是其经典实现。HashSet是按照hash算法来存储元素的，因此具有很好的存取和查找性能。

　　HashSet具有如下特点：

　　♦ 不能保证元素的顺序。

　　♦ HashSet不是线程同步的，如果多线程操作HashSet集合，则应通过代码来保证其同步。

　　♦ 集合元素值可以是null。

　　HashSet存储原理如下：

　　当向HashSet集合存储一个元素时，HashSet会调用该对象的hashCode()方法得到其hashCode值，然后根据hashCode值决定该对象的存储位置。HashSet集合判断两个元素相等的标准是(1)两个对象通过equals()方法比较返回true；(2)两个对象的hashCode()方法返回值相等。因此，如果(1)和(2)有一个不满足条件，则认为这两个对象不相等，可以添加成功。如果两个对象的hashCode()方法返回值相等，但是两个对象通过equals()方法比较返回false，HashSet会以链式结构将两个对象保存在同一位置，这将导致性能下降，因此在编码时应避免出现这种情况。

　　HashSet查找原理如下：

　　基于HashSet以上的存储原理，在查找元素时，HashSet先计算元素的HashCode值（也就是调用对象的hashCode方法的返回值），然后直接到hashCode值对应的位置去取出元素即可，这就是HashSet速度很快的原因。

　　重写hashCode()方法的基本原则如下：

　　♦ 在程序运行过程中，同一个对象的hashCode()方法返回值应相同。

　　♦ 当两个对象通过equals()方法比较返回true时，这两个对象的hashCode()方法返回值应该相等。

　　♦ 对象中用作equals()方法比较标准的实例变量，都应该用于计算hashCode值。

2）LinkedHashSet类

　　LinkedHashSet是HashSet的一个子类，具有HashSet的特性，也是根据元素的hashCode值来决定元素的存储位置。但它使用链表维护元素的次序，元素的顺序与添加顺序一致。由于LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet，但在迭代访问Set里的全部元素时由很好的性能。

3）TreeSet类

　　TreeSet时SortedSet接口的实现类，TreeSet可以保证元素处于排序状态，它采用红黑树的数据结构来存储集合元素。TreeSet支持两种排序方法：自然排序和定制排序，默认采用自然排序。

　　♦ 自然排序

　　TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素的大小关系，然后将元素按照升序排列，这就是自然排序。如果试图将一个对象添加到TreeSet集合中，则该对象必须实现Comparable接口，否则会抛出异常。当一个对象调用方法与另一个对象比较时，例如obj1.compareTo(obj2)，如果该方法返回0，则两个对象相等；如果返回一个正数，则obj1大于obj2；如果返回一个负数，则obj1小于obj2。

　　Java常用类中已经实现了Comparable接口的类有以下几个：

　　♦ BigDecimal、BigDecimal以及所有数值型对应的包装类：按照它们对应的数值大小进行比较。

　　♦ Charchter：按照字符的unicode值进行比较。

　　♦ Boolean：true对应的包装类实例大于false对应的包装类实例。

　　♦ String：按照字符串中的字符的unicode值进行比较。

　　♦ Date、Time：后面的时间、日期比前面的时间、日期大。

　　对于TreeSet集合而言，它判断两个对象是否相等的标准是：两个对象通过compareTo(Object obj)方法比较是否返回0，如果返回0则相等。

　　♦ 定制排序

　　想要实现定制排序，需要在创建TreeSet集合对象时，提供一个Comparator对象与该TreeSet集合关联，由Comparator对象负责集合元素的排序逻辑。

　　综上：自然排序实现的是Comparable接口，定制排序实现的是Comparator接口。（具体代码实现会在后续章节中讲解）

4）EnumSet类

　　EnumSet是一个专为枚举类设计的集合类，不允许添加null值。EnumSet的集合元素也是有序的，它以枚举值在Enum类内的定义顺序来决定集合元素的顺序。

5）各Set实现类的性能分析

　　HashSet的性能比TreeSet的性能好（特别是添加，查询元素时），因为TreeSet需要额外的红黑树算法维护元素的次序，如果需要一个保持排序的Set时才用TreeSet，否则应该使用HashSet。

　　LinkedHashSet是HashSet的子类，由于需要链表维护元素的顺序，所以插入和删除操作比HashSet要慢，但遍历比HashSet快。

　　EnumSet是所有Set实现类中性能最好的，但它只能保存同一个枚举类的枚举值作为集合元素。

　　以上几个Set实现类都是线程不安全的，如果多线程访问，必须手动保证集合的同步性，这在后面的章节中会讲到。

3. List集合

　　List集合代表一个有序、可重复集合，集合中每个元素都有其对应的顺序索引。List集合默认按照元素的添加顺序设置元素的索引，可以通过索引（类似数组的下标）来访问指定位置的集合元素。

　　实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。

1）ArrayList

ArrayList是一个动态数组，也是我们最常用的集合，是List类的典型实现。它允许任何符合规则的元素插入甚至包括null。每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。随着容器中的元素不断增加，容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作。所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。

ArrayList擅长于随机访问。同时ArrayList是非同步的。

2）LinkedList

LinkedList是List接口的另一个实现，除了可以根据索引访问集合元素外，LinkedList还实现了Deque接口，可以当作双端队列来使用，也就是说，既可以当作“栈”使用，又可以当作队列使用。

　　LinkedList的实现机制与ArrayList的实现机制完全不同，ArrayLiat内部以数组的形式保存集合的元素，所以随机访问集合元素有较好的性能；LinkedList内部以链表的形式保存集合中的元素，所以随机访问集合中的元素性能较差，但在插入删除元素时有较好的性能。

3）Vector

与ArrayList相似，但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与ArrayList几乎一样。

4）Stack

Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

5）Iterator接口和ListIterator接口

　　Iterator是一个接口，它是集合的迭代器。集合可以通过Iterator去遍历集合中的元素。Iterator提供的API接口如下：

　　♦ boolean hasNext()：判断集合里是否存在下一个元素。如果有，hasNext()方法返回 true。
　　♦ Object next()：返回集合里下一个元素。
　　♦ void remove()：删除集合里上一次next方法返回的元素。

　　ListIterator接口继承Iterator接口，提供了专门操作List的方法。ListIterator接口在Iterator接口的基础上增加了以下几个方法：

　　♦ boolean hasPrevious()：判断集合里是否存在上一个元素。如果有，该方法返回 true。
　　♦ Object previous()：返回集合里上一个元素。
　　♦ void add(Object o)：在指定位置插入一个元素。

　　以上两个接口相比较，不难发现，ListIterator增加了向前迭代的功能（Iterator只能向后迭代），ListIterator还可以通过add()方法向List集合中添加元素（Iterator只能删除元素）。

4. Map集合

　　Map接口采用键值对Map<K,V>的存储方式，保存具有映射关系的数据，因此，Map集合里保存两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value可以是任意引用类型的数据。key值不允许重复，可以为null。如果添加key-value对时Map中已经有重复的key，则新添加的value会覆盖该key原来对应的value。常用实现类有HashMap、LinkedHashMap、TreeMap等。

　　Map常见方法（来源于API）如下：

1）HashMap与Hashtable

　　HashMap与Hashtable是Map接口的两个典型实现，它们之间的关系完全类似于ArrayList与Vertor。HashTable是一个古老的Map实现类，它提供的方法比较繁琐，目前基本不用了，HashMap与Hashtable主要存在以下两个典型区别：

　　♦ HashMap是线程不安全，HashTable是线程安全的。

　　♦ HashMap可以使用null值最为key或value；Hashtable不允许使用null值作为key和value，如果把null放进HashTable中，将会发生空指针异常。

　　为了成功的在HashMap和Hashtable中存储和获取对象，用作key的对象必须实现hashCode()方法和equals()方法。

　　HashMap工作原理如下：

　　HashMap基于hashing原理，通过put()和get()方法存储和获取对象。当我们将键值对传递给put()方法时，它调用建对象的hashCode()方法来计算hashCode值，然后找到bucket位置来储存值对象。当获取对象时，通过建对象的equals()方法找到正确的键值对，然后返回对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会存储在链表的下一个节点中。

2）LinkedHashMap实现类

　　LinkedHashMap使用双向链表来维护key-value对的次序（其实只需要考虑key的次序即可），该链表负责维护Map的迭代顺序，与插入顺序一致，因此性能比HashMap低，但在迭代访问Map里的全部元素时有较好的性能。

3）Properties

　　Properties类时Hashtable类的子类，它相当于一个key、value都是String类型的Map，主要用于读取配置文件。

4）TreeMap实现类

　　TreeMap是SortedMap的实现类，是一个红黑树的数据结构，每个key-value对作为红黑树的一个节点。TreeMap存储key-value对时，需要根据key对节点进行排序。TreeMap也有两种排序方式：

　　♦ 自然排序：TreeMap的所有key必须实现Comparable接口，而且所有的key应该是同一个类的对象，否则会抛出ClassCastException。

　　♦ 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。

5）各Map实现类的性能分析

　　♦ HashMap通常比Hashtable（古老的线程安全的集合）要快

　　♦ TreeMap通常比HashMap、Hashtable要慢，因为TreeMap底层采用红黑树来管理key-value。

　　♦ LinkedHashMap比HashMap慢一点，因为它需要维护链表来爆出key-value的插入顺序。　

三、List集合使用

1.循环遍历；2.循环删除；3.迭代器；4.list集合特性

package com.j2ee.text;import java.util.ArrayList;
import java.util.List;/*** 测试* @author Administrator**/
public class Test {
public static void main(String[] args) {
//实例化list集合(net包中)List<Object> list = new ArrayList<Object>();//添加数据list.add(new String("张三"));list.add("李四");list.add(5);list.add("张小帅");list.add("李四");//遍历list集合，3种方式//1.for循环遍历 //特点：1.有序    2.可重复for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}
//代码结果：
//张三
//李四
//5
//张小帅李四
//有序：插入数据的顺序是什么，那么我们在遍历list集合的时候数据显示就是什么样的顺序。//2.foreach遍历for (Object object : list) {System.out.println(object);}//2.1.jdk1.8版本新特性遍历：list.forEach(System.out::println);
//3.迭代器遍历Iterator<Object> it = list.iterator();  while(it.hasNext()) {Object val = it.next();System.out.println(val);}//list集合删除方式//1.for循环删除//list集合特性：当删除了一个前面的元素后，后面的元素会自动往前靠。for (int i = list.size()-1; i>=0; i--) {list.remove(i);}Integer lenght = list.size();for (int i = 0; i < list.size(); i++) {list.remove(0);}System.out.println(list.size());System.out.println(list);//2.迭代器遍历删除System.out.println("-----------------");Iterator<Object> it = list.iterator();while(it.hasNext()) {it.next();it.remove();}System.out.println(list.size());System.out.println(list);//3.调用list集合中全部清空的方法System.out.println("----------------");list.clear();System.out.println(list.size());System.out.println(list);System.out.println("----------------");System.out.println(list.size());System.out.println(list);System.out.println("-----------------------------------------");//list优化：核心概念：①初始化变量（开始为10个Object数组）；②负载因子（扩容比例1.5）；③计算公式；//当数据大于10个Object数组所能容纳的个数时，会自动扩容，扩容比例为：当前容器大小*负载因子List list1 = new ArrayList();//添加数据，用于观察list集合的Object[]数组个数的扩容情况for (int i = 1; i <= 50; i++) {System.out.println(i);list.add(i);getLen(list);}//优化代码：//当我们知道自己要添加多少个数据的时候，我们利用集合的构造方法进行定义即可，
//避免Object[]个数大于数据的情况
//例如：以上我们已经生成了50个数据，我们把上面的List list1 = new ArrayList();替换成下面：List list1 = new ArrayList(50);System.out.println("-----------------------------------------");//泛型：以类型作为参数的类叫做泛型//作用：提供程序健壮性，简化代码List<Integer> arraylist = new ArrayList<Integer>();//添加数据arraylist.add(56);arraylist.add(53);arraylist.add(52);arraylist.add(55);arraylist.add(57);arraylist.add(23);//什么是泛型，就是集合规定了数据类型<数据类型>//获取偶数的数据for (int i = 0; i < arraylist.size(); i++) {if(arraylist.get(i)%2==0) {System.out.println("------偶数-------");System.out.println(arraylist.get(i));}}System.out.println("-----------------------------------------");//装箱：把值类型(基本数据类型)转换成引用类型Integer n = new Integer(1);//拆箱：把引用类型转换成基本类型int aa = n.intValue();//jdk1.5版本之后引入了自动装箱和自动拆箱功能，因此我们在写代码时
//如果我们已经安装jdk1.5版本之后，则不需要将八大基本数据类型转成引用类型,添加至集合中。
}
//定义一个方法
/*** 该方法用户查看list集合中数据不同Object数组的个数* @param list 集合*/
public static void getLen(List list) {try {//获取Object集合Field field = list.getClass().getDeclaredField("elementData");//打开权限field.setAccessible(true);//转换成Object数组类型Object[] obj= (Object[])field.get(list);//打印数组长度System.out.println("集合大小为："+obj.length);} catch (Exception e) {//e.printStackTrace();}
}
}

四、Set集合的使用

①HashSet:1.无序；2.唯一；3.底层结构：HashMap

package com.set.test;import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;/*** Set集合测试类* * @author Administrator**/
public class SetText {private Integer sage;// 年龄private String sname;// 姓名public SetText(Integer sage, String sname) {super();this.sage = sage;this.sname = sname;}public SetText(String sname) {super();this.sname = sname;}public Integer getSage() {return sage;}public void setSage(Integer sage) {this.sage = sage;}public String getSname() {return sname;}public void setSname(String sname) {this.sname = sname;}// 打印所有属性值(比较方式)@Overridepublic String toString() {return "SetText [sage=" + sage + ", sname=" + sname + "]";}// 判断对象是否相同@Overridepublic int hashCode() {// 判断当前属性是否存在，存在那么比较下一个属性(0)，如果两个属性都不存在()，调用equals方法继续判断final int prime = 31;int result = 1;// result = prime * result + ((sage == null) ? 0 : sage.hashCode());result = prime * result + ((sname == null) ? 0 : sname.hashCode());return result;}// 判断对象是否相同(比较方式)@Overridepublic boolean equals(Object obj) {// this代表当前对象，obj代表传入的对象// true:已存在 false:未存在，直接添加if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;SetText other = (SetText) obj;// 重写if (other.getSname() == this.getSname())return true;return false;}public static void main(String[] args) {// set集合特点：1.无序；2.唯一；// 1.无序Set<SetText> set = new HashSet<SetText>();// HashSet底层结构：(HashMap)// 默认的hashcode是当前对象的内存地址经过运算的值。// 使用 new 对象地址都不同(地址：是对变量或对象存储的路径的描述)// 2.去重原理：先调用hashcode方法比较，再调用equals方法比较// ①如果hashcode不同，则直接放入// ②如果hashcode相同，则通过equals方法判断// 3.遍历方式// 添加数据：set.add(new SetText(11, "张三"));set.add(new SetText(7, "李四"));set.add(new SetText(71, "王老五"));set.add(new SetText(8, "唯一"));set.add(new SetText(44, "老王"));set.add(new SetText(24, "老王"));set.add(new SetText(44, "老王"));// ①迭代器遍历：// 实例化迭代器Iterator<SetText> it = set.iterator();while (it.hasNext()) {System.out.println(it.next());}// (没重写)遍历结果：// SetText [sage=8, sname=唯一]// SetText [sage=44, sname=老王]// SetText [sage=11, sname=张三]// SetText [sage=71, sname=王老五]// SetText [sage=7, sname=李四]// SetText [sage=24, sname=老王]// 我们可以清楚看到44岁的老王被去掉了一个,因为它在hashcode方法中就已经被识别出是相同的，因此直接就去掉了// 那么假设我们要比较名字呢？我们可以修改hashcode方法和equals方法(例如：上面)重写后：// SetText [sage=7, sname=李四]// SetText [sage=11, sname=张三]// SetText [sage=44, sname=老王]// SetText [sage=8, sname=唯一]// SetText [sage=71, sname=王老五]// 如果还要按照其它条件可以自主修改:hashcode方法和equals方法// ②迭代器遍历：Iterator<SetText> ita = set.iterator();while (ita.hasNext()) {System.out.println(ita.next());}// ③foreach遍历set.forEach(System.out::println);}}

②ThreeSet：1.有序；2.底层结构（二叉树）

package com.set.test;import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;/*** TreeSet集合测试类* * @author Administrator**/
public class TreeSetText implements Comparable<TreeSetText> {private int tid;// 编号private String tname;// 名字public TreeSetText() {}public TreeSetText(int tid, String tname) {super();this.tid = tid;this.tname = tname;}@Overridepublic String toString() {return "TreeSetText [tid=" + tid + ", tname=" + tname + "]";}public int getTid() {return tid;}public void setTid(int tid) {this.tid = tid;}public String getTname() {return tname;}public void setTname(String tname) {this.tname = tname;}public static void main(String[] args) {// TreeSet特点：1.有序(插入数据顺序无序)；2.底层结构：二叉树。// 按照：升序、降序来排序。Set<String> set = new TreeSet<String>();// 添加数据set.add("zs");set.add("ls");set.add("ww");// 遍历set.forEach(System.out::println);// 结果：// ls// ww// zs// 这里我们看到就会疑惑，为什么我们在添加数据最后打印的时候，顺序不一样，不是特点是有序的吗？// 答：这里的有序是指a~z的排序方式，而并非添加顺序排序// 排序：1.自然排序； 2.选择器排序// 我们添加对象试试// Comparable:第一种：自然比较接口TreeSet<TreeSetText> ts = new TreeSet<TreeSetText>();ts.add(new TreeSetText(1, "老王"));ts.add(new TreeSetText(4, "老李"));ts.add(new TreeSetText(3, "老五"));ts.add(new TreeSetText(2, "老新"));// 遍历ts.forEach(System.out::println);// 如果我们没有实现Comparable接口，那么就会报错TreeSetText treeSetText = new TreeSetText();// 第二种TreeSet<TreeSetText> ts2 = new TreeSet<TreeSetText>(treeSetText.new NameComparator());ts2.add(new TreeSetText(1, "lw"));ts2.add(new TreeSetText(4, "ak"));ts2.add(new TreeSetText(3, "yy"));ts2.add(new TreeSetText(2, "bc"));// 遍历ts2.forEach(System.out::println);}@Overridepublic int compareTo(TreeSetText o) {// 比较者大于被比较着 返回1// 比较者等于被比较着 返回0// 比较者小于被比较着 返回-1// return this.getTid()-o.getTid();//升序return -(this.getTid() - o.getTid());// 降序}/*** 内部类* * @author Administrator**/class NameComparator implements Comparator<TreeSetText> {@Overridepublic int compare(TreeSetText o1, TreeSetText o2) {return o1.getTname().hashCode() - o2.getTname().hashCode();}}}

五、Map集合详解

①HashMap集合：

package com.map.test;import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;/*** Map集合测试* * @author Administrator**/
public class MapTest {public static void main(String[] args) {// Map特点：1.无序; 2.值不唯一; 3.键值对的形式存储数据;// 一个键对应一个值,键不能重复，值可以。// Map集合添加数据的方法：put();如下：// 其中<>也就是泛型，可以定义任意的数据类型,称为优化集合，提高代码健壮性Map<String, Object> map = new HashMap<String, Object>();map.put("test", "张三");map.put("list", new ArrayList<String>().add("无中生有"));map.put("set", new HashSet<String>().add("老五"));map.put("object", new Object[] { "张三", "李四" });// Map集合遍历方式：1.遍历键keys; 2.遍历值values; 3.遍历值和键;// 1.Set<String> keys = map.keySet();for (String string : keys) {System.out.println(string);}// 2.Collection<Object> values = map.values();for (Object object : values) {System.out.println(object);}// 3.Set<Entry<String, Object>> entrySet = map.entrySet();for (Entry<String, Object> entry : entrySet) {System.out.println("键：" + entry.getKey() + "--值：" + entry.getValue());}}
}

②TreeMap集合：

package com.map.test;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;/*** ThreeMap测试类* * @author Administrator**/
public class TreeMapTest {public static void main(String[] args) {// 1.ThreeMap特点：①以键排序; ②以值排序;(默认按键升序排序)Map<String, Object> map = new TreeMap<String, Object>();// 升序// Map<String,Object> map = new// TreeMap<String,Object>(Comparator.reverseOrder());//降序// ①以键排序：map.put("zs", 100);map.put("ls", 200);map.put("ww", 150);map.put("object", 50);// 遍历Set<Entry<String, Object>> entrySet = map.entrySet();// 升序for (Entry<String, Object> entry : entrySet) {System.out.println("键：" + entry.getKey() + "--值：" + entry.getValue());}// 结果：// 键：list--值：true// 键：object--值：[Ljava.lang.Object;@7852e922// 键：set--值：true// 键：test--值：张三// 我们发现键是按照：a~z排序(升序)// Hashtable:线程安全// HashMap:线程不安全// ②以值排序：// 第一步：将键值对形式转换成list集合ArrayList<Entry<String, Object>> list = new ArrayList<Entry<String, Object>>(entrySet);// Collections// 面试题：Collections和Collection的区别// Collection:集合顶层接口// Collections:集合框架中的帮助类// 第二步：调用Collections.sort方法：按以下操作Collections.sort(list, new Comparator<Entry<String, Object>>() {@Overridepublic int compare(Entry<String, Object> a, Entry<String, Object> b) {return -(a.getValue().hashCode() - b.getValue().hashCode());}});// 重写里面的compare方法进行value值的排序// 注意：我们遍历的是list集合list.forEach(System.out::println);// 2.Arrays：工具类，提供了一组静态方法操作数组// Arrays.asList():括号里内容为：基本数据类型数组,将一个字符数组转换成集合String trr = "1,32,5,45,64,5,6";String[] split = trr.split(",");List<String> asList = Arrays.asList(split);// 遍历asList.forEach(System.out::println);// Arrays.toString():将数组转换成字符串String string = Arrays.toString(split);System.out.println(string);}
}

六、小结部分

①集合框架+List集合：

②Set集合：

③Map集合：

J2EE_01快速入门集合框架相关推荐

【快速入门ORM框架之Dapper】大牛勿进系列
[快速入门ORM框架之Dapper]大牛勿进系列原文:[快速入门ORM框架之Dapper]大牛勿进系列前言:dapper是什么?Dapper是.NET下一个micro的ORM,它和Entity F ...
phpyii框架倒叙_快速入门php框架(Lumen thinkphp Yii)
打算从三个比较普遍常用的框架带领那些初入门的小伙伴(老鸟勿喷)快速上手一个框架,期间会分享一些自己的编码习惯,和代码思路,这三个框架分别是thinkphp(简单的轻量级国产框架).Lumen(为速度而 ...
HTML_03 快速入门表格框架
目录一.认识表格(由行和列组成) 概念:按所需的内容项目画成各自,分别填写文字或数字等书面材料,便于统计查看. 1.表格标签: 表格标题标签作用:自动加粗居中行(表格行) 列(单元 ...
【完结】12大深度学习开源框架(caffe,tf,pytorch,mxnet等)快速入门项目
这是一篇总结文,给大家来捋清楚12大深度学习开源框架的快速入门,这是有三AI的GitHub项目,欢迎大家star/fork. https://github.com/longpeng2008/yousa ...
【完结】给新手的12大深度学习开源框架快速入门项目
文/编辑 | 言有三这是一篇总结文,给大家来捋清楚12大深度学习开源框架的快速入门,这是有三AI的GitHub项目,欢迎大家star/fork. https://github.com/longpen ...
十九、Beego框架快速入门
Beego框架快速入门 1.框架了解 go语言的web框架:beego,gin,echo等等,那为什么我们选择beego呢? 第一,beego是中国人开发的,开发文档比较详细,beego官网网址: h ...
Verilog语言快速入门
Verilog语言快速入门基本框架 module<模块名> (端口列表) 端口说明 input output inout参数定义数据类型定义连续赋值语句 assign过程块 initi ...
一天入门Java快速入门
前言我写此文主要参考: Java:Java快速入门-幸福框架目的是: 快速入门啦.由于工作的需求-Android安全. 计划: Java一天入门我从未学过Java.我会找出Java与C++等语 ...
开源即时通讯IM框架MobileIMSDK的Uniapp端开发快速入门
► 相关链接: ① MobileIMSDK-Uniapp端的详细介绍 ② MobileIMSDK-Uniapp端的开发手册new(* 精编PDF版) 一.理论知识准备您需要对Uniapp和Vue开发 ...

J2EE_01快速入门集合框架

一、UML(统一建模语言)集合框架类图

二、Java集合框架概述

三、List集合使用

四、Set集合的使用

五、Map集合详解

①HashMap集合：

②TreeMap集合：

六、小结部分

①集合框架+List集合：

②Set集合：

③Map集合：

J2EE_01快速入门集合框架相关推荐

最新文章

热门文章

J2EE_01快速入门 集合框架

一、UML(统一建模语言)集合框架类图

二、Java集合框架概述

三、List集合使用

四、Set集合的使用

五、Map集合详解

①HashMap集合：

②TreeMap集合：

六、小结部分

①集合框架+List集合：

②Set集合：

③Map集合：

J2EE_01快速入门 集合框架相关推荐

最新文章

热门文章

J2EE_01快速入门集合框架

J2EE_01快速入门集合框架相关推荐