精华内容
下载资源
问答
  • 对于TreeSet和TreeMap来说,元素应该无序(指元素的存取)而不是有序的,而在表中它可能想表达的可以排序,不够严谨,严格来讲 元素的有序≠可以排序。元素的存取有序和排序本质上应该两码事,不应该混为一听...

    最近在整理Java基础知识的面试题,看到了一个题目的答案不够准确,这里跟大家分享一下。

    一、面试题的小错误

     对于TreeSet和TreeMap来说,元素应该是无序(指元素的存取)而不是有序的,而在表中它可能想表达的是可以排序,不够严谨,严格来讲

    元素的有序≠可以排序。元素的存取有序和排序本质上应该是两码事,不应该混为一听。

    二、元素的有序和无序

       下面具体来讲讲,集合中元素的存取有序的问题。 

      众所周知,List的特点:    ①元素可重复 ②元素是有序的

      相对地,Set的特点是:    ①元素唯一    ②元素是无序的

      首先,我们来明确这里的有序/无序的准确定义。

      有序是指元素的存取顺序是一致的,即你以什么顺序将元素存入List,比如1,3,4,13,那么取(遍历)出来的顺序也是1,3,4,13。

      无序是指元素的存取顺序是不一致的(这里注意,事实上会有小概率可能,你可能碰巧发现你的set中元素的存取顺序很巧合地一致了,不符合这个定义了,那么set中的元素究竟是不是一致的呢?我们下面会讲解)

     三、具体例子

      ①List

      List中元素的存取是有序的,有序很好理解,比如一个数组arr(以ArrayList为例),该数组的输出顺序是跟你存入(add)的顺序是一致的,为 15 , 2, 3, 9。

    import java.util.ArrayList;
    import java.util.List;
    public class Test {
    
        public static void main(String[] args) {
              List<Integer> arr=new ArrayList();
                arr.add(15);
                arr.add(2);
                arr.add(3);
                arr.add(9);
                 for(int a:arr) {
                System.out.println(a);
            }
        // 输出结果   15   2    3   9 
         //arraylist的元素存取是有序的
        }
    }

     ②Set

    import java.util.HashSet;
    import java.util.Set;
    
    public class Test {
    
    	public static void main(String[] args) {
    		Set<Integer> set=new HashSet();
    		set.add(122);
    		set.add(234);
    		set.add(2);
    		set.add(12);
    for(Integer s:set) { System.out.println(s+" "+s.hashCode()); } // 输出为 2 122 234 12 //HashSet是元素无序的 } }

      Set中元素的存取是无序的。那么为什么会出现小概率的“有序”情况呢?

      以HashSet来讲,HashSet的底层是Hash表,我们每次add元素进去后,每个元素将调用hashcode方法(匹配1个Hash函数)得到一个对应的hashcode值,然后根据这个hashcode值在hash表中对应的位置存入元素。举例来说,我们现在存的顺序是123,22,12,3。而取出来的时候是按照这些元素在Hash表中的真正的存储位置顺序(或者逆序或者某种规则)遍历,所以便会出现存取顺序不一致的情况。也就是说,Hash表内部的排序是根据hash值而不是add的先后顺序来排序的,而上面出现的特殊情况,也就是说正好你的元素的add顺序和它对应的Hash值在Hash表中的排列顺序刚好一致,让你感觉上好像变成有序了。其实,从Hash表的角度上来讲,HashSet中元素的存取并不是完全无序(随机)的,只不过它是按照自己的规则来存入和输出元素(Hash表中的Hash值的大小顺序)。

      同理,对于TreeMap来说,其底层为红黑树。add元素的先后顺序并不重要,真正的存储顺序是按照二叉树的规则存储的,所以最后遍历都是自然排序后的输出。

    四、总结

      最后总结:从本质上讲,List和Set内元素有序/无序的核心区别

      List的元素有序是因为它的底层是线性结构的数组(或者链表),元素的存取是和add的先后(时间)次序有关的——本质上与时间相关

      Set的元素无序是因为它的底层是非线性结构的哈希表/二叉树,元素的存取是和add的先后(时间)顺序无关的——你先add还是后add,都是存在Hash表中的同一个位置/在二叉树中,无论你先add还是后add,最后都输出的是排序(默认自然排序)后的数组——本质上和时间无关

     

      

    转载于:https://www.cnblogs.com/12three/p/11483556.html

    展开全文
  • 最近写到一个程序,返回了map,但是经过查阅资料,map没有顺序的,各种查阅资料无果,最后自己写了这个方法。。 1,通过map集合的keySet()方法,获取到一个包含map所有key的Set集合 2,定义一个新的TreeSet集合...

    最近写到一个程序,返回了map,但是经过查阅资料,map是没有顺序的,各种查阅资料无果,最后自己写了这个方法。。

    1,通过map集合的keySet()方法,获取到一个包含map所有key的Set集合

    2,定义一个新的TreeSet集合(TreeSet集合有自动排序功能)

    3,将第一步得到的Set集合遍历赋给TreeSet集合,这样所有key都排好序并保存在TreeSet里面

    4,然后通过TreeSet的迭代器遍历,并同时根据迭代器返回的key,一个一个取出map里面的value

    ----------------------------------------------------------------代码示例------------------------------------------------------------------------------

     

    Map<Integer, String> oldMap=new HashMap<Integer,String>();//待排序的map集合
    Map<Integer, String> newMap=new HashMap<Integer,String>();//排序后的map集合
    Set<Integer> keySet = oldMap.keySet();//存放key的set集合
    TreeSet<Integer> keyTreeSet = new TreeSet<Integer>();//存放key排序后的set集合
    Iterator<Integer> itKeySet;//Set集合的迭代器
    Iterator<Integer> itKeyTreeSet;//TreeSet集合的迭代器

      //放入一些测试数据   oldMap.put(1, "content1"); oldMap.put(5, "content5"); oldMap.put(6, "content6"); oldMap.put(10, "content10"); oldMap.put(11, "content11"); oldMap.put(100, "content100"); oldMap.put(999, "content999"); keySet=oldMap.keySet();//获取map的所有key itKeySet=keySet.iterator(); while (itKeySet.hasNext()) {   Integer key = (Integer) itKeySet.next();   System.out.print(key+" ");//打印排序前key的顺序     keyTreeSet.add(key); } System.out.println("\n"); itKeyTreeSet=keyTreeSet.iterator(); while (itKeyTreeSet.hasNext()) {   Integer key = (Integer) itKeyTreeSet.next();   System.out.print(key+" ");//打印一下排序后key的顺序     newMap.put(key, oldMap.get(key));//此时根据排序好的TreeSet挨个取出Map里面的value,此处我只是放到了一个newMap中 }

     

     

     

    打印key结果如下所示

     

    转载于:https://www.cnblogs.com/convict/p/8318352.html

    展开全文
  • Java中哪些集合是有序的

    千次阅读 2019-12-05 21:22:48
    Java中哪些集合是有序的? 实现了 List 接口的集合类全部有序:比如ArrayList、LinkedList LinkedHashMap:在 HashMap 的基础上多维护了一个双向链表。 ConcurrentSkipListMap:基于跳表实现,跳表内所有的元素都是...

    Java中哪些集合是有序的?

    • 实现了 List 接口的集合类全部有序:比如ArrayList、LinkedList
    • LinkedHashMap:在 HashMap 的基础上多维护了一个双向链表。
    • ConcurrentSkipListMap:基于跳表实现,跳表内所有的元素都是排序的。
    • TreeMap:基于红黑树实现。
    • TreeSet:基于TreeMap实现。
    哪些 Map 是有序的?
    • LinkedHashMap
    • ConcurrentSkipListMap
    • TreeMap
    展开全文
  • import java.util.ArrayList; import java.util.Iterator;...* 描述:有两个有序的集合集合的每个元素一段范围,求其交集, * 例如交集{[4,8],[9,13]}和{[6,12]}的交集{[6,8],[9,12]} * * 两个有序的集...
    package com.tulun;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    /**  
    * 描述:有两个有序的集合,集合的每个元素都是一段范围,求其交集,
    * 例如交集{[4,8],[9,13]}和{[6,12]}的交集是{[6,8],[9,12]} 
    *
     * 两个有序的集合,集合的每个元素都是一段范围,求其交集
     * 所求交集结果直接打印到输出终端
     * @param collects1:集合1
     * @param collects2:集合2
     *
    
    *  
    * @author ASUS  
    * @date 2018年8月4日
    */
    public class TestGY1 {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		//测试题中给的数据是否正确
    		List <List <Integer>> collection1 = new ArrayList <List <Integer>>();
            ArrayList <Integer> list11 = new ArrayList <>();
            list11.add(4);
            list11.add(8);
            collection1.add(list11);
    
            ArrayList <Integer> list12 = new ArrayList <>();
            list12.add(9);
            list12.add(13);
            collection1.add(list12);
    
            ArrayList <List <Integer>> collection2 = new ArrayList <>();
            ArrayList <Integer> list21 = new ArrayList <>();
            list21.add(6);
            list21.add(12);
            collection2.add(list21);
            
            intersectionWithColletion(collection1,collection2);
    	}
    	
    	//最终的交集
    	public static void intersectionWithColletion(List<List<Integer>> collects1, List<List<Integer>> collects2) {
            //参数校验
            if (!(isVaild(collects1) && isVaild(collects2))) {
                return;
            }
              //把每个集合中的小集合都与其他的做交集判断
            Iterator <List <Integer>> iterator1 = collects1.iterator();
            while (iterator1.hasNext()) {
                List <Integer> list1 = iterator1.next();
                Iterator <List <Integer>> iterator2 = collects2.iterator();
                while (iterator2.hasNext()) {
                    List <Integer> list2 = iterator2.next();
                    intersection(list1, list2);
                }
            }
    	}
    	
    	//交集的算法过程
            private static void intersection(List<Integer> list1, List<Integer> list2) {
            	
                Integer a1 = list1.get(0);
                Integer a2 = list1.get(1);
                Integer b1 = list2.get(0);
                Integer b2 = list2.get(1);
    
                if (a1 > b2 || b1 > a2) {
                    return;
                }
                
                if (a1 == b2) {
                    System.out.println("["+a1+"]");
                }
                
                if (a2 == b1) {
                    System.out.println("["+a2+"]");
                }
                
                if (a1 > b1) {
                    System.out.print("[" + a1 + ",");
                    if (b2 < a2) {
                        System.out.println(b2 + "]");
                    } else {
                        System.out.println(a2 + "]");
                    }
                }
                
                if (b1 >=  a1) {
                    System.out.print("["+b1+",");
                    if (b2 < a2) {
                        System.out.println(b2 + "]");
                    } else {
                        System.out.println(a2 + "]");
                    }
                }
                
            }
            /*
             * 参数校验的方法
             */
            private static boolean isVaild(List<List<Integer>> collects) {
                if (collects.size() < 1) {
                    System.out.println("集合为空");
                    return false;
                }
                Iterator <List <Integer>> iterator = collects.iterator();
                while (iterator.hasNext()) {
                    List <Integer> list = iterator.next();
                    if (list.size() != 2) {
                        System.out.println("集合区间不合法");
                        return false;
                    }
                    if (list.get(0) > list.get(1)) {
                        System.out.println("集合区间不是有序的");
                        return false;
                    }
                }
                    return true;
            }
    
    
    
        
    
    
    }

     

    展开全文
  • 2、二分查找法必须满足被搜索的集合必须是有序的 3、待查找的元素是集合中真实存在的 算法: 1、二分查找法每次搜索都是按照搜索区域中间位置的元素进行定位,首次搜索时,开始位置为0,结束位置为集合长度-1,...
  • LinkedHashSet是继承了HashSet hashSet的存取是随机的 但是LinkedHashSet的存取是有序的 但是元素都是不能重复的 l
  • 我们知道,Set集合的维护的元素是唯一的,不会出现两个一样的元素,这是通过元素的equals和hashCode方法来判定的。而对于TreeSet来说,它本身除了是一个Set集合,同时还会依据一个Comparator或是Comparable接口对...
  • 链表的有序集合

    2017-04-19 19:38:35
     集合有一个重要的特性:互异性,即集合中任意两个元素不同的,互异性使得集合中的元素没有重复。给你 n 个包含重复数字的无序正整数序列,建立一个有序链表,链表中的结点按照数值非降序排列且不包含重复元素
  • 有序的Map集合

    万次阅读 2019-06-22 08:32:07
    我们通常使用的Map集合是HashMap...而在某些情况下,如果我们需要Map集合里的元素有序,那么HashMap不能满足我们的要求的。 那么有没有有序的Map集合呢?有,Java提供了两种有序的Map集合:LinkedHashMap和TreeM...
  • 1.1 列表 列表(list)类型是用来存储多个...①列表中的元素是有序的,这就意味着可以通过索引下标获取某个元素或者某个范围内的元素列表. ②列表中的元素可以是重复的. 1.1.1 命令 1 插入命令 (1) 从右边插入元素. rpu
  •  集合有一个重要的特性:互异性,即集合中任意两个元素不同的,互异性使得集合中的元素没有重复。给你 n 个包含重复数字的无序正整数序列,建立一个有序链表,链表中的结点按照数值非降序排列且不包含重复元素...
  • Redis 有序集合

    千次阅读 2017-08-28 09:09:12
    简介有序集合是给每个元素设置一个分数(score)作为排序的依据这一概念的集合,其也不能有重复元素的。有序集合提供了获取指定分数和元素范围查询、计算成员排名等功能。 数据结构 是否允许重复元素 是否有序 ...
  • Map、Set集合存放是无序的,然而LinkedHashSet和LinkedHashMap等集合有序,请解释这是什么原因?...键值对,map中插入元素是根据key计算出的哈希值来存储元素的,因此他不是按照元素的添加顺序来存储对...
  • {1 2 3 4 5}集合是正确有序的,但 {2 3 1 4 5}错误顺序的,其有序率 : 对于2来说,其余四个数中有三个数的分布对的(3,4,5分布在2的右边,真确的;但1的位置错的,应该在2的左边),其有序率为3/4, 对于3来...
  • Java集合中有关有序,无序的概念

    千次阅读 2019-03-18 11:34:03
    而大家容易混淆的就是排序,排序集合内的元素是否按照升序或降序来排序 实现了List接口的集合类全部有序,如ArrayList、LinkedList 实现了Set接口的集合类中,HashSet无序,TreeSet排序 实现了Map接口的集合类...
  • 都说list集合是有序的,那么list底层是怎么保证维持元素的特定顺序?list相对于map的优越性在哪?
  • 最近老大让看看redis中数据类型,list中单个element元素,能不能设置过期(不是针对整个list),整个list可以直接设置过期的。网上搜结果list单个元素不支持自动过期设置expire ...②使用有序集合,来实现。(每...
  • 有序集合

    2016-09-26 16:30:00
    Redis 有序集合集合一样也string类型元素集合,且不允许重复的成员。不同的每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。有序集合的成员唯一的,但分数...
  • redis有序集合

    2021-06-21 06:42:56
    有序集合中的元素是可以排序的,通过score 作为有序集合排序的依据 有序集合添加元素(zadd key [nx)
  • 有序集合的一些感想

    2021-04-22 20:19:59
    有序集合的思想本质上二分的思想,即给定一个值(查找值),在一个有序集合中找出()(第一个)满足条件的的元素(即目标元素)。但是很多时候集合是无序的,因此我们需要维护一个有序集合来找出目标元素。比如,我们要想...
  • 假设以两个元素依值递增有序排列的顺序表A和B 分别表示两个集合(同一表中的元素值各不相同),现要求另辟空间构成一个顺序表C,其元素为A和B元素的交集,且表C中的元素依值递增有序排列。 # include <stdio....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,420
精华内容 5,768
关键字:

集合元素是有序的