深入浅出的分析 Set集合

开发 前端
关于 Set 接口,在实际开发中,其实很少用到,但是如果你出去面试,它可能依然是一个绕不开的话题。

 01. 摘要

“关于 Set 接口,在实际开发中,其实很少用到,但是如果你出去面试,它可能依然是一个绕不开的话题。

[[282307]]

言归正传,废话咱们也不多说了,相信使用过 Set 集合类的朋友都知道,Set集合的特点主要有:元素不重复、存储无序的特点。

啥意思呢?你可以理解为,向一个瓶子里面扔东西,这些东西没有记号是第几个放进去的,但是有一点就是这个瓶子里面不会有重样的东西。

细细思考,你会发现, Set 集合的这些特性正处于 List 集合和 Map 集合之间,为什么这么说呢?之前的集合文章中,咱们了解到,List 集合的特点就是存取有序,本质是一个有序数组,每个元素依次按照顺序存储;Map 集合主要用于存放键值对,虽然底层也是用数组存放,但是元素在数组中的下标是通过哈希算法计算出来的,数组下标无序。

而 Set 集合,在元素存储方面,注重独立无二的特性,如果某个元素在集合中已经存在,不会存储重复的元素,同时,集合存储的是元素,不像 Map 集合那样存储的是键值对。

具体的分析,咱们慢慢道来,打开 Set 集合,主要实现类有 HashSet、LinkedHashSet 、TreeSet 、EnumSet( RegularEnumSet、JumboEnumSet )等等,总结 Set 接口实现类,图如下:

 

 

 

 

由图中的继承关系,可以知道,Set 接口主要实现类有 AbstractSet、HashSet、LinkedHashSet 、TreeSet 、EnumSet( RegularEnumSet、JumboEnumSet ),其中 AbstractSet、EnumSet 属于抽象类,EnumSet 是在 jdk1.5 中新增的,不同的是 EnumSet 集合元素必须是枚举类型。

  • HashSet 是一个输入输出无序的集合,集合中的元素基于 HashMap 的 key 实现,元素不可重复;
  • LinkedHashSet 是一个输入输出有序的集合,集合中的元素基于 LinkedHashMap 的 key 实现,元素也不可重复;
  • TreeSet 是一个排序的集合,集合中的元素基于 TreeMap 的 key 实现,同样元素不可重复;
  • EnumSet 是一个与枚举类型一起使用的专用 Set 集合,其中 RegularEnumSet 和 JumboEnumSet 不能单独实例化,只能由 EnumSet 来生成,同样元素不可重复;

下面咱们来对各个主要实现类进行一一分析!

02. HashSet

HashSet 是一个输入输出无序的集合,底层基于 HashMap 来实现,HashSet 利用 HashMap 中的key元素来存放元素,这一点我们可以从源码上看出来,阅读源码如下:

 

  1. public class HashSet<E> 
  2.     extends AbstractSet<E> 
  3.     implements Set<E>, Cloneable, java.io.Serializable
  4.      
  5.     // HashMap 变量 
  6.     private transient HashMap<E,Object> map; 
  7.      
  8.     /**HashSet 初始化*/ 
  9.     public HashSet() { 
  10.         //默认实例化一个 HashMap 
  11.         map = new HashMap<>(); 
  12.     } 

add方法

打开HashSet的add()方法,源码如下:

 

  1. public boolean add(E e) { 
  2.     //向 HashMap 中添加元素 
  3.     return map.put(e, PRESENT)==null

其中变量PRESENT,是一个非空对象,源码部分如下:

 

  1. private static final Object PRESENT = new Object(); 

可以分析出,当进行add()的时候,等价于

 

  1. HashMap map = new HashMap<>(); 
  2. map.put(e, new Object());//e 表示要添加的元素 

在之前的集合文章中,咱们了解到 HashMap 在添加元素的时候 ,通过equals()和hashCode()方法来判断传入的key是否相同,如果相同,那么 HashMap 认为添加的是同一个元素,反之,则不是。

从源码分析上可以看出,HashSet 正是使用了 HashMap 的这一特性,实现存储元素下标无序、元素不会重复的特点。

remove方法

HashSet 的删除方法,同样如此,也是基于 HashMap 的底层实现,源码如下:

 

  1. public boolean remove(Object o) { 
  2.     //调用HashMap 的remove方法,移除元素 
  3.     return map.remove(o)==PRESENT; 

查询方法

HashSet 没有像 List、Map 那样提供 get 方法,而是使用迭代器或者 for 循环来遍历元素,方法如下:

 

  1. public static void main(String[] args) { 
  2.     Set<String> hashSet = new HashSet<String>(); 
  3.     System.out.println("HashSet初始容量大小:"+hashSet.size()); 
  4.     hashSet.add("1"); 
  5.     hashSet.add("2"); 
  6.     hashSet.add("3"); 
  7.     hashSet.add("3"); 
  8.     hashSet.add("2"); 
  9.     hashSet.add(null); 
  10.  
  11.     //相同元素会自动覆盖 
  12.     System.out.println("HashSet容量大小:"+hashSet.size()); 
  13.     //迭代器遍历 
  14.     Iterator<String> iterator = hashSet.iterator(); 
  15.     while (iterator.hasNext()){ 
  16.         String str = iterator.next(); 
  17.         System.out.print(str + ","); 
  18.     } 
  19.  
  20.     System.out.println("\n==========="); 
  21.     //增强for循环 
  22.     for (String str : hashSet) { 
  23.         System.out.print(str + ","); 
  24.     } 

输出结果:

 

  1. HashSet初始容量大小:0 
  2. HashSet容量大小:4 
  3. null,1,2,3, 
  4. =========== 
  5. null,1,2,3, 

需要注意的是,HashSet 允许添加为null的元素。

03. LinkedHashSet

LinkedHashSet 是一个输入输出有序的集合,继承自 HashSet,但是底层基于 LinkedHashMap 来实现。

如果你之前了解过 LinkedHashMap,那么你一定知道,它也继承自 HashMap,唯一有区别的是,LinkedHashMap 底层数据结构基于循环链表实现,并且数组指定了头部和尾部,虽然数组的下标存储无序,但是却可以通过数组的头部和尾部,加上循环链表,依次可以查询到元素存储的过程,从而做到输入输出有序的特点。

如果还不了解 LinkedHashMap 的实现过程,可以参阅集合系列中关于 LinkedHashMap 的实现过程文章。

阅读 LinkedHashSet 的源码,类定义如下:

 

  1. public class LinkedHashSet<E> 
  2.     extends HashSet<E> 
  3.     implements Set<E>, Cloneable, java.io.Serializable { 
  4.  
  5.     public LinkedHashSet() { 
  6.         //调用 HashSet 的方法 
  7.         super(16, .75f, true); 
  8.     } 

查询源码,super调用的方法,源码如下:

 

  1. HashSet(int initialCapacity, float loadFactor, boolean dummy) { 
  2.     //初始化一个 LinkedHashMap 
  3.     map = new LinkedHashMap<>(initialCapacity, loadFactor); 

add方法

LinkedHashSet没有重写add方法,而是直接调用HashSet的add()方法,因为map的实现类是LinkedHashMap,所以此处是向LinkedHashMap中添加元素,当进行add()的时候,等价于

 

  1. HashMap map = new LinkedHashMap<>(); 
  2. map.put(e, new Object());//e 表示要添加的元素 

remove方法

LinkedHashSet也没有重写remove方法,而是直接调用HashSet的删除方法,因为LinkedHashMap没有重写remove方法,所以调用的也是HashMap的remove方法,源码如下:

 

  1. public boolean remove(Object o) { 
  2.     //调用HashMap 的remove方法,移除元素 
  3.     return map.remove(o)==PRESENT; 

查询方法

同样的,LinkedHashSet 没有提供 get 方法,使用迭代器或者 for 循环来遍历元素,方法如下:

 

  1. public static void main(String[] args) { 
  2.     Set<String> linkedHashSet = new LinkedHashSet<String>(); 
  3.     System.out.println("linkedHashSet初始容量大小:"+linkedHashSet.size()); 
  4.     linkedHashSet.add("1"); 
  5.     linkedHashSet.add("2"); 
  6.     linkedHashSet.add("3"); 
  7.     linkedHashSet.add("3"); 
  8.     linkedHashSet.add("2"); 
  9.     linkedHashSet.add(null); 
  10.     linkedHashSet.add(null); 
  11.  
  12.     System.out.println("linkedHashSet容量大小:"+linkedHashSet.size()); 
  13.     //迭代器遍历 
  14.     Iterator<String> iterator = linkedHashSet.iterator(); 
  15.     while (iterator.hasNext()){ 
  16.         String str = iterator.next(); 
  17.         System.out.print(str + ","); 
  18.     } 
  19.  
  20.     System.out.println("\n==========="); 
  21.     //增强for循环 
  22.     for (String str : linkedHashSet) { 
  23.         System.out.print(str + ","); 
  24.     } 

输出结果:

 

  1. linkedHashSet初始容量大小:0 
  2. linkedHashSet容量大小:4 
  3. 1,2,3,null
  4. =========== 
  5. 1,2,3,null

可见,LinkedHashSet 与 HashSet 相比,LinkedHashSet 输入输出有序。

04. TreeSet

TreeSet 是一个排序的集合,实现了NavigableSet、SortedSet、Set接口,底层基于 TreeMap 来实现。TreeSet 利用 TreeMap 中的key元素来存放元素,这一点我们也可以从源码上看出来,阅读源码,类定义如下:

 

  1. public class TreeSet<E> extends AbstractSet<E> 
  2. implements NavigableSet<E>, Cloneable, java.io.Serializable { 
  3.      
  4.     //TreeSet 使用NavigableMap接口作为变量 
  5.     private transient NavigableMap<E,Object> m; 
  6.      
  7.     /**对象初始化*/ 
  8.     public TreeSet() { 
  9.         //默认实例化一个 TreeMap 对象 
  10.         this(new TreeMap<E,Object>()); 
  11.     } 
  12.      
  13.     //对象初始化调用的方法 
  14.     TreeSet(NavigableMap<E,Object> m) { 
  15.         this.m = m; 
  16.     } 

new TreeSet<>()对象实例化的时候,表达的意思,可以简化为如下:

 

  1. NavigableMap<E,Object> m = new TreeMap<E,Object>(); 

因为TreeMap实现了NavigableMap接口,所以没啥问题。

 

  1. public class TreeMap<K,V> 
  2.     extends AbstractMap<K,V> 
  3.     implements NavigableMap<K,V>, Cloneable, java.io.Serializable
  4.     ...... 

add方法

打开TreeSet的add()方法,源码如下:

 

  1. public boolean add(E e) { 
  2.     //向 TreeMap 中添加元素 
  3.     return m.put(e, PRESENT)==null

其中变量PRESENT,也是是一个非空对象,源码部分如下:

 

  1. private static final Object PRESENT = new Object(); 

可以分析出,当进行add()的时候,等价于

 

  1. TreeMap map = new TreeMap<>(); 
  2. map.put(e, new Object());//e 表示要添加的元素 

TreeMap 类主要功能在于,给添加的集合元素,按照一个的规则进行了排序,默认以自然顺序进行排序,当然也可以自定义排序,比如测试方法如下:

 

  1. public static void main(String[] args) { 
  2.     Map initMap = new TreeMap(); 
  3.     initMap.put("4""d"); 
  4.     initMap.put("3""c"); 
  5.     initMap.put("1""a"); 
  6.     initMap.put("2""b"); 
  7.     //默认自然排序,key为升序 
  8.     System.out.println("默认 排序结果:" + initMap.toString()); 
  9.     //自定义排序,在TreeMap初始化阶段传入Comparator 内部对象 
  10.     Map comparatorMap = new TreeMap<String, String>(new Comparator<String>() { 
  11.         @Override 
  12.         public int compare(String o1, String o2){ 
  13.             //根据key比较大小,采用倒叙,以大到小排序 
  14.             return o2.compareTo(o1); 
  15.         } 
  16.     }); 
  17.     comparatorMap.put("4""d"); 
  18.     comparatorMap.put("3""c"); 
  19.     comparatorMap.put("1""a"); 
  20.     comparatorMap.put("2""b"); 
  21.     System.out.println("自定义 排序结果:" + comparatorMap.toString()); 

输出结果:

 

  1. 默认 排序结果:{1=a, 2=b, 3=c, 4=d} 
  2. 自定义 排序结果:{4=d, 3=c, 2=b, 1=a} 

相信使用过TreeMap的朋友,一定知道TreeMap会自动将key按照一定规则进行排序,TreeSet正是使用了TreeMap这种特性,来实现添加的元素集合,在输出的时候,其结果是已经排序好的。

如果您没看过源码TreeMap的实现过程,可以参阅集合系列文章中TreeMap的实现过程介绍,或者阅读 jdk 源码。

remove方法

TreeSet 的删除方法,同样如此,也是基于 TreeMap 的底层实现,源码如下:

 

  1. public boolean remove(Object o) { 
  2.         //调用TreeMap 的remove方法,移除元素 
  3.         return m.remove(o)==PRESENT; 

查询方法

TreeSet 没有重写 get 方法,而是使用迭代器或者 for 循环来遍历元素,方法如下:

 

  1. public static void main(String[] args) { 
  2.     Set<String> treeSet = new TreeSet<>(); 
  3.     System.out.println("treeSet初始容量大小:"+treeSet.size()); 
  4.     treeSet.add("1"); 
  5.     treeSet.add("4"); 
  6.     treeSet.add("3"); 
  7.     treeSet.add("8"); 
  8.     treeSet.add("5"); 
  9.  
  10.     System.out.println("treeSet容量大小:"+treeSet.size()); 
  11.     //迭代器遍历 
  12.     Iterator<String> iterator = treeSet.iterator(); 
  13.     while (iterator.hasNext()){ 
  14.         String str = iterator.next(); 
  15.         System.out.print(str + ","); 
  16.     } 
  17.  
  18.     System.out.println("\n==========="); 
  19.     //增强for循环 
  20.     for (String str : treeSet) { 
  21.         System.out.print(str + ","); 
  22.     } 

输出结果:

 

  1. treeSet初始容量大小:0 
  2. treeSet容量大小:5 
  3. 1,3,4,5,8, 
  4. =========== 
  5. 1,3,4,5,8, 

自定义排序

使用自定义排序,有 2 种方法,第一种在需要添加的元素类,实现Comparable接口,重写compareTo方法来实现对元素进行比较,实现自定义排序。

方法一

 

  1. /** 
  2.   * 创建实体类Person实现Comparable接口 
  3.   */ 
  4. public class Person implements Comparable<Person>{ 
  5.     private int age; 
  6.     private String name
  7.     public Person(String nameint age){ 
  8.         this.name = name
  9.         this.age = age; 
  10.     } 
  11.     @Override 
  12.     public int compareTo(Person o){ 
  13.         //重写 compareTo 方法,自定义排序算法 
  14.         return this.age-o.age; 
  15.     } 
  16.     @Override 
  17.     public String toString(){ 
  18.         return name+":"+age; 
  19.     } 

创建一个Person实体类,实现Comparable接口,重写compareTo方法,通过变量age实现自定义排序 测试方法如下:

 

  1. public static void main(String[] args) { 
  2.     Set<Person> treeSet = new TreeSet<>(); 
  3.     System.out.println("treeSet初始容量大小:"+treeSet.size()); 
  4.     treeSet.add(new Person("李一",18)); 
  5.     treeSet.add(new Person("李二",17)); 
  6.     treeSet.add(new Person("李三",19)); 
  7.     treeSet.add(new Person("李四",21)); 
  8.     treeSet.add(new Person("李五",20)); 
  9.  
  10.     System.out.println("treeSet容量大小:"+treeSet.size()); 
  11.     System.out.println("按照年龄从小到大,自定义排序结果:"); 
  12.     //迭代器遍历 
  13.     Iterator<Person> iterator = treeSet.iterator(); 
  14.     while (iterator.hasNext()){ 
  15.         Person person = iterator.next(); 
  16.         System.out.print(person.toString() + ","); 
  17.     } 

输出结果:

 

  1. treeSet初始容量大小:0 
  2. treeSet容量大小:5 
  3. 按照年龄从小到大,自定义排序结果: 
  4. 李二:17,李一:18,李三:19,李五:20,李四:21, 

方法二

第二种方法是在TreeSet初始化阶段,Person不用实现Comparable接口,将Comparator接口以内部类的形式作为参数,初始化进去,方法如下:

 

  1. public static void main(String[] args) { 
  2.     //自定义排序 
  3.     Set<Person> treeSet = new TreeSet<>(new Comparator<Person>(){ 
  4.         @Override 
  5.         public int compare(Person o1, Person o2) { 
  6.             if(o1 == null || o2 == null){ 
  7.                 //不用比较 
  8.                 return 0; 
  9.             } 
  10.             //从小到大进行排序 
  11.             return o1.getAge() - o2.getAge(); 
  12.         } 
  13.     }); 
  14.     System.out.println("treeSet初始容量大小:"+treeSet.size()); 
  15.     treeSet.add(new Person("李一",18)); 
  16.     treeSet.add(new Person("李二",17)); 
  17.     treeSet.add(new Person("李三",19)); 
  18.     treeSet.add(new Person("李四",21)); 
  19.     treeSet.add(new Person("李五",20)); 
  20.  
  21.     System.out.println("treeSet容量大小:"+treeSet.size()); 
  22.     System.out.println("按照年龄从小到大,自定义排序结果:"); 
  23.     //迭代器遍历 
  24.     Iterator<Person> iterator = treeSet.iterator(); 
  25.     while (iterator.hasNext()){ 
  26.         Person person = iterator.next(); 
  27.         System.out.print(person.toString() + ","); 
  28.     } 

输出结果:

 

  1. treeSet初始容量大小:0 
  2. treeSet容量大小:5 
  3. 按照年龄从小到大,自定义排序结果: 
  4. 李二:17,李一:18,李三:19,李五:20,李四:21, 

需要注意的是,TreeSet不能添加为空的元素,否则会报空指针错误!

05. EnumSet

EnumSet 是一个与枚举类型一起使用的专用 Set 集合,继承自AbstractSet抽象类。与 HashSet、LinkedHashSet 、TreeSet 不同的是,EnumSet 元素必须是Enum的类型,并且所有元素都必须来自同一个枚举类型,EnumSet 定义源码如下:

 

  1. public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E> 
  2.     implements Cloneable, java.io.Serializable { 
  3.     ...... 

EnumSet是一个虚类,不能直接通过实例化来获取对象,只能通过它提供的静态方法来返回EnumSet实现类的实例。

EnumSet的实现类有两个,分别是RegularEnumSet、JumboEnumSet两个类,两个实现类都继承自EnumSet。

EnumSet会根据枚举类型中元素的个数,来决定是返回哪一个实现类,当 EnumSet元素中的元素个数小于或者等于64,就会返回RegularEnumSet实例;当EnumSet元素个数大于64,就会返回JumboEnumSet实例。

这一点,我们可以从源码中看出,源码如下:

 

  1. public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) { 
  2.     Enum<?>[] universe = getUniverse(elementType); 
  3.     if (universe == null
  4.         throw new ClassCastException(elementType + " not an enum"); 
  5.     //当元素个数小于或者等于 64 的时候,返回 RegularEnumSet 
  6.     if (universe.length <= 64) 
  7.         return new RegularEnumSet<>(elementType, universe); 
  8.     else 
  9.         //大于64,返回 JumboEnumSet 
  10.         return new JumboEnumSet<>(elementType, universe); 

noneOf是EnumSet中一个静态方法,用于判断是返回哪一个实现类。

我们来看看当元素个数小于等于64的时候,使用RegularEnumSet的类,源码如下:

 

  1. class RegularEnumSet<E extends Enum<E>> extends EnumSet<E> { 
  2.  
  3.     /**元素为long型*/ 
  4.     private long elements = 0L; 
  5.  
  6.     /**添加元素*/ 
  7.     public boolean add(E e) { 
  8.         typeCheck(e); 
  9.  
  10.         long oldElements = elements; 
  11.         //二进制运算,获取元素 
  12.         elements |= (1L << ((Enum<?>)e).ordinal()); 
  13.         return elements != oldElements; 
  14.     } 

RegularEnumSet 通过二进制运算得到结果,直接使用long来存放元素。

我们再来看看当元素个数大于64的时候,使用JumboEnumSet的类,源码如下:

 

  1. class JumboEnumSet<E extends Enum<E>> extends EnumSet<E> { 
  2.  
  3.     /**元素为long型*/ 
  4.     private long elements = 0L; 
  5.  
  6.     /**添加元素*/ 
  7.     public boolean add(E e) { 
  8.         typeCheck(e); 
  9.  
  10.         int eOrdinal = e.ordinal(); 
  11.         int eWordNum = eOrdinal >>> 6; 
  12.  
  13.         long oldElements = elements[eWordNum]; 
  14.         //二进制运算 
  15.         elements[eWordNum] |= (1L << eOrdinal); 
  16.         //使用数组来操作元素 
  17.         boolean result = (elements[eWordNum] != oldElements); 
  18.         if (result) 
  19.             size++; 
  20.         return result; 
  21.     } 

JumboEnumSet 也是通过二进制运算得到结果,使用long来存放元素,但是它是使用数组来存放元素。

二者相比,RegularEnumSet 效率比 JumboEnumSet 高些,因为操作步骤少,大多数情况下返回的是 RegularEnumSet,只有当枚举元素个数超过 64 的时候,会使用 JumboEnumSet。

添加元素

新建一个EnumEntity的枚举类型,定义2个参数。

 

  1. public enum EnumEntity { 
  2.     WOMAN,MAN; 

创建一个空的 EnumSet!

 

  1. //创建一个 EnumSet,内容为空 
  2. EnumSet<EnumEntity> noneSet = EnumSet.noneOf(EnumEntity.class); 
  3. System.out.println(noneSet); 

输出结果:

 

  1. [] 

创建一个 EnumSet,并将枚举类型的元素全部添加进去!

 

  1. //创建一个 EnumSet,将EnumEntity 元素内容添加到EnumSet中 
  2. EnumSet<EnumEntity> allSet = EnumSet.allOf(EnumEntity.class); 
  3. System.out.println(allSet); 

输出结果:

 

  1. [WOMAN, MAN] 

创建一个 EnumSet,添加指定的枚举元素!

 

  1. //创建一个 EnumSet,添加 WOMAN 到 EnumSet 中 
  2. EnumSet<EnumEntity> customSet = EnumSet.of(EnumEntity.WOMAN); 
  3. System.out.println(customSet); 

查询元素

EnumSet与HashSet、LinkedHashSet、TreeSet一样,通过迭代器或者 for 循环来遍历元素,方法如下:

 

  1. EnumSet<EnumEntity> allSet = EnumSet.allOf(EnumEntity.class); 
  2. for (EnumEntity enumEntity : allSet) { 
  3.     System.out.print(enumEntity + ","); 

输出结果:

 

  1. WOMAN,MAN, 

06. 总结

 

 

HashSet 是一个输入输出无序的 Set 集合,元素不重复,底层基于 HashMap 的 key 来实现,元素可以为空,如果添加的元素为对象,对象需要重写 equals() 和 hashCode() 方法来约束是否为相同的元素。

LinkedHashSet 是一个输入输出有序的 Set 集合,继承自 HashSet,元素不重复,底层基于 LinkedHashMap 的 key来实现,元素也可以为空,LinkedHashMap 使用循环链表结构来保证输入输出有序。

TreeSet 是一个排序的 Set 集合,元素不可重复,底层基于 TreeMap 的 key来实现,元素不可以为空,默认按照自然排序来存放元素,也可以使用 Comparable 和 Comparator 接口来比较大小,实现自定义排序。

EnumSet 是一个与枚举类型搭配使用的专用 Set 集合,在 jdk1.5 中加入。EnumSet 是一个虚类,有2个实现类 RegularEnumSet、JumboEnumSet,不能显式的实例化改类,EnumSet 会动态决定使用哪一个实现类,当元素个数小于等于64的时候,使用 RegularEnumSet;大于 64的时候,使用JumboEnumSet类,EnumSet 其内部使用位向量实现,拥有极高的时间和空间性能,如果元素是枚举类型,推荐使用 EnumSet。

07. 参考

1、JDK1.7&JDK1.8 源码

 

2、程序园 - java集合-EnumMap与EnumSet

责任编辑:华轩 来源: Java极客技术
相关推荐

2019-11-11 14:51:19

Java数据结构Properties

2021-03-16 08:54:35

AQSAbstractQueJava

2011-07-04 10:39:57

Web

2013-11-14 15:53:53

AndroidAudioAudioFlinge

2022-12-02 09:13:28

SeataAT模式

2009-11-30 16:46:29

学习Linux

2019-01-07 15:29:07

HadoopYarn架构调度器

2017-07-02 18:04:53

块加密算法AES算法

2012-05-21 10:06:26

FrameworkCocoa

2021-07-20 15:20:02

FlatBuffers阿里云Java

2015-08-06 14:02:31

数据分析

2018-03-15 09:13:43

MySQL存储引擎

2022-09-26 09:01:15

语言数据JavaScript

2023-03-20 09:48:23

ReactJSX

2018-11-09 16:24:25

物联网云计算云系统

2012-02-21 13:55:45

JavaScript

2021-04-27 08:54:43

ConcurrentH数据结构JDK8

2022-01-11 07:52:22

CSS 技巧代码重构

2019-12-04 10:13:58

Kubernetes存储Docker

2009-11-18 13:30:37

Oracle Sequ
点赞
收藏

51CTO技术栈公众号