java集合

集合

什么是集合：

    概念： 集合是一个容器 用来存储数据

    容器 ：变量 字符串缓冲区 数组

集合的特点：

    长度可变 ， 存储不同的类型数据，只能存储引用类型，有的容器有下标 有的容器没有下标

    集合的容器不同，存储数据采用的算法(数据结构)不同，导致特点也不同

集合框架分两种：

    单列集合 ：一个数据一个一个数据储存

    双列集合一对一对数据储存

集合选型规则

在开发中选择什么集合实现类主要取决于业务操作特点然后根据集合实现类特性进行选择

分析：

先判断存储的类型（一组对象或一组键值对）

一组对象：Collection允许重复：List增删多：LinkedList[底层维护了一个双向链表]改查多：ArrayList [底层维护 Object类型的可变数组]不允许重复：Set无序：HashSet [底层是HashMap 维护了一个哈希表即（数组 +链表+红黑树）]排序：TreeSet插入和取出顺序一致：LinkedHashSet 维护数组 + 双向链表

一对键值对[双列] ：Map键无序：HashMap[底层是哈希表 jdk7：数组+ 链表 jdk8中是数组+链表 +红黑树]键排序：TreeMap键插入和取出顺序一致：LinkedHashMap读取文件： Properties

单列集合

Collection 继承了iterable 接口

Collection接口的特点：

collection的实现子类可以存放多个元素，每个元素都可以说Object;
有些Collection的实现类，可以存放重复元素，有些不可以
有些Collection的实现类，有些是有序的(List),有些是无序的(Set)；
Collection接口没有直接的实现子类，是通过他的子接口Set 和List来实现的

Collection 接口有两个重要的子接口：

List Set 这两个实现的子类都是单列集合

    List ：有序可重复

    Set ：无序不可重复

list的重要子类：

** Vector ArrayList LinkedList**

Set的重要子类

** TreeSet HashSet**

Collection 接口的常用方法：

    用ArrayList来演示Collection方法

AarrayList底层算法是数组算法

add：添加单个元素ArrayList list = new ArrayList(); list.add("jack"); list.add(10); list.add(true); System.out.println(list);// [jack, 10, true] 输出效果
remove: 删除指定元素 list.remove(0);//删除第一个元素 list.remove("jack");//指定删除某个元素
contains ：查找元素是否存在 System.out.println(list.contains("jack"));//有就返回true 没有false
size ：返回元素个数 System.out.println(list.size()); //有几个元素就返回几
isEmpty :判断是否为空 System.out.println(list.isEmpty());//空的就返回 ture 有元素就返回false
clear：清空list.clear();//清空
addAll：添加多个元素 ArrayList list1 = new ArrayList();//又创建个对象 list1.add("qwe"); list1.add("qwe"); list.addAll(list1);//把new出来的list1放进了list
comtainsAll ：查找多个元素是否都存在 System.out.println(list.containsAll(list1));//T
removeAll ：删除多个元素 list.removeAll(list1);// 把new出来的list1里面的元素给删除了
toArray() : 将集合转为数组 list.add("123"); list.add(true); Object[] objects = list.toArray(); for (int i = 0; i < objects.length; i++) { System.out.println(objects[i]);//123 true }

Collections工具类

** Collections 基本介绍**Collections 是一个操作 Set List Map 等集合的工具类

** Collections 中提供了一系列静态的方法对集合元素进行排序，查询和修改等操作**

排序操作： static 方法
reverse(List) : 反转 List 中元素的顺序
shuffle(List)：对List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素进行升序排序
sort(List,Comparator)：根据指定的 Comparato 产生的顺序对 List 集合元素进行排序
swap(List, int i ,int j)：将指定的 List 集合中的 i 处元素和 j 处元素进行交换
sort(List,Comparator)；例改为按照字符串的长度来排序

Collections .sort(集合引用名， new Comparator(){

        @Override
        public int compare(Object o1,Object o2){
        // 可以加入效验代码  if(01 instanceof String) ---->不成立就返回0
         return  ((String)o1).length() - ((String)02).length();
        }
});查找，替换 操作

Object max (集合): 根据元素的自然顺序，返回给定集合中的最大元素

Object max (集合，Comparator): 根据Comparator 指定的顺序，返回给定集合中的最大元素

Object min(集合); 根据元素的自然顺序，返回给定集合中的最小元素

Object min(集合,Comparator): 根据Comparator 指定的顺序，返回给定集合中的最小元素

int frequency(集合,Object) : 返回指定集合中指定元素的出现次数

void copy(List dest, List src): 将src 中的内容复制到 dest 中

{为了完成的拷贝，需先给dest 赋值，大小和src.size()一样，否则抛出异常}

boolean replace All(List list, Object old Val , Object new Val ): 使用新的值替换掉 list 对象的旧值（value）

Collection接口遍历元素方式：

使用Iterator （迭代器）1. Iterator对象称为迭代器，主要用于遍历Collection 集合中的元素2. 所有实现类Collection接口的集合类都有一和iterator()方法用以返回一个实现iterator接口的对象，即可以返回一个迭代器3. 如果希望再次遍历需要重制我们的迭代器重制迭代器的方法：**iterator iterator = col.iterator();**4. iterator仅用于遍历集合，iterator本身并不存放对象；Iterator iterator = list.iterator();// 循环输出while (iterator.hasNext()){ Object obj = iterator.next(); System.out.print(obj+",");}//hello0,张三,hello1,hello2,hello3,hello5,三国,hello7,hello8,hello9,hello10,hello11,hello12,
使用增强for循环 增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator迭代器，本质一样，只能用于遍历集合或数组 1. 增强for循环底层源码仍是调用迭代器2. for (Object o : list) { System.out.print(list+",");}//hello0,张三,hello1,hello2,hello3,hello5,三国,hello7,hello8,hello9,hello10,hello11,hello12,
使用普通的for循环1. for (int i = 0; i < list.size(); i++) { System.out.print(list.get(i)+",");}//hello0,张三,hello1,hello2,hello3,hello5,三国,hello7,hello8,hello9,hello10,hello11,hello12,
列表迭代器ListIterator it = list.listIterayor();while(lt.hasNext()){ Object obj = it.next(); System.out.println(obj);}
转数组遍历输出

 Object[] objects = list.toArray();
 for (int i = 0; i < objects.length; i++) {
            System.out.print(objects[i]); 
        }//hello0,高寒星,hello1,hello2,hello3,hello5,三国,hello7,hello8,hello9,hello10,hello11,hello12

Iterator接口的方法：

hasNext() next() remov()

小提示：

在调用itreator.next()方法之前必须要调用iterator.has.Next()进行检测。

不调用就会下一跳记录就会无效，直接调用itreator.next()会抛出No.SuchElementException异常

 Collection col = new ArrayList();
        col.add(new Book("三国演义","罗贯中",100));
        col.add(new Book("小李飞刀","古龙",5.1));
        col.add(new Book("红楼梦","曹雪芹",34.1));
        //现在遍历col集合
        //先得到col 对应的迭代器
        Iterator iterator = col.iterator();
        while (iterator.hasNext()){//判断下面是否还有数据
            //返回下一个元素 类型是 Object
            Object next = iterator.next();
            System.out.println(next);
        }//当退出while循环后 这是iterator迭代器指向了最后的元素 
        //再进行iterator.next()会报异常
        //如果希望再次遍历 需要重制我们的迭代器
//        iterator = col.iterator();
            /*输出结果
Book{name='三国演义', author='罗贯中', price=100.0}
Book{name='小李飞刀', author='古龙', price=5.1}
Book{name='红楼梦', author='曹雪芹', price=34.1} */
            class  Book{// 这是book 类  
                    private String name;
                    private String author;
                    private double price ;

重制迭代器的方法：

iterator iterator = col.iterator();

增强for循环的基本语法

for(元素类型元素名：集合名或数组名){// 分号右边只能是数组或集合

访问元素

}

增强for循环只能用于遍历元素

底层原理就是调用迭代器

        for (Object book: col) {
            System.out.println(book);
        }
        //输出效果 效果和iterator迭代器 一样
        // Book{name='三国演义', author='罗贯中', price=100.0}
        //Book{name='小李飞刀', author='古龙', price=5.1}
        //Book{name='红楼梦', author='曹雪芹', price=34.1

List接口常用方法

List接口是Collection接口的子接口
List集合类种元素有序（即添加顺序和取出顺序一致），且可重复
List集合中的每个元素都有其对应的顺序索引，且支持索引
List容器中的元素都对应一个整数型的序号记载其容器中的位置，可以根据序号存取容器中的元素
JDK API 中 list接口的实现类：AbstractList， AbstractSequentialList， ArrayList， AttributeList， CopyOnWriteArrayList， LinkedList， RoleList， RoleUnresolvedList， Stack， Vector

index 插入

 List list = new ArrayList();
        list.add("张三");
        list.add("李四");
        //在int index = 1 的位置位置上插入一个对象
        list.add(1,"111");
    System.out.println(list);//[张三, 111, 李四]
  // 也可以插入多个对象  add方法 换成 addAll
List list2 = new ArrayList();
    list2.add("tom");
    list2.add("jack");
    list.addAll(1,list2);
    System.out.println(list);//[张三, tom, jack, 111, 李四]

Object get(int index): 获取指定index位置的元素

   System.out.println(list.get(3));// 111

int indexof(Object obj) :返回obj在集合中首次出现的位置

    System.out.println(list.indexOf("tom"));//1

int lastindexof(Object obj): 返回obj 在当前集合最后出现的位置

        list.add("tom");// 在当前集合中的最后又添加了一个tom
    System.out.println(list);//集合中的元素：[张三, tom, jack, 王五, 李四，tom]
    System.out.println(list.lastIndexOf("tom"));//5

Object remove(int index):移除指定index位置的元素并返回此元素

    Object remove = list.remove(0);
    System.out.println(remove);//张三
    System.out.println(list);//[tom, jack, 王五, 李四, tom]

Object set(int index ,Object ele): 将指定位置的元素设置为ele 相当于替换

    System.out.println(list);//[tom, jack, 王五, 李四, tom]
    list.set(2,"玛丽")
    System.out.println(list);//[tom, jack, 玛丽, 李四, tom]

List subList(int fromIndex , int toIndex):返回从fromIndex 到 toIndex位置的子集合

// 注意返回的子集合 是从0下标开始 2下标结束   
List list000 = list.subList(0, 3);
    System.out.println(list000);//[tom, jack, 玛丽]

ArrayList 注意事项

ArrayList 可以加入空值 null 并且可以加入多个
ArrayList 是由数组来实现数据存储的
ArrayList 基本等同于Vector，除了ArrayList是线程不安全(但执行效率高) 在多线程情况下不建议使用

ArrayList底层结构

ArrayList中维护了一个Object类型的数组elementData在ArrayLsit中存放的元素最终都存放在elementData数组中transient Object[] elementData ;//transient 表示瞬间短暂的，表示该属性不会被序列话
当创建ArrayList对象时，如果使用的时无参构造器，则初始elementData的容量位0，第一次添加则扩容数组大小为10 ，如需要再次扩容则扩容到当前数组大小的1.5倍
如果使用的时指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容到当前数组大小的1.5倍

Vector 底层结构

Vector 时List接口的实现子类
Vector 底层也是一个对象数组，protected Object[] elementData;
Vector 时线程同步的即线程安全，Vector类的操作方法带有synchronized //代表线程同步安全
在开发中需要线程同步安全时，考虑使用Vector

Vector 底层结构和ArrayList底层结构的比较

底层结构版本线程安全(同步)效率扩容倍数ArrayList可变数组jdk1.2不安全效率高如果有参数构造扩容按照当前容量的1.5倍如果是无参第一次容量为10 第二次按照当前容量的1.5倍扩容Vector可变数组jdk1.0安全，效率不高如果是无参默认容量大小为10 满后就按照当前容量大小的2倍扩容如果指定大小满后则每次直接按2倍扩荣

LinkedList 底层结构

node 代表节点

LinkedList 底层实现类双向链表和双端队列特点
可以添加任意元素（元素可以重复），包括null
线层不安全没有实现同步 尽量在单线程中使用LinkedList 的底层操作机制
LinkedList底层维护了一个双向链表
LinkedList中维护了两个属性first和last分别指向首节点和尾节点
每个节点（Node对象），里面有维护了prev，next，item，三个属性，其中通过prev指向前一个，同过next指向后一个字点。最终实现双向链表
所以LinkedList的元素的添加和删除，不是通过数组来完成的，相对来说效率较高

ArratList 和LinkedList 的比较

底层结构增删的效率改查的效率ArrayList可变数组较低数组扩容较高LinkedList双向链表较高通过链表追加较低
如何选择ArrayList 和LinkedList ：

如果我们改查比较多使用ArrayList
如果我们增删比较多使用LinkedList
一般来说在程序中 80%--90% 都是查询，因此大部分情况下都会选择ArrayList
在一般的项目中根据业务灵活选择，也可能这样，一个模块使用的是ArrayList（做改查），另一个模块中是LenkedList（做增删）

Set接口和常用方法

Set接口基本介绍

无序（添加和取出顺序不一致）没有索引(下标)
不允许重复元素，最多包含一个null
JDK API中Set接口的实现类有：AbstractSet， ConcurrentHashMap.KeySetView， ConcurrentSkipListSet， CopyOnWriteArraySet， EnumSet， HashSet， JobStateReasons， LinkedHashSet， TreeSet

Set接口的常用方法和List接口一样 Set接口也是Collection的子接口，因此，常用方法和Collection接口一样

Set接口的遍历方式同Collection的遍历方式一样，因此Set接口是Collection的接口的子接口

可以使用迭代器
增强for循环
不能使用索引的方式来获取

Set 接口实现类 HashSet 的全面说明

HashSet 实现了 Set接口
HashSet 实际上是hashMap ，底层是hashmap// 这是HashSet 的底层代码public HashSet() { map = new HashMap<>(); }
可以存放 null 但只能存放一个
HashSet不保证元素是有序的，取决于hash后再确定索引的结果（添加的顺序和取出的顺序不一致，存入的顺序不一致但存放的位置已经固定好了取出的顺序不会改变）
不能有重复的元素/对象

HashSet底层集中说明

HashSet 底层是HashMap , HashMap 底层是(数组 +链表+ 红黑树)

结论：

HashSet 底层是HashMap 第一次添加时 table数组扩容到16，临界值(threshold)是16*加载因子(loadFactor)是0.75 = 12
如果table数组使用到临界值12，就会扩容到162 = 32 ，新的临界值就是320.75 = 24,依此类推
添加一个元素时，先得到hash值会转成 ->索引值
找到存储数据表table 看这个索引位置是否已经存放的有元素
如果没有直接加入
如果有调用equals比较如果相同就放弃添加如果不相同则添加到最后
在Java8中如果一条链表的元素个数到达TREEIFY _THRESHOLD(默认为 8)并且table的大小>=MIN_TREEILFY_CAPACITY(默认64)；就会进行树化（红黑树）

Set接口的实现类 LinkedHashSet的全面说明

LinkedHashSet 的全面说明：

LinkedHashSet 是HashSet的子类
linkedHashSet 底层是一个LinkedHashMap，底层维护了一个数组 + 双向链表
LinkedHashSet 根据元素的hashCode 值来决定元素的存储位置，同时使用链表维护元素的次序这使得元素看起来是插入顺序保存的；
LinkedHashSet 不允许有重复元素添加
LinkedHashSet中维护了一个hash表和双向链表（LinkedHashSet 有head和tail）
每一个节点有before和after属性，这样可以形成双向链表
在添加一个元素时，先求hash值，在求索引，确定该元素在table数组的位置，然后将该元素加入到双向链表中(如果已经存在，不添加[原则和hashset一样])//示意代码tail.next = newElementnewElement.pre = tail;tail = newElement;//这样的话我们遍历LinkedHashSet 也能确保插入顺序和遍历顺序一致

Set 接口实现类TreeSet ：

Tree的特点：

存储的数据会按照自然顺序或字典顺序进行排序

底层数据结构：二叉树算法

去重机制如果你传入了一个Compareable匿名对象就是用实现的compare方法去重如果方法返回0 就认为是相同元素就不添加如果没有传入Compareable匿名对象则已你添加的对象实现的Compareable 接口的compareTo 去重

双列集合

Map 接口的实现子类是双列集合一对一对数据储存存放的Key----Value;

Map 的重要实现类

HashMap Hashtable TreeMap

Hashtable 的重要子类：Properties

HashMap 的重要子类： LinkedHashMap

双列集合小案例 :

HashMap hm = new HashMap();
    hm.put("NO1","北京")；//k == NO1 , V == 北京
    hm.put("NO2","深圳");
    hm.put("NO1","广东")；//只会输出 NO2= 深圳 NO1= 广东

Map接口的实现类的特点[很实用]

注意这里记得是JKD8 的Map接口特点

Map与Collection并列存在用于保存具有映像关系的数据 key----Value(双列元素)
Map中的key 和value 可以是任何引用类型的数据，会封装在HashMap$Node 对象中
Map 中的 key 不允许重复原因和HashSet 一样当有相同的key 就等价替换
map中的value 可以重复原因和HashSet 一样
Map 的key 可以为null 但只能有一个 value 也可以为null 可以有多个
常用String类作为Map 的key
key和value之间存在单向一对一关系即通过指定的key 能找到对应的value
一对 k----v是放在HashMap$Node中的又因为Node实现了Entry接口

Map接口的常用方法：使用的是HashMap

public class Map_ {
    public static void main(String[] args) {
        Map map = new HashMap();
//put 添加元素
        map.put("邓超",new Book("",100));//添加成功
        map.put("邓超","孙俪");//替换掉 map.put("邓超",new Book("",100));
        map.put("王宝强","马蓉");//添加成功
        map.put("宋喆","马蓉");//添加成功
        map.put("刘令博",null);//添加成功
        map.put(null,"刘亦菲");//添加成功
        map.put("鹿晗","关晓彤");//添加成功
        System.out.println(map);
        //{邓超=孙俪, 宋喆=马蓉, 刘令博=null, null=刘亦菲, 王宝强=马蓉, 鹿晗=关晓彤}
//remove :根据键删除映射关系
        map.remove(null);
        System.out.println(map);
        //{邓超=孙俪, 宋喆=马蓉, 刘令博=null, 王宝强=马蓉, 鹿晗=关晓彤}

//get :根据键获得值
        Object val = map.get("鹿晗");
        System.out.println(val);//关晓彤

 //size() 获取元素个数
        System.out.println("k---v ="+map.size());//k---v =5
//isEmpty ：判断个数是否为0
        System.out.println(map.isEmpty());//false 因为不为空
//clear :清空 k----v
 // map.clear();
        System.out.println(map);//{}

//containsKey : 查找键是否存在
        System.out.println(map.containsKey("鹿晗"));//true
    }
}
class  Book{
    private String name;
    private int num;

    public Book(String name, int num) {
        this.name = name;
        this.num = num;
    }
}

Map的遍历方法使用的是HashMap

接上面代码

//第一组 先取出 所有的key 通过key 取出对应的key
        Set keySet = map.keySet();
//1. 增强for循环
        for (Object key : keySet) {
            System.out.print(map.get(key)+" ");
        }//孙俪 马蓉 null 马蓉 关晓彤
        System.out.println("\n\n");
//2. 迭代器
        Iterator iterator = keySet.iterator();
        while (iterator.hasNext()){
            Object key = iterator.next();
            System.out.print(key+" "+map.get(key));
        }//邓超 孙俪宋喆 马蓉刘令博 null王宝强 马蓉鹿晗 关晓彤

//第二组 ： 把所有的values 取出
        Collection values = map.values();
// 可以使用 单列集合中的Collection接口遍历元素方式：
// 不能使用普通for循环

//第三组 ：通过EntrySet 来获取 K----V
        Set entrySet= map.entrySet();//EnrySet<Map.Entry<K,V>>
 //1. 增强for
        for (Object entry : entrySet) {
            //将entry 转成 map.Entry
            Map.Entry m = (Map.Entry)entry;
            System.out.println(m.getKey()+" "+m.getValue());
        }//宋喆 马蓉
        //刘令博 null    
        //王宝强 马蓉
        //鹿晗 关晓彤

//2. 迭代器
        System.out.println("-------------");
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()) {
            Object next = iterator1.next();
          //  System.out.println(next.getClass());
            //向上转型 HashMap$Node ->实现-->Map.Entry然后使用(getKey,getValue)

            //向下转型 直接转成Map.Entry
            Map.Entry m = (Map.Entry)next;
            System.out.println(m.getKey()+" "+m.getValue());
        }/*邓超 孙俪
            宋喆 马蓉
            刘令博 null
            王宝强 马蓉
            鹿晗 关晓彤
         */

Map接口实现类 HashMap 小结

HashMap 是Map接口使用频率最高的实现类
HashMap是以 Key-----Value 的方式来存储数据（HashMap$Node类型）
Key 不能重复但是值可以重复允许使用null键和null值
如果添加相同的key 则会覆盖调原来的key--value 等同于修改（key不会替换 value会替换）
与HashSet一样不保证输出的映射的顺序，因为地层是以hash表的方式进行存储 (jDK8 的hashMap 底层数组+链表 +红黑树)
HashMap没有实现同步线程是不安全的方法没有做同步互斥的操作没有synchronized
(k--v)是一个Node实现了Map.Entry<K,V> 查看HashMap的源码可以看到
jdk7.0的hashmap底层实现[数组 +链表] jdk8.0 hashmap底层是[数组+链表+红黑树]
扩容机制和HashSet 一致

HashMap底层机制

当创象时将加载因子（loadfactor）初始化为0.75
当添加k--v时通过key的哈希码值得到table的索引然后判断该索引处是否有元素没有就直接添加如果有判断该元素的key是否和准备进入的key是否相等如果相等就替换value 不相等余姚判断是树结构还是链表结构做出相应处理如果添加时发现容量不够则需要扩容
第一次添加则需要扩容table容量到16 临界值为（threshold）12
以后再扩容则需要扩容table容量为原来的2倍临界值为原来的2倍依此类推
在java8中如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认为8) 并且table的大小>=MIN_TREEIFY_CAPACITY(默认64) 就会进行树化

Map 接口的实现类 HashTable

HashTable的基本介绍

存放的元素是键值对：k---v
hashtable的键和值不能为null 否则会抛出NullPointerException空指针异常
hashtable使用方法基本和hashmap一样
hashtable是线程安全的 hashmap是线程不安全的

hashtable的底层

底层有数组HashTable$Entry[] 初始大小为11
临界值为 8 （ threshold） = 11 *0.75
扩容：原本的初始值 ×2 加1

HashTable 和 HashMap 的对比

版本线程安全（同步）效率允许null键null值HashMap1.2不安全高可以HashTable1.0安全较低不可以

Map 的接口实现类Properties

Properties的基本介绍

Properties类继承自Hashtable类并且实现了Map接口也是使用一种键值对的形式来保存数据
他的使用特点和HashTable类似
Properties还可以用于冲xxx.properties文件中加载数据到Properties类对象并进行读取和修改（说明：工作后xxx.properties文件通常做为配置文件这个知识点在io流举例）

 public static void main(String[] args) {
 //Properties 继承 Hashtable
//可以通过k---v 存放数据   k--v键值对不能为null
 // 存入的元素是无序的
        Properties properties = new Properties();
        properties.put("jack",18);
        properties.put(123,"tom");
//   properties.put(null,18);//抛出NullPointerException 空指针异常
// properties.put("tom",null);//抛出NullPointerException  空指针异常
        properties.put("jack",12);//有相同的键 值会替换

        System.out.println(properties);//{jack=12,123=tom}

//通过key键    获取对应的value值
        System.out.println(properties.get("jack"));//12

//删除   通过key键    删除对应的value值
       properties.remove(123);
        System.out.println(properties);//{jack=12}

//修改  通过相同的key 替换value值
        properties.put("jack","老王");
        System.out.println(properties);//{jack=老王}

//查找
        System.out.println(properties.get("jack"));//老王
        System.out.println(properties.getProperty("jack"));//老王
    }
}

Map接口的实现类 TerrMap

     //使用默认的构造器 顺序是无序的
      //  TreeMap treeMap = new TreeMap();

        //要求 按照传入的k(String)的大小进行排序
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
              //  k(String)的大小进行排序
              //  return ((String)o1).compareTo((String)o2 );
                //按照字符串的长度比较
                return ((String)o1).length() -((String)o2).length();
            }
        });
                treeMap.put("jack","jack");
                treeMap.put("tom","汤姆");
                treeMap.put("smith","史密斯");

       // System.out.println(treeMap);//{jack=jack, smith=史密斯, tom=汤姆}
        //字符串长度 比较
        System.out.println(treeMap);//{tom=汤姆, jack=jack, smith=史密斯}
    }
}

标签： java

本文转载自: https://blog.csdn.net/weixin_67585058/article/details/126534221
版权归原作者 凡夫_俗人 所有，如有侵权，请联系我们删除。

集合