精华内容
下载资源
问答
  • HashSet使用

    2018-07-23 13:45:10
    HashSet使用 1.HashSet 特点:  1.无序,不可重复  2.容量自动增长。   2.存储原理:  向Set中添加对象时,首先调用此对象所在类的hashCode()方法,计算次对象的哈希值,  此哈希值决定了此对象在Set中存放的...

    HashSet使用
    1.HashSet 特点:
        1.无序,不可重复
        2.容量自动增长。
        
    2.存储原理:
        向Set中添加对象时,首先调用此对象所在类的hashCode()方法,计算次对象的哈希值,
        此哈希值决定了此对象在Set中存放的位置;若此位置没有被存储对象则直接存储,
        若已有对象则通过对象所在类的equals()比较两个对象是否相同,相同则不能被添加。
        
        添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。
        要求重写equals() 和 hashCode()方法保持一致。

    3.使用场景:
       所有的技术都是为了转化为生产力,所以要知道如何取使用技术
       如购物车对象转化为订单对象,获取购物车不重复的库存地址
       
    4.hashSet没有get方法,所以遍历的时候,有两种方法,一种是通过迭代器,一种是通过增强for循环

    例子

    没有重写equals()和hashCode类添加相同元素,可以添加进去:

    package test;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    public class TestSet {
    	
         public static void main(String[] args){
        	  Set<Person> set = new HashSet<>();
        	  set.add(new Person(1, 1));
        	  set.add(new Person(1, 3));
        	  set.add(new Person(1, 1));
        	//  1.迭代器
        	  Iterator iterator = set.iterator();
        	  while (iterator.hasNext()) {
    			Person person = (Person) iterator.next();
    			System.out.println("迭代器:"+person);
    		} 	 
         }
    
    }
    

        结果:

               迭代器:Person [x=1, y=3]
               迭代器:Person [x=1, y=1]
              迭代器:Person [x=1, y=1]

    重写了equals()方法和hashCode()后

    package test;
    
    public class Person {
        private  int x;
        private  int y;
    	public int getX() {
    		return x;
    	}
    	public void setX(int x) {
    		this.x = x;
    	}
    	public int getY() {
    		return y;
    	}
    	public void setY(int y) {
    		this.y = y;
    	}
    	@Override
    	public String toString() {
    		return "Person [x=" + x + ", y=" + y + "]";
    	}
    	public Person(int x, int y) {
    		super();
    		this.x = x;
    		this.y = y;
    	}
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + x;
    		result = prime * result + y;
    		return result;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (x != other.x)
    			return false;
    		if (y != other.y)
    			return false;
    		return true;
    	}  
           
    	
    }
    
    package test;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    public class TestSet {
    	
         public static void main(String[] args){
        	  Set<Person> set = new HashSet<>();
        	  set.add(new Person(1, 1));
        	  set.add(new Person(1, 3));
        	  set.add(new Person(1, 1));
        	//  1.迭代器
        	  Iterator iterator = set.iterator();
        	  while (iterator.hasNext()) {
    			Person person = (Person) iterator.next();
    			System.out.println("迭代器:"+person);
    		} 	 
            /*  2.增强for循环
             * for(Person p:set){
            	 System.out.println(p);
             }*/
        	  
         }
    
    }
    

    结果:

           迭代器:Person [x=1, y=1]
           迭代器:Person [x=1, y=3]

    所以一定要重写equals()和hashCode()方法


    Set接口有两个子类:HashSet和TreeSet 。
    |-  HashSet
        |-  特点:在不存在重复元素的基础上,还可以进行高速的存取元素。
         |-  要求:需要为您的类重写hashCode()和equals()方法。
    |-  TreeSet
        |-  特点:在不存在重复元素的基础上,还可以将元素自动排序。
         |-  要求:需要为您的类实现Comparable接口,并重写compareTo方法。  
        |-  重写compareTo() 可以同时完成两份工作   排序和消除重复。

    展开全文
  • HashSet

    2019-03-14 19:53:29
    与HashMap相同,...HashSet应用场景: 1、 排重 2、 保存特殊值,比如保存用户黑白名单,来判断用户是否有某权限 3、集合运算,,set可以方便的进行交集,并集等运算 HashSet的内部实现 HashSet内部是用一个...

    与HashMap相同,HashSet也要求元素重写hashCode和equals方法,且对于两个对象如果equals相同,则hashCode也必须相同,如果元素是自定义类,需要注意这一点。
    HashSet的应用场景:
    1、 排重
    2、 保存特殊值,比如保存用户黑白名单,来判断用户是否有某权限
    3、集合运算,,set可以方便的进行交集,并集等运算

    HashSet的内部实现

    HashSet内部是用一个HashMap实现的:

        private transient HashMap<E,Object> map;
    

    HashSet相当于只有键,值都是相同的值:

        // Dummy value to associate with an Object in the backing Map
        private static final Object PRESENT = new Object();
    

    基于这个内部组成,他的实现就很好懂了:

        public HashSet(int initialCapacity, float loadFactor) {
            map = new HashMap<>(initialCapacity, loadFactor);
        }
    
        public HashSet(Collection<? extends E> c) {
            map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
            addAll(c);
        }
    

    c.size()/.75f 用来计算loadFactor的默认值;

        public boolean add(E e) {
            return map.put(e, PRESENT)==null;
        }
    

    add方法就是直接调用map的put方法;

        public boolean contains(Object o) {
            return map.containsKey(o);
        }
    
    

    contains就是直接调用map的containsKey方法

        public boolean remove(Object o) {
            return map.remove(o)==PRESENT;
        }
    
        public Iterator<E> iterator() {
            return map.keySet().iterator();
        }
    
    

    remove和iterator方法也是直接是用的map的方法,简单的超乎想象。

    特点小结:
    1、 没有重复元素
    2、可以高效的添加、删除元素、判断元素是否存在,效率为O(1)
    3、 没有顺序
    如果要保持添加的顺序,可以是用HashSet的子类:LinkedHashSet。Set还有一个重要的实现类TreeSet,他可以进行排序。

    展开全文
  • Hashset

    2021-04-11 12:25:51
    Hashset HashSet 无序,去重 ​ 底层结构: 哈希表(数组+链表+红黑树) ​ 特点: ​ 做查询,增删效率较高 ​ 无序去重 ​ 初始容量: 16 ​ 加载因子: 0.75 ->扩容的临界点 ​ 扩容的临界点 = 容量加载因子; ​ 12 = ...

    Hashset

    HashSet 无序,去重

    ​ 底层结构: 哈希表(数组+链表+红黑树)

    ​ 特点:
    ​ 做查询,增删效率较高
    ​ 无序去重

    ​ 初始容量: 16
    ​ 加载因子: 0.75 ->扩容的临界点

    ​ 扩容的临界点 = 容量加载因子;
    ​ 12 = 16
    0.75; 当存储的数据到12就扩容

    HashSet 与 TreeSet之间的选择
    如果想要数据存储的时候默认升序|降序->TreeSet
    否则建议选择HashSet

    构建一个HashSet 存储字符串类型的数据,做基本操作行为,然后遍历
    构建一个HashSet 存储自定义引用数据类型的数据,做基本操作行为,然后遍历

    TreeSet

    TreeSet
    默认升序,去重
    红黑树

    当方法|构造器参数为接口类型的时候,实参可以考虑是否可以通过一个Lambda表达式进行传递

    lambda可以让行为作为参数|数据传递,配合函数式接口,可以让定义与实现变的更加简单灵活

    Arrays工具类 操作数组的工具类
    练习:
    定义一个User类型的数组,使用Arrays.sort方法对这个数据做升序排序
    排序规则: 要求按照用户编号降序排序
    排序规则: 要求按照用户员工的余额升序排序
    分别打印
    static void sort 根据元素的natural ordering ,将指定的对象数组按升序排序。
    static void sort 根据指定比较器引发的顺序对指定的对象数组进行排序。

    public class SetDemo01 {
        public static void main(String[] args) {
            //匿名内部类   简化实现类IMPL
            Comparator<Person> com = new Comparator<Person>(){
    
                @Override
                public int compare(Person o1, Person o2) {
                    return o2.getAge() - o1.getAge();
                }
            };
    
            //Lambda
            com = (Person o1, Person o2)->{
                return o1.getAge() - o2.getAge();
            };
    
            //指定使用外部比较规则
            //TreeSet<Person> tree= new TreeSet<Person>(com);
            TreeSet<Person> tree= new TreeSet<Person>((Person o1, Person o2)->{
                return o1.getAge() - o2.getAge();
            });
    
            tree.add(new Person("胡歌",35));
            tree.add(new Person("大表哥",30));
            tree.add(new Person("金城武",34));
            tree.add(new Person("谢霆锋",30));
    
            System.out.println(tree);
    
    
    
        }
    }
    
    //外部比较器
    class Impl implements Comparator<Person>{
    
        @Override
        public int compare(Person o1, Person o2) {
            return o1.getAge() - o2.getAge();
        }
    }
    

    LinkedList

    LinkedList 有序可重复
    底层结构: 双向链表
    特点:
    增删效率较高
    根据索引查询,遍历,修改效率低
    应用场景: 在大量做增删,少量做查询的位置适合使用LinkedList

    ​ 新增: 新增了一些操作链表头尾的方法

    ​ 练习: 使用LinkedList存储自定义引用数据类型的数据,并操作练习

    public class ListDemo01 {
        public static void main(String[] args) {
            LinkedList<String> linked = new LinkedList<>();
            linked.add("haha");
            linked.add("hehe");
            linked.add("heihei");
            linked.add("houhou");
            linked.add("xixi");
            //新增方法
            //void addFirst(E e) 在此列表的开头插入指定的元素。
            //void addLast(E e) 将指定的元素追加到此列表的末尾。
            System.out.println(linked);
    
            linked.addFirst("first");
            linked.addLast("last");
            System.out.println(linked);
    
            //E element() 检索但不删除此列表的头部(第一个元素)。
            System.out.println(linked.element());
        }
    }
    
    /*
        手写LinkedList
            使用单向链表实现
    
            思考实现:
                根据索引修改,查询
     */
    public class MyLinkedListDemo02 {
        public static void main(String[] args) {
            MyLinkedList list = new MyLinkedList();
    
            //list.add("数据");
            System.out.println(list.size());
            //list.add("haha");
            System.out.println(list.size());
            System.out.println(list);
        }
    }
    
    //自定义容器类型: MyLinkedList
    class MyLinkedList{
        //链表头节点
        private Node head;
        //长度
        private int size;
    
        public MyLinkedList() {
        }
    
        /*
            添加
         */
        public void add(Object value) {
            //创建新节点
            Node node = new Node(value,null);
            //判断是不否存在链表头节点
            if(head==null && size==0){
                head = node;  //新节点就是链表头节点
            }else{
                //存在原链表,遍历原链表,找到最后一个节点,新节点的地址记录
                Node temp = head;  //temp指向链表头节点,后面使用temp操作遍历指向每一个节点,直到最后一个
                while(temp.getNext()!=null){
                    temp = temp.getNext();
                }
                temp.setNext(node);  //把新节点挂在原链表的最后
            }
            size++;
        }
    
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("[");
            //1.临时变量,指向链表中的每一个节点
            Node temp = head;
    
            //获取每一个节点的值value
            while(true){
                //结束条件
                if(temp==null){
                    break;
                }
                sb.append(temp.getValue()); //数据的拼接
                sb.append(","); //数据的拼接
                temp = temp.getNext();  //指向新节点
    
            }
            //StringBuilder replace(int start, int end, String str) 使用指定的 String的字符替换此序列的子字符串中的字符。
            if(sb.length()==1){
                sb.append("]");
            }else{
                sb.replace(sb.length()-1,sb.length(),"]");
            }
            //拼接成字符串返回
            return sb.toString();
        }
    
        public int size(){
            return this.size;
        }
    }
    
    //节点
    class Node{
        private Object value;  //数据
        private Node next;  //下一个节点对象的地址
    
        public Node() {
        }
    
        public Node(Object value, Node next) {
            this.value = value;
            this.next = next;
        }
    
        public Object getValue() {
            return value;
        }
    
        public void setValue(Object value) {
            this.value = value;
        }
    
        public Node getNext() {
            return next;
        }
    
        public void setNext(Node next) {
            this.next = next;
        }
    
        @Override
        public String toString() {
            return "Node{" +
                    "value=" + value +
                    ", next=" + next +
                    '}';
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Node node = (Node) o;
            return Objects.equals(value, node.value) &&
                    Objects.equals(next, node.next);
        }
    
    }
    

    HashMap

    HashMap
    HashSet --> HashMap
    底层结构:
    哈希表(数组+链表+红黑树)
    特点:
    存储键值对类型数据
    无序,根据key做去重
    查询,修改,删除,增加效率较高

    Hash表存储原理:
    哈希表: Node节点数组,存储节点数据 节点:key,value,hash,next
    1.put(key,value)存储键值对类型的数据
    根据key计算hash值,确定桶的位置
    2.找到Node数组中的指定索引位置,判断当前位置中是否存在数据,没有存在直接构建一个Node节点对象 new Node(key,value,hash,null),放入数组
    如果已经存在值,就比较每一个Node的key与我当前要存储的key是否相等,相等value覆盖,不相等继续判断,最后数据放入链表的最后

    默认初始容量: 1<<4 16-> 数组长度
    加载因子 : 0.75
    最大容量… 1<<30
    扩容: 新数组的容量为原容量的2倍 newCap = oldCap << 1
    当添加的数据个数>=原数组长度*0.75的时候,就扩容,扩容的是数组的大小

    HashMap存储key如果为自定义引用数据类型:
    key去重的问题 : key类型中要求重写hashcode与equals方法

    Map<K,V>
    接口
    存储键值对的数据
    k-v 一个映射关系
    key->value
    key与value可以为任意类型的一个数据
    一个key只能对应一个value
    key是唯一的,无序的 --> Set集合
    value是无序可重复的 --> Collection 无序可重复

    遍历方式:
    Set keySet() 返回所有的key,通过key获取value
    Collection values() 获取集合中的所有value值,无法获取key
    Set<Map.Entry<K,V>> entrySet()

    public class MapDemo01 {
        public static void main(String[] args) {
            Map<Integer,String> map = new HashMap<>();
            //V put(K key, V value)  添加一个键值对数据,如果key重复,value会覆盖,返回被覆盖的value值,如果key不重复,返回null
            System.out.println(map.put(101,"张三"));
            System.out.println(map.put(103,"wangwu"));
            System.out.println(map.put(102,"lisi"));
            System.out.println(map.put(101,"zhangsan"));
            System.out.println(map.put(104,"zhangsan"));
    
            System.out.println(map);
    
            //V get(Object key)  根据key获取value,没有返回null
            System.out.println(map.get(108));
    
    
            //int size()
            System.out.println(map.size());
    
            //boolean containsKey(Object key) 如果此映射包含指定键的映射,则返回 true 。
            //boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值,则返回 true 。
            System.out.println(map.containsKey(101));
            System.out.println(map.containsValue("zhangsan"));
    
            //V remove(Object key) 如果存在,则从该映射中移除键的映射(可选操作)。
            System.out.println(map.remove(102));
            System.out.println(map);
    
            //default V replace(K key, V value) 仅当指定键当前映射到某个值时,才替换该条目的条目。
            System.out.println(map.replace(101,"zhangsanfeng"));
            System.out.println(map);
    
            //default boolean replace(K key, V oldValue, V newValue) 仅当前映射到指定值时,才替换指定键的条目。
            System.out.println(map.replace(101,"zhangsan","hahaha"));
            System.out.println(map);
    
            //遍历
            System.out.println("-------- Set<K> keySet()  返回所有的key,通过key获取value-------------");
            Set<Integer> set = map.keySet();
            //1)foreach   2)iterator
            for(Integer t:set){
                System.out.println(t+"-->"+map.get(t));
    
    
            }
            System.out.println("-------------Collection<V> values() 获取集合中的所有value值,无法获取key------");
            Collection<String> col = map.values();
            //1)foreach   2)iterator
            Iterator<String> it = col.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
    
            System.out.println("------- Set<Map.Entry<K,V>> entrySet() ------------");
            Set<Map.Entry<Integer,String>> entrys = map.entrySet();
            for(Map.Entry<Integer,String> entry:entrys){
                System.out.println(entry.getKey()+"-->"+entry.getValue());
            }
    
        }
    
    }
    
    public class MapDemo02 {
        public static void main(String[] args) {
            Map<Integer,String>  map  =  new HashMap<>();
            System.out.println(map.put(100,"张三"));
            System.out.println(map.put(102,"李四"));
            System.out.println(map.put(103,"王五"));
            System.out.println(map.put(104,"赵六"));
            System.out.println(map.put(105,"田七"));
            System.out.println(map.put(106,"勾八"));
            System.out.println(map);
    
            System.out.println(map.get(100));
    
            System.out.println(map.size());
    
    
            //boolean containsKey(Object key) 如果此映射包含指定键的映射,则返回 true 。
            //boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值,则返回 true 。
            System.out.println(map.containsKey(105));
            System.out.println(map.containsValue("勾八"));
    
            //default boolean replace(K key, V oldValue, V newValue) 仅当前映射到指定值时,才替换指定键的条目。
            System.out.println(map.replace(103,"王五","牛逼"));
            System.out.println(map);
    
            //遍历
            System.out.println("-------- Set<K> keySet()  返回所有的key,通过key获取value-------------");
    
            Set<Integer> set = map.keySet();
            for (Integer i:set) {
                System.out.println(i+"-->"+map.get(i));
    
            }
            System.out.println("-------------Collection<V> values() 获取集合中的所有value值,无法获取key------");
            Collection<String> col = map.values();
    
            Iterator<String> it =  col.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
    
            System.out.println("------- Set<Map.Entry<K,V>> entrySet() ------------");
    
            Set<Map.Entry<Integer,String>> entrys =  map.entrySet();
            for (Map.Entry<Integer,String> entry:entrys) {
                System.out.println(entry.getKey()+"-->"+entry.getValue());
    
            }
    
    
    
        }
    }
    
    展开全文
  • 集合之HashSet应用思路

    2018-12-20 14:21:51
    集合之HashSet应用思路 一、为什么要重写hashcode和equals两个方法 我们都知道Java语言是完全面向对象的,在java中,所有的对象都是继承于Object类。Ojbect类中有两个方法equals、hashCode,这两个方法都是用来...

                                         集合之HashSet应用思路

     

    一、为什么要重写hashcode和equals两个方法

    我们都知道Java语言是完全面向对象的,在java中,所有的对象都是继承于Object类。Ojbect类中有两个方法equals、hashCode,这两个方法都是用来比较两个对象是否相等的。

    在未重写equals方法我们是继承了object的equals方法那里的 equals是比较两个对象的内存地址,显然我们new了2个对象内存地址肯定不一样

    • 对于值对象,==比较的是两个对象的值
    • 对于引用对象,比较的是两个对象的地址

    默认的equals方法同==,但是一般来说我们的对象都是引用对象,要重写equals方法(将对象地址比较重写为对象的值比较)。

    所以如果我们对equals方法进行了重写,建议一定要对hashCode方法重写,以保证相同的对象返回相同的hash值,不同的对象返回不同的hash值。

     

    二、在什么情况下需要重写hashcode和equals两个方法

    想要搞清楚什么情况下重写hashcode和equals方法就的先知道集合在项目中使用场景。

    1、集合在项目中使用的场景:首先用户在前端页面填写一个用户信息表单提交(用户表单的会员ID要求不能重复)--------请求通过post方式调用java服务端代码-----服务端的hashset代码在执行add()添加方法的时候就会调用hashcode和equals两个方法判断会员ID是否已存在(所以如果我们对equals方法进行了重写,同时一定要对hashCode方法重写),如果存在则不添加,不存在就将数据添加到数据库。

    三、HashSet应用实例

    现在有一个学生类登记表单填写,ID、学号、姓名(要求ID不能重复)。HashSet存放Student类对象,需要判断Student对象里面的ID是否存在。这个时候就需要在Student类中将hashcode和equals方法对ID进行判断进行重写。

    1hashcode和equals方法重写在IEDA中生成的快捷方法

     

    2、代码示例

    package day15;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Objects;
    import java.util.Set;
    
    class Student extends  Object{
        public long id;
        public String sn;//学号
        public String name;
    
        @Override
        //1、重写equals方法对ID对象值是否相等进行判断
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            Student student = (Student) o;
    
            return id == student.id;
        }
    
        @Override
        //2、重写hashCode方法对ID对象值是否相等进行判断
        public int hashCode() {
            return (int) (id ^ (id >>> 32));
        }
    }
    public class SetDemo2 {
        public static void main(String[]args){
            //3、实例化HashSet类的对象
            Set set = new HashSet();
            //4、实例化Student对象
            Student e = new Student();
            //5、添加Student对象属性值
            e.id = 001;
            e.name = "张三";
            e.sn = "s1";
            //6、将Student对象添加到HashSet集合中
            ((HashSet) set).add(e);
    
            System.out.println("=====================第一次集合添加对象的值输出=======================");
            System.out.println(e.id+e.name+e.sn);
    
    
            //7、Student对象再次添加ID和第一次添加ID值一样
            Student e2 = new Student();
            e2.id = 001;
            e2.name = "李四";
            e2.sn = "s2";
            //8、boolean值判断第二次添加已存在的ID值是否存到set集合中
            boolean b = set.add(e2);
            System.out.println("======================第二次ID是否添加到Set集合中===============:"+b);
    //9、Iterator和数组两种方式遍历集合输出对象
            System.out.println("==================Iterator和数组两种方式遍历集合输出对象===================");
            //10、Iterator输出HashSet集合中对象的值。
            Iterator it = set.iterator();   //set调用iterator方法
            while (it.hasNext()){
                Student s = (Student) it.next();    //Iterator类型转换成Student类型调用Student类中的方法。
                System.out.println("===========Iterator方式输出HashSet集合对象存储的值:"+s.id+","+s.name+s.sn);
            }
    
            //11、数组方式输出HashSet集合中的对象的值
            Object[] obj = set.toArray();
            for(int i=0;i<obj.length;i++){
                Student  s = (Student)obj[i]; //Obj类型转换成Student类型调用Student类中的方法。
    
                System.out.println("---------数组方式输出HashSet集合对象存储的值:"+s.id+","+s.name+","+s.sn);
            }
        }
    }
    

     

    结果:

     

    展开全文
  • 《java编程的逻辑》读书笔记 HashMap 主要实例变量: ...transient Entry,V>[] talbe = ...如果要保持添加的顺序,可以使用HashSet的一个子类,LinkedHashSet。Set还有一个重要的 实现类TreeSet,它可以排序。
  • 应用场景:数据去重复 Application:Data removal duplication 继承关系:HashSet继承于AbstractSet,AbstractSet继承于AbstractCollection实现了Set,克隆,有序化接口. Extend relationship:HashSet extends ...
  • 随机产生10万个数据,数据范围在1~1000,统计每个数据出现的次数?... -》HashSet HashMap 3、找出出现次数最多的数据并打印?-》HashMap 4、打印全部数据,重复性元素只打印一次; -》HashSet ...
  • 1.HashSet和HashMap在高并发场景下也会报java.util.ConcurrentModificationException异常 2.解决办法: Set s= new CopyOnWriteArraySet<>(); private final CopyOnWriteArrayList<E> al; /** * ...
  • hashset踩坑

    2019-08-21 15:26:40
    使用hashset去重: 源码如上,可以看到hashSet的add方法调用的是HashMap的put的方法,而put方法返回的是上一个value值,把这个值是否为空作为方法返回!这样根据add的返回值就可以判断是否重复! 但是每次调用的...
  • HashSet<String> set = new HashSet(); Iterator<String> iter = set.iterator(); 2.开始迭代 while (iter.hasNext()) {// 判断迭代器中是否还有元素 String str = iter.next();// 取出一个元素,取出一个,...
  • HashSet源码

    2020-02-24 18:56:52
    1、HashSet介绍 与HashMap类似,字面上看,HashSet由两个单词组成:Hash和Set。其中,Set表示接口,实现Set接口也有多种方式,各有特点,HashSet实现的方式利用了Hash Set public interface Set<E> extends ...
  • Java HashSet

    2017-02-28 09:37:16
    容器实现了Set接口,后端由hash table支持.每次在迭代的时候,容器不保证迭代遍历的顺序.可以存储null元素. ...因此,在性能非常重要的场景下,不适合于将HashSet的初始capacity设置的过大或者装载因子过低. 同样
  • HashSet 存储结构,应用场景,实现原理
  • 一般用于对健值对方式快速查询的使用场景。但是线程不安全,线程的安全的话可以使用tableMap,但tableMap的锁太重,因此可以使用ConcurretHashMap采取分段锁的方式性能更搞。 HashMap无序,如果要有序遍历的情况可以...
  • HashSet 是一个优化过的无序集合,提供对元素的高速查找和高性能的set集合操作,而且 HashSet 是在 .NET 3.5 中被引入的,在 System.Collection.Generic 命名空间下,这篇就来讨论一下如何使用这个 HashSet。...
  • 深度剖析HashSet

    万次阅读 2020-12-05 13:02:29
    HashSet是Java集合Set的一个实现类,Set是一个接口,其实现类除HashSet之外,还有TreeSet,并继承了Collection,HashSet集合很常用,同时也是程序员面试时经常会被问到的知识点 我就没见过这么不要脸的数据结构,...
  • HashSet源码分析

    2011-12-03 10:39:03
    HashSet是Set的一个实现,Set定义一个集合,集合的一个特征是不能包含重复的元素(可以包含null),HashSet底层使用HashMap作为存储结构来实现。    可知HashSet只用来存储对象,并不是key-value对,因为HashMap中...
  • Redis:HyperLogLog使用应用场景

    万次阅读 2018-08-19 00:38:15
    本文介绍redis的HyperLogLogde 命令使用和其他统计方式以及应用场景。 本文最后记录了HyperLogLog算法相关参考链接 简介 基数计数的演进 使用一般集合或数据结构来处理如HashSet或B+树 bitmap 概率算法 算法...
  • HashSet基本操作

    2019-09-18 00:04:46
    ** 1.HashSet的添加时的...**1.1 **重要:需要去重的对象必须做到覆盖Object的equals和hashcode方法,具体实现需要根据业务场景来定. **1.2 **HashSet 会首先调用 obj 的 hasCode 方法得到该对象的哈希码,HashSet 会...
  • HashSet学习笔记

    2021-08-09 21:48:08
    文章目录tips构造方法迭代器方法 tips HashSet是依赖于HashMap的一种Set接口的实现。不能保证在对set进行迭代时的顺序,...当再多线程场景使用时,建议在创建对象时使用以下方法: Set s = Collections.synchroni
  • Java集合之HashSet

    2017-08-04 14:58:14
    HashSet
  • ArrayList与LinkedList的区别和适用场景 Arraylist: 优点:ArrayList是实现了基于动态数组的数据结构,因为地址连续,一旦数据存储好了,查询操作效率会比较高(在内存里是连着放的)。 缺点:因为地址连续, ...
  • import java.util.HashSet; import java.util.Set; import java.util.TreeSet; /* set 里的方法和list相同 * HashSet 无序不可重复 (因为底层实现的是HashMap,hashMap是无序的) * (为什么是不可重复的呢? ...
  • Set判断两个对象相同不是使用==运算符,而是根据equals方法。也就是说,只要两个对象用equals方法比较返回true,Set就不 会接受这两个对象。HashSet HashSet有以下特点  不能保证元素的排列顺序,顺序有可能发生...
  • HashSet 源码解析

    2018-01-08 00:22:27
    HashSet ,是在HashMap的基础之上保持这一特性,并且拥有自身的特点(如果对于HashMap忘了,或者不了解,可以先了解HashMap , 否则,是无法准确地了解HashSet的原理。所以此篇文章是基于了解一些HashMap特性的) ...
  • HashSet:实现了Set接口的一个类。 90、 关于 Object 类的 equals 方法的特点 a) 自反性:x.equals(x)应该返回 true b) 对称性:x.equals(y)为 true,那么 y.equals(x)也为 true。 c) 传递性:x.equals(y)为...
  • Java HashSet用法详解

    2020-09-07 10:35:17
    HashSet基于HashMap来实现的,是一个不允许有...HashSet类位于java.util包中,使用前需要引入它,语法格式如下: import java.util.HashSet;//引入HashSetHashSet的创建及常用操作如下: //引入HashSet类 im

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,227
精华内容 13,290
关键字:

hashset应用场景