TomyZhang
TomyZhang

JDK源码--HashSet

一、概念

类定义：

public class HashSet
    extends AbstractSet
    implements Set, Cloneable, java.io.Serializable
  • 继承了AbstractSet抽象类，实现了Set接口，拥有一组Set通用的操作。
  • 实现了Cloneable接口，可进行浅层次拷贝。
  • 实现了Serializable接口，可进行序列化。

特点：

  • 允许存放空对象。
  • 没有重复元素。
  • 不保证元素顺序。
  • 非线程安全类，可通过Collections.synchronizedSet(new HashSet())获得线程安全的HashSet。

二、使用

//TestHashSet
public class TestHashSet {
    private static final String TAG = "TestHashSet";
    private HashSet  set = new HashSet();

    public void testAdd() {
        set.add("Android");
        set.add("Java");
        set.add("网络协议");
        set.add("数据结构与算法");
        set.add("Android");
        Log.d(TAG, "zwm, add set: " + set);
    }

    public void testRemove() {
        set.remove("网络协议");
        Log.d(TAG, "zwm, remove set: " + set);
    }

    public void testContains() {
        Log.d(TAG, "zwm, contains Java: " + set.contains("Java"));
    }

    public void testSize() {
        Log.d(TAG, "zwm, size: " + set.size());
    }

    public void testClear() {
        set.clear();
        Log.d(TAG, "zwm, clear set: " + set);
    }

    public void testEmpty() {
        Log.d(TAG, "zwm, isEmpty: " + set.isEmpty());
    }

    public void testIterator() {
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            Log.d(TAG, "zwm, iterator item: " + iterator.next());
        }
    }

    public void testClone() {
        Log.d(TAG, "zwm, set hashcode: " + set.hashCode());
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            Log.d(TAG, "zwm, set item hashcode: " + iterator.next().hashCode());
        }

        HashSet cloneSet = (HashSet)set.clone(); //浅拷贝
        Log.d(TAG, "zwm, cloneSet hashcode: " + cloneSet.hashCode());
        Iterator cloneIterator = cloneSet.iterator();
        while(cloneIterator.hasNext()) {
            Log.d(TAG, "zwm, cloneSet item hashcode: " + cloneIterator.next().hashCode());
        }
        Log.d(TAG, "zwm, set.equals(cloneSet): " + set.equals(cloneSet));
        Log.d(TAG, "zwm, set==cloneSet: " + (set==cloneSet));
    }

    public void testAddAll() {
        HashSet temp = new HashSet();
        temp.add("tempAAA");
        temp.add("tempBBB");
        temp.add("tempCCC");
        set.addAll(temp);
        Log.d(TAG, "zwm, addAll set: " + set);
    }

    public void testContainsAll() {
        HashSet temp = new HashSet();
        temp.add("tempAAA");
        temp.add("tempBBB");
        Log.d(TAG, "zwm, containsAll: " + set.containsAll(temp));
    }

    public void testRemoveAll() {
        HashSet temp = new HashSet();
        temp.add("tempAAA");
        temp.add("tempBBB");
        temp.add("tempDDD");
        Log.d(TAG, "zwm, removeAll: " + set.removeAll(temp));
        Log.d(TAG, "zwm, set: " + set);
    }

    public void testRetainAll() {
        HashSet temp = new HashSet();
        temp.add("Android");
        temp.add("Java");
        temp.add("DDD");
        Log.d(TAG, "zwm, retainAll: " + set.retainAll(temp));
        Log.d(TAG, "zwm, set: " + set);
    }

    public void testToArray() {
        //注意：以下注释的语句会抛异常java.lang.ClassCastException: java.lang.Object[] cannot be cast to java.lang.String[]
        //Java中的强制类型转换只是针对单个对象的，想要偷懒将整个数组转换成另外一种类型的数组是不行的
        //String[] arrays = (String[])set.toArray();
        Object[] arrays = set.toArray();
        for(Object item : arrays) {
            Log.d(TAG, "zwm, for item: " + item);
        }
    }

    public void testToArray2() {
        String[] param = new String[set.size()];
        String[] result = set.toArray(param);
        for(String item : param) {
            Log.d(TAG, "zwm, for param item: " + item);
        }
        for(String item : result) {
            Log.d(TAG, "zwm, for result item: " + item);
        }
    }
}

//测试代码
private void testMethod() {
    Log.d(TAG, "zwm, testMethod");
    TestHashSet testHashSet = new TestHashSet();
    testHashSet.testAdd();
    testHashSet.testRemove();
    testHashSet.testContains();
    testHashSet.testSize();
    testHashSet.testClear();
    testHashSet.testEmpty();
    testHashSet.testAdd();
    testHashSet.testAddAll();
    testHashSet.testIterator();
    testHashSet.testClone();
    testHashSet.testContainsAll();
    testHashSet.testRemoveAll();
    testHashSet.testRetainAll();
    testHashSet.testToArray();
    testHashSet.testToArray2();
}

//输出log
2019-07-31 10:36:23.647 zwm, testMethod
2019-07-31 10:36:23.650 zwm, add set: [Java, 数据结构与算法, 网络协议, Android]
2019-07-31 10:36:23.650 zwm, remove set: [Java, 数据结构与算法, Android]
2019-07-31 10:36:23.651 zwm, contains Java: true
2019-07-31 10:36:23.651 zwm, size: 3
2019-07-31 10:36:23.651 zwm, clear set: []
2019-07-31 10:36:23.651 zwm, isEmpty: true
2019-07-31 10:36:23.651 zwm, add set: [Java, 数据结构与算法, 网络协议, Android]
2019-07-31 10:36:23.652 zwm, addAll set: [Java, 数据结构与算法, 网络协议, tempAAA, tempBBB, Android, tempCCC]
2019-07-31 10:36:23.652 zwm, iterator item: Java
2019-07-31 10:36:23.652 zwm, iterator item: 数据结构与算法
2019-07-31 10:36:23.652 zwm, iterator item: 网络协议
2019-07-31 10:36:23.652 zwm, iterator item: tempAAA
2019-07-31 10:36:23.652 zwm, iterator item: tempBBB
2019-07-31 10:36:23.652 zwm, iterator item: Android
2019-07-31 10:36:23.653 zwm, iterator item: tempCCC
2019-07-31 10:36:23.653 zwm, set hashcode: 1030884738
2019-07-31 10:36:23.653 zwm, set item hashcode: 2301506
2019-07-31 10:36:23.653 zwm, set item hashcode: -788094787
2019-07-31 10:36:23.653 zwm, set item hashcode: 1002884394
2019-07-31 10:36:23.653 zwm, set item hashcode: -1428146227
2019-07-31 10:36:23.653 zwm, set item hashcode: -1428145234
2019-07-31 10:36:23.654 zwm, set item hashcode: 803262031
2019-07-31 10:36:23.654 zwm, set item hashcode: -1428144241
2019-07-31 10:36:23.654 zwm, cloneSet hashcode: 1030884738
2019-07-31 10:36:23.655 zwm, cloneSet item hashcode: 2301506
2019-07-31 10:36:23.655 zwm, cloneSet item hashcode: -788094787
2019-07-31 10:36:23.655 zwm, cloneSet item hashcode: 1002884394
2019-07-31 10:36:23.655 zwm, cloneSet item hashcode: -1428146227
2019-07-31 10:36:23.655 zwm, cloneSet item hashcode: -1428145234
2019-07-31 10:36:23.655 zwm, cloneSet item hashcode: 803262031
2019-07-31 10:36:23.655 zwm, cloneSet item hashcode: -1428144241
2019-07-31 10:36:23.656 zwm, set.equals(cloneSet): true
2019-07-31 10:36:23.656 zwm, set==cloneSet: false
2019-07-31 10:36:23.656 zwm, containsAll: true
2019-07-31 10:36:23.656 zwm, removeAll: true
2019-07-31 10:36:23.657 zwm, set: [Java, 数据结构与算法, 网络协议, Android, tempCCC]
2019-07-31 10:36:23.657 zwm, retainAll: true
2019-07-31 10:36:23.657 zwm, set: [Java, Android]
2019-07-31 10:36:23.657 zwm, for item: Java
2019-07-31 10:36:23.657 zwm, for item: Android
2019-07-31 10:36:23.657 zwm, for param item: Java
2019-07-31 10:36:23.658 zwm, for param item: Android
2019-07-31 10:36:23.658 zwm, for result item: Java
2019-07-31 10:36:23.658 zwm, for result item: Android

三、原理

重要参数

//底层使用HashMap来保存HashSet的元素
private transient HashMap map;

//由于Set只使用到了HashMap的key，所以此处定义一个静态的常量Object类，来充当HashMap的value
private static final Object PRESENT = new Object();

构造函数

//无参构造方法，使用HashMap的默认容量大小16和默认加载因子0.75初始化map，构造一个HashSet
public HashSet() {
    map = new HashMap<>();
}

//指定一个Collection参数构造HashSet，并将参数中的元素添加到HashSet中
public HashSet(Collection c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}

//使用指定的初始容量大小和加载因子初始化map，构造一个HashSet
public HashSet(int initialCapacity, float loadFactor) {
    map = new HashMap<>(initialCapacity, loadFactor);
}

//使用指定的初始容量大小和默认的加载因子0.75初始化map，构造一个HashSet
public HashSet(int initialCapacity) {
    map = new HashMap<>(initialCapacity);
}

//不对外公开的一个构造方法（默认default修饰），底层构造的是LinkedHashMap，dummy只是一个标示参数，只是为了区分其它构造方法，无具体意义
//实际上是提供给LinkedHashSet使用的
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

public boolean add(E e)

//添加一个元素到HashMap
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

public boolean remove(Object o)

//从HashMap中移除一个元素
public boolean remove(Object o) {
    return map.remove(o)==PRESENT;
}

public boolean contains(Object o)

//判断HashMap中是否包含相应的对象
public boolean contains(Object o) {
    return map.containsKey(o);
}

public int size()

//返回HashMap的大小
public int size() {
    return map.size();
}

public void clear()

//清空HashMap
public void clear() {
    map.clear();
}

public boolean isEmpty()

//判断HashMap是否为空
public boolean isEmpty() {
    return map.isEmpty();
}

public Iterator iterator()

//先通过HashMap的keySet()方法得到key的Set集合，然后再获取该Set集合的迭代器对象
public Iterator iterator() {
    return map.keySet().iterator();
}

public Object clone()

//返回浅拷贝对象
public Object clone() {
    try {
        HashSet newSet = (HashSet) super.clone();
        newSet.map = (HashMap) map.clone();
        return newSet;
    } catch (CloneNotSupportedException e) {
        throw new InternalError(e);
    }
}

AbstractCollection public boolean addAll(Collection c)

//将给定的Collection对象的所有元素添加到HashSet中
public boolean addAll(Collection c) {
    boolean modified = false;
    for (E e : c)
        if (add(e))
            modified = true;
    return modified;
}

AbstractCollection public boolean containsAll(Collection c)

//判断HashSet是否包含给定的Collection对象的所有元素
public boolean containsAll(Collection c) {
    for (Object e : c)
        if (!contains(e))
            return false;
    return true;
}

AbstractCollection public boolean removeAll(Collection c)

//在HashSet中移除给定的Collection对象的所有元素
public boolean removeAll(Collection c) {
    Objects.requireNonNull(c);
    boolean modified = false;
    Iterator it = iterator();
    while (it.hasNext()) {
        if (c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

AbstractCollection public boolean retainAll(Collection c)

//在HashSet中保留给定的Collection对象的所有元素
public boolean retainAll(Collection c) {
    Objects.requireNonNull(c);
    boolean modified = false;
    Iterator it = iterator();
    while (it.hasNext()) {
        if (!c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

AbstractCollection public Object[] toArray()

//将HashSet的所有元素保存到Object数组中，并返回该数组
public Object[] toArray() {
    // Estimate size of array; be prepared to see more or fewer elements
    Object[] r = new Object[size()];
    Iterator it = iterator();
    for (int i = 0; i < r.length; i++) {
        if (! it.hasNext()) // fewer elements than expected
            return Arrays.copyOf(r, i);
        r[i] = it.next();
    }
    return it.hasNext() ? finishToArray(r, it) : r;
}

AbstractCollection public T[] toArray(T[] a)

//将HashSet的所有元素保存到T类型的数组中，并返回该数组
public  T[] toArray(T[] a) {
    // Estimate size of array; be prepared to see more or fewer elements
    int size = size();
    T[] r = a.length >= size ? a :
              (T[])java.lang.reflect.Array
              .newInstance(a.getClass().getComponentType(), size);
    Iterator it = iterator();

    for (int i = 0; i < r.length; i++) {
        if (! it.hasNext()) { // fewer elements than expected
            if (a == r) {
                r[i] = null; // null-terminate
            } else if (a.length < i) {
                return Arrays.copyOf(r, i);
            } else {
                System.arraycopy(r, 0, a, 0, i);
                if (a.length > i) {
                    a[i] = null;
                }
            }
            return a;
        }
        r[i] = (T)it.next();
    }
    // more elements than expected
    return it.hasNext() ? finishToArray(r, it) : r;
}

四、主题

HashSet保存自定义对象

无重写hashCode及equals方法：

//TestObject
public class TestObject {
    public String name;
    public int age;

    public TestObject(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

//TestHashSet
public class TestHashSet {
    private static final String TAG = "TestHashSet";
    private HashSet  set = new HashSet<>();

    public void doSomething() {
        set.add(new TestObject("aaa", 1)); //注意此元素
        set.add(new TestObject("bbb", 2));
        set.add(new TestObject("ccc", 3));
        set.add(new TestObject("aaa", 1)); //注意此元素
        set.add(null);
        Log.d(TAG, "zwm, set size: " + set.size());
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            TestObject object = (TestObject)iterator.next();
            Log.d(TAG, "zwm, object: " + object);
            if(object != null) {
                Log.d(TAG, "zwm, item: name->" + object.name + ", age->" + object.age + ", hashcode->" + object.hashCode());
            }
        }
    }
}

//测试代码
private void testMethod() {
    Log.d(TAG, "zwm, testMethod");
    TestHashSet testHashSet = new TestHashSet();
    testHashSet.doSomething();
}

//输出log
2019-07-31 15:51:51.676 zwm, testMethod
2019-07-31 15:51:51.677 zwm, set size: 5
2019-07-31 15:51:51.678 zwm, item: name->aaa, age->1, hashcode->23649305 //注意此元素
2019-07-31 15:51:51.678 zwm, item: name->aaa, age->1, hashcode->268378508 //注意此元素
2019-07-31 15:51:51.678 zwm, item: name->bbb, age->2, hashcode->17532126
2019-07-31 15:51:51.679 zwm, item: name->ccc, age->3, hashcode->102196927

有重写hashCode及equals方法：

//TestObject
public class TestObject {
    public String name;
    public int age;

    public TestObject(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int hashCode() { //重写hashCode方法
        int hash = 0;
        if(!TextUtils.isEmpty(name)) {
            hash += name.hashCode();
        }
        hash += age;
        return hash;
    }

    @Override
    public boolean equals(Object obj) { //重写equals方法
        if(obj == this) { //如果两个对象引用相同，则说明是同一个对象
            return true;
        }
        if(obj instanceof TestObject) {
            TestObject object = (TestObject)obj;
            if(TextUtils.equals(object.name, name) && object.age == age) {
                return true;
            }
        }
        return false;
    }
}

//TestHashSet
public class TestHashSet {
    private static final String TAG = "TestHashSet";
    private HashSet  set = new HashSet<>();

    public void doSomething() {
        set.add(new TestObject("aaa", 1)); //注意此元素
        set.add(new TestObject("bbb", 2));
        set.add(new TestObject("ccc", 3));
        set.add(new TestObject("aaa", 1)); //注意此元素
        set.add(null);
        Log.d(TAG, "zwm, set size: " + set.size());
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            TestObject object = (TestObject)iterator.next();
            if(object != null) {
                Log.d(TAG, "zwm, item: name->" + object.name + ", age->" + object.age + ", hashcode->" + object.hashCode());
            }
        }
    }
}

//测试代码
private void testMethod() {
    Log.d(TAG, "zwm, testMethod");
    TestHashSet testHashSet = new TestHashSet();
    testHashSet.doSomething();
}

//输出log
2019-07-31 16:10:26.405 zwm, testMethod
2019-07-31 16:10:26.409 zwm, set size: 4
2019-07-31 16:10:26.410 zwm, item: name->aaa, age->1, hashcode->96322 //注意此元素
2019-07-31 16:10:26.410 zwm, item: name->bbb, age->2, hashcode->97316
2019-07-31 16:10:26.410 zwm, item: name->ccc, age->3, hashcode->98310

LinkedHashSet

LinkedHashSet

你可能感兴趣的:(JDK源码--HashSet)

  • leetCode进阶算法题+解析（八十五） 唯有努力不欺人丶
    子数组按位或操作题目：我们有一个非负整数数组A。对于每个（连续的）子数组B=[A[i],A[i+1],...,A[j]]（iset=newHashSet();Setlast=newHashSet();for(inti:arr){Settemp=newHashSet();temp.add(i);for(intc:last){temp.add(c|i);}last=temp;set.addAll(te
  • Java 【数据结构】 哈希（Hash超详解）HashSet&HashMap【神装】 中草药z 【Java】登神长阶史诗般的Java成神之路哈希算法数据结构javahashhashtableMapSet
    登神长阶第十神装HashSet第十一神装HashMap目录一.哈希1.概念2.Object类的hashCode()方法:3.String类的哈希码:4.注意事项:二.哈希桶1.哈希桶原理2.哈希桶的实现细节3.总结三.解决哈希冲突的常用方法*四.HashSet1.定义2.操作3.特性4.内部实现5.应用场景✏️五.HashMap✒️1.定义️2.操作️3.特性️4.内部实现️5.应用场景六.对比七
  • LeetCode之图的广度优先搜索 星夜孤帆 宽度优先算法
    433.最小基因变化classSolution{publicintminMutation(Stringstart,Stringend,String[]bank){//将基因库存储在集合中，便于快速查找SetbankSet=newHashSetqueue=newLinkedList<>();queue.offer(start);//记录变换的步骤intsteps=0;//定义基因的四个可变字符cha
  • gee mysql数据库_MySQL weixin_39955142 geemysql数据库
    集合如果你有更好的想法请在评论区留下您的答案，一起交流讨论说说常见的集合有哪些？答：主要分List、Set、Map、Queue四类，其中包含ArrayList、LinkedList、HashSet、TreeSet、HashMapComparable和Comparator接口的区别？答：其两...»smart-rick2021-02-15JAVA基础面向对象有哪些特征？答：继承、封装、多态JDK与J
  • Java之Java基础二十（集合[上]) Violet永存 Javajava开发语言Java基础
    Java集合框架可以分为两条大的支线：①、Collection，主要由List、Set、Queue组成：List代表有序、可重复的集合，典型代表就是封装了动态数组的ArrayList和封装了链表的LinkedList；Set代表无序、不可重复的集合，典型代表就是HashSet和TreeSet；Queue代表队列，典型代表就是双端队列ArrayDeque，以及优先级队列PriorityQueue。②
  • Java集合之HashSet源码解析 气宇轩昂固执狂 JAVA面试笔试通关指南java开发语言HashSetHashSet源码
    一、HashSet概述：1、HashSet底层实现实际上就是利用HashMap的键（Key）来存储对象，原HashMap的键key的位置存放对象，值value的位置存放空的Object对象作为虚拟值；2、增加和删除都是直接调用HashMap的方法来实现的，没有修改和具体的查询方法，获取值只能通过iterator方法来迭代，迭代方法也是建立在HashMap的键的迭代方法上的。相关HashSet的操作
  • Leetcode面试经典150题-54.螺旋矩阵 鱼跃鹰飞 数据结构与算法字节跳动高频面试题leetcode面试算法
    解法都在代码里，不懂就留言或者私信这个题可能和算法关联不大，coding技巧为上classSolution{publicListspiralOrder(int[][]matrix){/**先定义结果集*/Listans=newArrayListexistsSet=newHashSet=0&&colNext>=0&&rowNext
  • C#语言基础速成Day07 blaizeer C#c#windows开发语言算法
    “知止而后有定，定而后能静，静而后能安，安而后能虑，虑而后能得。”目录前言文章有误敬请斧正不胜感恩！||Day07C#常见数据结构：1.集合（Collection）1.1**List**1.2**HashSet**1.3**LinkedList**1.4**ObservableCollection**2.栈（Stack）2.1深度优先搜索（DFS）2.2广度优先搜索（BFS）代码解释适用场景3.堆
  • 2367. 算术三元组的数目 红树_
    把握现在，决战今天。LC每日一题，参考2367.算术三元组的数目，难度分1203。题目给你一个下标从0开始、严格递增的整数数组nums和一个正整数diff。如果满足下述全部条件，则三元组(i,j,k)就是一个算术三元组：ihs=newHashSet=diff*2&&hs.contains(num-diff)&&hs.contains(num-diff*2))ans++;}returnans;}}数
  • 字节微软阿里腾讯快手面试题——349. 两个数组的交集 iygvh 算法与数据结构算法
    349.两个数组的交集给定两个数组nums1和nums2，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。示例1：输入：nums1=[1,2,2,1],nums2=[2,2]输出：[2]示例2：输入：nums1=[4,9,5],nums2=[9,4,9,8,4]输出：[9,4]解释：[4,9]也是可通过的提示：1set1=newHashSet();Setset2=n
  • 算法-快乐数（202） 翔山代码 算法算法哈希算法数据结构
    这道题可以用for循环来做，也就是不停计算平方直到结果为1或者出现循环，但是题目要求用hash表来做，那我们可以稍微改造一下，下面是代码importjava.util.HashSet;importjava.util.Set;publicclassSolution9{//创建一个hash_set用来存储n的平方和检测一下如果n变成了1或者出现了循环则退出循环publicbooleanisHappy(
  • 算法-最长连续序列 翔山代码 算法算法
    leetcode的题目链接这道题的思路主要是要求在O（n)的时间复杂度下，所以你暴力解决肯定不行，暴力至少两层for循环，所以要在O（n)的时间复杂度下，你可以使用HashSet来存储数组，对于每个数字，我们判断它的前一个数字在不在集合里面，如果在就再向前判断，不在就以这个为标准，开始向后遍历，一直到后面不是+1，停止，返回最大长度。下面是代码importjava.util.HashSet;imp
  • 面试官：HashSet如何保证元素不重复？ Java架构奶思
    HashSet实现了Set接口，由哈希表（实际是HashMap）提供支持。HashSet不保证集合的迭代顺序，但允许插入null值。也就是说HashSet不能保证元素插入顺序和迭代顺序相同。HashSet具备去重的特性，也就是说它可以将集合中的重复元素自动过滤掉，保证存储在HashSet中的元素都是唯一的。1.HashSet基本用法HashSet基本操作方法有：add（添加）、remove（删除）
  • 代码随想录——139.单词拆分 cui_hao_nan 代码随想录java算法开发语言
    classSolution{publicbooleanwordBreak(Strings,ListwordDict){HashSetset=newHashSet<>(wordDict);boolean[]valid=newboolean[s.length()+1];valid[0]=true;for(inti=1;i<=s.length();i++){for(intj=0;j
  • 代码随想录系统性一刷总结 snoooooooooooooopy leetcodejava
    代码随想录系统性一刷总结数组指针思想很重要day01二分查找+移除元素day02数组平方+长度最小子数组+螺旋矩阵II链表链表结点的增删改查，头结点的运用，灵活运用指针day03移除链表元素+设计链表+翻转链表day04交换结点+删除结点+链表相交+环形列表哈希表灵活使用hashset，几数之和指针再次出马，理解去重和剪枝操作day06字符串异位词+数组交集+快乐数+两数之和day07赎金信+四数
  • Java中HashSet和HashMap类之间的区别 cumt30111 数据结构javapythonmysql队列
    HashMap与HashSet(HashMapvsHashSet)First,wewillseehowHashMapdiffersfromHashSetinJava?首先，我们将看到HashMap与Java中的HashSet有何不同？哈希图(HashMap)Thisclassisavailableinjava.utilpackage.此类在java.util包中可用。Thisclassisanim
  • Java中HashSet、HashMap和HashTable的区别 Sueko 日常学习笔记Javajava开发语言
    今天写每日一题时，看到题解用到了HashSet。之前数据结构学习的时候并没有区别这三者，于是在这里做一个整理。是Leetcode上的这题720.词典中最长的单词，等我写完题解也会把题解再贴上来。Java中HashSet、HashMap和HashTable的区别1.官方文档对这三者的介绍1.1Hashtable1.2HashMap1.3HashSet2.三者之间的区别2.1Hashtable和Has
  • java中的set集合 eqa11 java开发语言
    java中的set集合文章目录java中的set集合1.HashSet集合1.1HashSet的特点1.2HashSet常用方法2.LinkedHashSet集合2.1LinkedHashSet集合的特点3.TreeSet集合3.1TreeSet集合的特点3.2TreeSet的基本使用4.HashSet、LinkedHashSet、TreeSet的使用场景5.list和set集合的区别5.1有序性
  • 11. HashSet的内部实现原理是什么？它如何保证元素不重复？ 这孩子叫逆 面试题java集合java开发语言
    HashSet是Java集合框架中的一个实现了Set接口的类，它用于存储不重复的元素。HashSet的内部实际上是基于HashMap来实现的。下面是HashSet的内部实现原理和它如何保证元素不重复的细节。1.HashSet的底层数据结构HashSet内部使用一个HashMap实例来存储元素。在HashSet中，每个添加的元素实际上是作为HashMap中的键存储的，而HashMap中的值是一个常量
  • 128. 最长连续序列 %d%d2 算法数据结构
    思路：剪枝：判断当前元素是否有前一位元素（是否起始点）哈希：插入哈希集合，查询元素总体：起始点，从头向前，更新最高长度语法注意：（1）HashSet的contains方法期望引用&T而不是值类型T，主要是为了避免不必要的内存拷贝和移动，同时遵循Rust的所有权和借用规则（2）在fornumin&HashSet比在for&numin&Vec中遍历快20倍。遍历对象不同：HashSet遍历（fornu
  • Java笔试面试题AI答之集合（6） 工程师老罗 Java笔试面试题AI答java开发语言
    文章目录31.简述JavaSet有哪些实现类？32.简述Java哪些集合类是线程安全的?33.简述ConcurrentHashMap和HashTable有什么区别？1.线程安全机制2.支持null键和值3.迭代器和分割器4.性能和扩展性5.初始化和默认参数总结34.简述HasmMap和HashSet的区别？一、存储方式二、唯一性三、排序四、访问速度五、功能六、适用场景31.简述JavaSet有哪些
  • Java集合框架--Set（HashSet,TreeSet,LinkedHashSet） 纣王家子迎新 java开发语言学习set
    S‌et概述Set是Java集合框架中的一部分，‌代表了一个不重复元素的集合，‌每个元素在集合中都是唯一的‌。‌Set集合的特点是无序性，‌即集合内的元素不按任何特定顺序排列，‌且每个元素都是唯一的。‌Set集合的主要实现类有HashSet、‌TreeSet和LinkedHashSet。‌HashSet基于哈希表实现，‌具有良好的插入、‌删除和查找性能，‌但不保证元素的迭代顺序。‌TreeSet基
  • JAVA基础篇（三） 凉笙2019
    一，集合与数组的区别二，collection集合的方法三，常用集合分类四，list和set区别五，list集合六，set(1)HashSet底层数据结构采用哈希表实现，元素无序且唯一，线程不安全，效率高，可以存储null元素，元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性。(2)LinkedHashSet底层
  • Java 技术栈：Java 中的 HashSet、LinkedHashSet 和 TreeSet（Set 集合）特点与实现解析 阳爱铭 java技术栈javapython开发语言后端数据库架构数据结构个人开发
    Java集合框架（JavaCollectionsFramework）是Java编程语言中处理集合的基础设施，提供了强大的数据结构和算法支持。本文将深入探讨Java中的三种主要Set集合：HashSet、LinkedHashSet和TreeSet，分析它们的特点、实现原理及实际应用场景。1.Set接口概述Set接口是Java集合框架中的一个重要接口，定义了一组不允许重复元素的集合。与List接口不同
  • Java 集合框架：Java 中的 Set 集合（HashSet & LinkedHashSet & TreeSet）特点与实现解析 栗筝i 栗筝i的Java技术栈#Java基础栗筝i的Java技术栈Java基础Java集合JavaSetSet集合
    大家好，我是栗筝i，这篇文章是我的“栗筝i的Java技术栈”专栏的第017篇文章，在“栗筝i的Java技术栈”这个专栏中我会持续为大家更新Java技术相关全套技术栈内容。专栏的主要目标是已经有一定Java开发经验，并希望进一步完善自己对整个Java技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同
  • 力扣126双周赛 koshi484 leetcode算法职场和发展
    k三题求出加密整数的和classSolution{publicintsumOfEncryptedInt(int[]nums){intans=0;for(inti=0;ipq=newPriorityQueue{if(nums[a]!=nums[b]){returnnums[a]-nums[b];}returna-b;});SetmarkedSet=newHashSet0&&!pq.isEmpty()
  • C#常见的.Net类型（二） 林祖师 C#c#.net开发语言
    目录一、在集合中存储多个对象理解集合的选择1.列表2.字典3.堆栈4.队列5.集二、使用Span、索引和范围Span索引范围处理类型和属性1.特性2.创建自定义特性3.反射一、在集合中存储多个对象处理集合的常见类型类型描述List动态大小的数组，可以按索引访问Dictionary键值对集合，根据键进行快速查找Queue先进先出的队列集合Stack后进先出的栈集合HashSet不包含重复元素的集合L
  • Java集合5-HashSet 安迪小宝 java开发语言
    HashSet：基于哈希表实现的集合，用于存储不重复的元素。HashSetset=newHashSetmap;//DummyvaluetoassociatewithanObjectinthebackingMapprivatestaticfinalObjectPRESENT=newObject();发现主要就两个变量:map：用于存放最终数据的。PRESENT：是所有写入map的value值。构造函
  • 代码随想录day5：哈希表part1，哈希基本思路，HashSet&HashMap用法 O_ra_Cle 代码随想录哈希算法散列表算法
    文章目录day5：哈希表part1242.有效的字母异位词349.两个数组的交集202.快乐数1.两数之和day5：哈希表part1242.有效的字母异位词242.有效的字母异位词-力扣（LeetCode）什么时候想到用哈希法，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。当哈希表长度确定时，可以用数组模拟哈希表classSolution{publicbooleanisAna
  • 享元模式 Flyweight JackXiang2019 设计模式享元模式
    1.模式定义:运用共享技术有效地支持大量细粒度的对象优点：如果系统有大量类似的对象，可以节省大量的内存及CPU资源JDK源码中的应用String,Integer,Long...com.sun.org.apache.bcel.internal.generic.InstructionConstants
  • PHP如何实现二维数组排序？ IT独行者 二维数组PHP排序　
    二维数组在PHP开发中经常遇到，但是他的排序就不如一维数组那样用内置函数来的方便了，（一维数组排序可以参考本站另一篇文章【PHP中数组排序函数详解汇总】）。二维数组的排序需要我们自己写函数处理了，这里UncleToo给大家分享一个PHP二维数组排序的函数： 代码： functionarray_sort($arr,$keys,$type='asc'){ $keysvalue= $new_arr
  • 【Hadoop十七】HDFS HA配置 bit1129 hadoop
    基于Zookeeper的HDFS HA配置主要涉及两个文件,core-site和hdfs-site.xml。   测试环境有三台 hadoop.master hadoop.slave1 hadoop.slave2   hadoop.master包含的组件NameNode, JournalNode, Zookeeper，DFSZKFailoverController
  • 由wsdl生成的java vo类不适合做普通java vo darrenzhu VOwsdlwebservicerpc
    开发java webservice项目时，如果我们通过SOAP协议来输入输出，我们会利用工具从wsdl文件生成webservice的client端类，但是这里面生成的java data model类却不适合做为项目中的普通java vo类来使用，当然有一中情况例外，如果这个自动生成的类里面的properties都是基本数据类型，就没问题，但是如果有集合类，就不行。原因如下： 1)使用了集合如Li
  • JAVA海量数据处理之二（BitMap） 周凡杨 java算法bitmapbitset数据
           路漫漫其修远兮，吾将上下而求索。想要更快，就要深入挖掘 JAVA 基础的数据结构，从来分析出所编写的 JAVA 代码为什么把内存耗尽，思考有什么办法可以节省内存呢？ 啊哈！算法。这里采用了 BitMap 思想。   首先来看一个实验： 指定 VM 参数大小： -Xms256m -Xmx540m
  • java类型与数据库类型 g21121 java
    很多时候我们用hibernate的时候往往并不是十分关心数据库类型和java类型的对应关心，因为大多数hbm文件是自动生成的，但有些时候诸如：数据库设计、没有生成工具、使用原始JDBC、使用mybatis(ibatIS)等等情况，就会手动的去对应数据库与java的数据类型关心，当然比较简单的数据类型即使配置错了也会很快发现问题，但有些数据类型却并不是十分常见，这就给程序员带来了很多麻烦。 &nb
  • Linux命令 510888780 linux命令
    系统信息 arch 显示机器的处理器架构(1) uname -m 显示机器的处理器架构(2) uname -r 显示正在使用的内核版本 dmidecode -q 显示硬件系统部件 - (SMBIOS / DMI) hdparm -i /dev/hda 罗列一个磁盘的架构特性 hdparm -tT /dev/sda 在磁盘上执行测试性读取操作 cat /proc/cpuinfo 显示C
  • java常用JVM参数 墙头上一根草 javajvm参数
    -Xms：初始堆大小，默认为物理内存的1/64(<1GB)；默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制 -Xmx：最大堆大小，默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制 -Xmn：新生代的内存空间大小，注意：此处的大小是（eden+ 2
  • 我的spring学习笔记9-Spring使用工厂方法实例化Bean的注意点 aijuans Spring 3
    方法一： <bean id="musicBox" class="onlyfun.caterpillar.factory.MusicBoxFactory" factory-method="createMusicBoxStatic"></bean> 方法二：
  • mysql查询性能优化之二 annan211 UNIONmysql查询优化索引优化
    1 union的限制 有时mysql无法将限制条件从外层下推到内层，这使得原本能够限制部分返回结果的条件无法应用到内层 查询的优化上。 如果希望union的各个子句能够根据limit只取部分结果集，或者希望能够先排好序在 合并结果集的话，就需要在union的各个子句中分别使用这些子句。 例如 想将两个子查询结果联合起来，然后再取前20条记录，那么mys
  • 数据的备份与恢复 百合不是茶 oraclesql数据恢复数据备份
     数据的备份与恢复的方式有: 表,方案 ,数据库;     数据的备份: 导出到的常见命令; 参数 说明 USERID 确定执行导出实用程序的用户名和口令 BUFFER 确定导出数据时所使用的缓冲区大小，其大小用字节表示 FILE 指定导出的二进制文
  • 线程组 bijian1013 java多线程threadjava多线程线程组
    有些程序包含了相当数量的线程。这时，如果按照线程的功能将他们分成不同的类别将很有用。        线程组可以用来同时对一组线程进行操作。        创建线程组：ThreadGroup g = new ThreadGroup(groupName);  &nbs
  • top命令找到占用CPU最高的java线程 bijian1013 javalinuxtop
    上次分析系统中占用CPU高的问题，得到一些使用Java自身调试工具的经验，与大家分享。 (1)使用top命令找出占用cpu最高的JAVA进程PID:28174 (2)如下命令找出占用cpu最高的线程 top -Hp 28174 -d 1 -n 1 32694 root 20 0 3249m 2.0g 11m S 2 6.4 3:31.12 java
  • 【持久化框架MyBatis3四】MyBatis3一对一关联查询 bit1129 Mybatis3
      当两个实体具有1对1的对应关系时，可以使用One-To-One的进行映射关联查询   One-To-One示例数据 以学生表Student和地址信息表为例，每个学生都有都有1个唯一的地址(现实中，这种对应关系是不合适的，因为人和地址是多对一的关系)，这里只是演示目的   学生表   CREATE TABLE STUDENTS (
  • C/C++图片或文件的读写 bitcarter 写图片
    先看代码： /*strTmpResult是文件或图片字符串 * filePath文件需要写入的地址或路径 */ int writeFile(std::string &strTmpResult,std::string &filePath) { int i,len = strTmpResult.length(); unsigned cha
  • nginx自定义指定加载配置 ronin47
    进入 /usr/local/nginx/conf/include 目录，创建 nginx.node.conf 文件，在里面输入如下代码： upstream nodejs { server 127.0.0.1:3000; #server 127.0.0.1:3001; keepalive 64; } server { liste
  • java-71-数值的整数次方.实现函数double Power(double base, int exponent)，求base的exponent次方 bylijinnan double
    public class Power { /** *Q71-数值的整数次方 *实现函数double Power(double base, int exponent)，求base的exponent次方。不需要考虑溢出。 */ private static boolean InvalidInput=false; public static void main(
  • Android四大组件的理解 Cb123456 android四大组件的理解
     分享一下，今天在Android开发文档-开发者指南中看到的:                            App components are the essential building blocks of an Android
  • [宇宙与计算]涡旋场计算与拓扑分析 comsci 计算
         怎么阐述我这个理论呢？ 。。。。。。。。。       首先： 宇宙是一个非线性的拓扑结构与涡旋轨道时空的统一体。。。。       我们要在宇宙中寻找到一个适合人类居住的行星，时间非常重要，早一个刻度和晚一个刻度，这颗行星的
  • 同一个Tomcat不同Web应用之间共享会话Session cwqcwqmax9 session
    实现两个WEB之间通过session 共享数据 查看tomcat 关于 HTTP Connector 中有个emptySessionPath 其解释如下： If set to true, all paths for session cookies will be set to /. This can be useful for portlet specification impleme
  • springmvc Spring3 MVC，ajax，乱码 dashuaifu springjquerymvcAjax
      springmvc Spring3 MVC @ResponseBody返回，jquery ajax调用中文乱码问题解决   Spring3.0 MVC @ResponseBody 的作用是把返回值直接写到HTTP response body里。具体实现AnnotationMethodHandlerAdapter类handleResponseBody方法，具体实
  • 搭建WAMP环境 dcj3sjt126com wamp
    这里先解释一下WAMP是什么意思。W:windows，A：Apache，M：MYSQL，P：PHP。也就是说本文说明的是在windows系统下搭建以apache做服务器、MYSQL为数据库的PHP开发环境。      工欲善其事，必须先利其器。因为笔者的系统是WinXP，所以下文指的系统均为此系统。笔者所使用的Apache版本为apache_2.2.11-
  • yii2 使用raw http request dcj3sjt126com http
    Parses a raw HTTP request using yii\helpers\Json::decode()   To enable parsing for JSON requests you can configure yii\web\Request::$parsers using this class: 'request' =&g
  • Quartz-1.8.6 理论部分 eksliang quartz
    转载请出自出处：http://eksliang.iteye.com/blog/2207691 一.概述 基于Quartz-1.8.6进行学习，因为Quartz2.0以后的API发生的非常大的变化，统一采用了build模式进行构建； 什么是quartz?   答：简单的说他是一个开源的java作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。并且还能和Sp
  • 什么是POJO？ gupeng_ie javaPOJO框架Hibernate
    POJO--Plain Old Java Objects(简单的java对象)   POJO是一个简单的、正规Java对象，它不包含业务逻辑处理或持久化逻辑等，也不是JavaBean、EntityBean等，不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。   POJO对象有时也被称为Data对象，大量应用于表现现实中的对象。如果项目中使用了Hiber
  • jQuery网站顶部定时折叠广告 ini JavaScripthtmljqueryWebcss
    效果体验：http://hovertree.com/texiao/jquery/4.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>网页顶部定时收起广告jQuery特效 - HoverTree<
  • Spring boot内嵌的tomcat启动失败 kane_xie spring boot
    根据这篇guide创建了一个简单的spring boot应用，能运行且成功的访问。但移植到现有项目（基于hbase）中的时候，却报出以下错误：     SEVERE: A child container failed during start java.util.concurrent.ExecutionException: org.apache.catalina.Lif
  • leetcode: sort list michelle_0916 Algorithmlinked listsort
    Sort a linked list in O(n log n) time using constant space complexity. ====analysis======= mergeSort for singly-linked list  ====code=======   /** * Definition for sin
  • nginx的安装与配置,中途遇到问题的解决 qifeifei nginx
    我使用的是ubuntu13.04系统，在安装nginx的时候遇到如下几个问题，然后找思路解决的，nginx 的下载与安装   wget http://nginx.org/download/nginx-1.0.11.tar.gz tar zxvf nginx-1.0.11.tar.gz ./configure make make install   安装的时候出现
  • 用枚举来处理java自定义异常 tcrct javaenumexception
    在系统开发过程中，总少不免要自己处理一些异常信息，然后将异常信息变成友好的提示返回到客户端的这样一个过程，之前都是new一个自定义的异常，当然这个所谓的自定义异常也是继承RuntimeException的，但这样往往会造成异常信息说明不一致的情况，所以就想到了用枚举来解决的办法。 1，先创建一个接口，里面有两个方法，一个是getCode, 一个是getMessage public
  • erlang supervisor分析 wudixiaotie erlang
    当我们给supervisor指定需要创建的子进程的时候，会指定M,F,A,如果是simple_one_for_one的策略的话，启动子进程的方式是supervisor:start_child(SupName, OtherArgs),这种方式可以根据调用者的需求传不同的参数给需要启动的子进程的方法。和最初的参数合并成一个数组，A ++ OtherArgs。那么这个时候就有个问题了，既然参数不一致，那
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他