精华内容
下载资源
问答
  • SET接口没有所谓的有序还是无序。 TreeSet是有序的,此有序是说读取数据的顺序和插入数据的顺序一样。 HashSet无序?,此无序说的是读取数据的顺序不一定和插入数据的顺序一样。但是HashSet真实的情况是有序的,只...

    SET接口没有所谓的有序还是无序。

    TreeSet是有序的,此有序是说读取数据的顺序和插入数据的顺序一样。

    HashSet无序?,此无序说的是读取数据的顺序不一定和插入数据的顺序一样。但是HashSet真实的情况是有序的,只不过他是通过内部HashCode方法计算hash值后自动进行了排序,所以读取的是经过内部排序后的数据,且此数据每次结果都是一样的顺序。

    同样的,HashMap和HashSet是一样的,HashMap是根据key的hash值进行了排序。

     

    public static void main(String[] args) {
           Set<String> a = new HashSet<String>();
           a.add("a");
           a.add("b");
           a.add("c");
           a.add("d");
           a.add("e");
           a.add("f");
           a.add("g");
           for (String x : a) {
            System.out.println(x);
           }
        }

     当我们按照abcdefg的顺序插入后,发现读取出来的顺序还是abcdefg,此时是因为正好插入数据的hash值是按照这个顺序排列。当我们把插入的字符复杂化后就会出现变化。

    public static void main(String[] args) {
           Set<String> a = new HashSet<String>();
           a.add("axs");
           a.add("bda");
           a.add("cewd");
           a.add("dds");
           a.add("eve");
           a.add("fdd");
           a.add("gew32");
           for (String x : a) {
            System.out.println(x);
           }
        }

     得到的结果为

    cewd
    dds
    gew32
    eve
    fdd
    axs
    bda

    且恒定地出现这样的结果。说明HashMap是有序的。补充一点,HashSet有序是内部处理了,但是没有排序方法,不能自定义排序。

    展开全文
  • 1、为什么集合能够直接打印? System.out.println(HashSet has); 答:因为集合的底层重写了toString方法,调用了StringBuilder类的.append()/.toString()方法将元素拼接起来 (特么这个 Iterator it = iterator()...

    1、为什么集合能够直接打印?

    System.out.println(HashSet  has);
    

    答:因为集合的底层重写了toString方法,调用了StringBuilder类的.append()/.toString()方法将元素拼接起来 (这个 Iterator it = iterator();什么意思???没有对象供他引用啊用这个迭代器是干嘛的??)

      public String toString() {
            Iterator<E> it = iterator();
            if (! it.hasNext())
                return "[]";
    
            StringBuilder sb = new StringBuilder();
            sb.append('[');
            for (;;) {
                E e = it.next();
                sb.append(e == this ? "(this Collection)" : e);
                if (! it.hasNext())
                    return sb.append(']').toString();
                sb.append(',').append(' ');
            }
        }
    

    2、HashSet到底是有序还是无序的?

    先上一个代码,在HashSet存储10个范围在0到9的随机数:

    package cn.njupt;
    
    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.ListIterator;
    import java.util.Random;
    
    public class TTTTest {
    
    	@SuppressWarnings({ "unchecked", "rawtypes" })
    	public static void main(String[] args) {
    		
    		HashSet<Integer> has = new HashSet<>();
    		
    		Random ran = new Random();
    		
    		while(has.size() != 10) {
    			has.add((ran.nextInt(10)));
    		}
    		
    		for (Integer integer : has) {
    			System.out.print(integer + " ");
    		}
    	}
    
    }
    
    輸出:0 1 2 3 4 5 6 7 8 9 
    

    很奇怪,无论编译多少次,输出是有序的????

    网上看了一些回答,摘抄如下:Java遍历HashSet为什么输出是有序的?

    1. HashSet无序指的是存取无序。不是储存数据无序。
    2. 首先你要懂哈希表是什么,实质就是数组+链表,所以每插入一个对象,都会计算哈希值,插到固定位置,所以每一个对象的位置是固定的,那么hashset到底有序还是无序,答案肯定是有序的,国内的人闲麻烦就直接了当的说成无序,在国外程序员眼里这个就是有序的。
    3. 实现是会变的,HashSet的迭代器在输出时“不保证有序”,但也不是“保证无序”。也就是说,输出时有序也是允许的,但是你的程序不应该依赖这一点。

    然后我用存取有序的LinkedHashSet和存取无序的HashSet来存储String对象,发现LinkedHashSet的输出和输入的顺序是一样的
    HashSet的内部应该是存储有序的,就像火车上的座位号一样,虽然乘客的车票(hashcode)都不一样,但是坐下来的座位都是一样的,因为已经按照固定的位置坐了,所以出站是按照位置的,但不是和进站一样的顺序,“不保证有序”,但也不是“保证无序”

    package cn.njupt;
    
    import java.util.HashSet;
    import java.util.LinkedHashSet;
    
    public class HashSetooo {
    
    	public static void main(String[] args) {
    		// HashSet<String> has = new HashSet<>();
    		LinkedHashSet<String> has = new LinkedHashSet<>();
    
    		has.add("z");
    		has.add("x");
    		has.add("a");
    		has.add("a");
    		has.add("a");
    		has.add("e");
    		has.add("f");
    		has.add("d");
    		has.add("f");
    		has.add("b");
    
    		System.out.println(has);
    
    	}
    
    }
    
    HashSet输出:[a, b, d, e, f, x, z]   存取无序,但是取出是按照存储的顺序
    LinkedHashSet输出:[z, x, a, e, f, d, b]  存取有序
    

    3、HashSet如何保证存储唯一?
    就像坐火车一样,HashSet给每一个进站的人(对象)分配了一个车票(hashcode),如果hashcode不一样,就是两个对象,如果一样,再调用该写过的equals()方法,比较对象的属性,所以如果用HashSet存储自己创建的对象(Student类等),需要重写一下hashcode()和equals()方法。
    hashcode只是提供了一个调用方法的框架,方法本身还是类自己定义的,比如很多类类重写了toSting的方法,println就直接输出了println(a.toString),并不是在System里面重写toString方法

    下面是自己创建的Student类重写的hashcode()和equals()方法:

    @Override
    public int hashCode() {
    	final int prime = 31;
    	int result = 1;
    	result = prime * result + age;
    	result = prime * result + ((name == null) ? 0 : name.hashCode());
    	return result;
    }
    
    @Override
    public boolean equals(Object obj) {  //写这么多,健壮性判断
    	if (this == obj)                 //调用的对象和传入的对象一样
    		return true;
    	if (obj == null)    //传入对象为null
    		return false;
    	if (getClass() != obj.getClass())  //返回的字节码对象(对应的字节码文件)不是同一个
    		return false;
    	Student other = (Student) obj;  //向下转型
    	if (age != other.age)        年龄不符合
    		return false;  //年龄
    	if (name == null) { //如果姓名为空
    		if (other.name != null)  //姓名不为空
    			return false;
    	} else if (!name.equals(other.name))  //姓名不为空的时候姓名不一样
    		return false;
    	return true;
    }
    
    equals 属性相同返回true,不同返回false	
    
    展开全文
  • 在java中经常用到List有序集合,以便处理数据,但有些情况下需要转换成map集合,但是map集合是无序的,如果我们还是想的到一个有序的map集合在使用lambda表达式时当如下使用: Map<String, List<T>> ...

    在java中经常用到List有序集合,以便处理数据,但有些情况下需要转换成map集合,但是map集合是无序的,如果我们还是想的到一个有序的map集合在使用lambda表达式时当如下使用:

    Map<String, List<T>> collect1 = list.stream().collect(Collectors.groupingBy(T::getT, LinkedHashMap::new, Collectors.toList()));
    

    经过转换的map集合后和List就保持一致了。

    展开全文
  • 无论是有序关联容器还是有序关联容器都是基于(set:集合 key map:映射表 [key : value]) unordered_set 单重集合:所谓的单重集合就是集合中的所有的元素都是唯一的,不存在俩个重复的元素。 unordered_multiset ...

    无序关联容器:链式哈希表  增删改O(1)

    无论是有序关联容器还是有序关联容器都是基于(set:集合 key  map:映射表  [key : value])

     

    unordered_set          单重集合:所谓的单重集合就是集合中的所有的元素都是唯一的,不存在俩个重复的元素。

    unordered_multiset   多重集合:所谓的多重集合和单重集合的元素是相反的。允许集合中存在重复的元素。

    unordered_map        单重映射表

    unordered_multimap  多重映射表

    使用到的头文件:

    #include<unordered_set>

    #include<unordered_map>

    1.各个容器底层的数据结构 O(1)  O(log2n)
    2.常用增删查方法
    增加:insert(val)
    遍历:iterator自己搜索, 调用find成员方法
    删除:erase(key)  erase(it)//既可以按照key值删除,也可以按照迭代器删除

    #include<iostream>
    #include <unordered_set>
    int main()
    {
            unordered_set<int> set1; // 不会存储key值重复的元素
    	for (int i = 0; i < 50; ++i)
    	{
    		set1.insert(rand()%20+1); // vector/deque/list  insert(it, val)
    	}
    
    	//cout << set1.size() << endl;
    	//cout << set1.count(15) << endl;
    
    	auto it1 = set1.begin();
    	for (; it1 != set1.end(); ++it1)
    	{
    		cout << *it1 << " ";
    	}
    	cout << endl;
    
    	set1.erase(20); // 按key值删除元素
    
    	for (it1 = set1.begin(); it1 != set1.end(); )
    	{
    		if (*it1 == 30)
    		{
    			it1 = set1.erase(it1); // 调用erase,it1迭代器就失效了
    		}
    		else
    		{
    			++it1;
    		}
    	}
    	
    	it1 = set1.find(20);
    	if (it1 != set1.end())
    	{
    		set1.erase(it1);
    	}
    
    	for (int v : set1)
    	{
    		cout << v << " ";
    	}
    	cout << endl;
    }

    有序关联容器:红黑树  增删改O(log2n) 2是底数

    set

    multiset

    map

    multimap

    使用到的头文件

    #include<set>

    #include<map>


    关联容器应用场景

    1,处理海量数据查重复;去重复的时候

            const int ARR_LEN = 100;
    	int arr[ARR_LEN] = { 0 };
    	for (int i = 0; i < ARR_LEN; ++i)
    	{
    		arr[i] = rand() % 20 + 1;
    	}
    
    	// 上面的10万个整数中,把数字进行去重打印  set  map
    	unordered_set<int> set;
    	for (int v : arr) // O(n)
    	{
    		set.insert(v); // O(1)
    	}
    
    	for (int v : set)
    	{
    		cout << v << " ";
    	}
    	cout << endl;

    2,统计大量数字中,那些数字重复了,并且统计数字重复的次数。

    一下代码中需要注意unordered_map的中括号运算符重载访问key value对的时候,如果key不存在会默认将你访问的不存在的key 和value默认类型构造组成新的key value键值对插入到map中。

    也可以这么解释:

    map的operator[]功能如下
        1.查询
        2.如果key不存在,它会插入一对数据[key, string()]。

    所以我们使用map1[k]++直接可以替换掉注释代码,和注释代码逻辑相同。

            unordered_map<int, int> map1;
    	for (int k : arr)
    	{
    		/*
    		auto it = map1.find(k);
    		if (it == map1.end())
    		{
    			map1.insert({k, 1});
    		}
    		else
    		{
    			it->second++;
    		}
    		*/
    		map1[k]++; // map1[k]  [k, 1]
    	}
    
    	/*
    	for (const pair<int, int> &p : map1)
    	{
    		if (p.second > 1)
    		{
    			cout << "key:" << p.first << " count:" << p.second << endl;
    		}
    	}
    	*/
    
    	auto it = map1.begin();
    	for (; it != map1.end(); ++it)
    	{
    		if (it->second > 1)
    		{
    			cout << "key:" << it->first <<
    				" count:" << it->second << endl;
    		}
    	}

     

    展开全文
  • 最终都是去执行图片上最后这个构造方法,根据用户传入的第二个参数来决定创建LinkedHashMap对象还是HashMap对象,这就说明了,json底层是一个Map集合,也就解释了为什么json默认存放元素是无序的(其实是有序的,不过...
  • 再次查看 还是没有变化 因为一个不可变的 有序集合Set,使用treeSet进行排序 创建可变的Set 导入包  可变的Set加一个值 用+ 用+= 就是在原有值的基础上加上,不加= 就会生成一个新的set ...
  • 无论是常用的List、Hashtable还是ListDictionary,在保存值的时候都是无序的,而今天要介绍的集合类SortedList和SortedList在保存值的时候是有序保存。SortedList之二分查找法一个集合有序,意味着什么?意味着可以...
  • Python入门迭代

    2018-01-11 16:09:31
    迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用 for 循环总是可以依次取出集合的每一个元素。 注意: 集合是指包含一组元素的数据结构,已经介绍的包括: 1. 有序集合:list,tuple,str和unicode;...
  • Sequence 设置流程为串行还是并行处理。 Loop cardinality 设置节点的循环次数。 Collection 设置处理人集合。 Element variable 设置一个处理人变量。 Completion condition 设置结束条件,在这里配置会签结束...
  • 集合

    2021-01-18 16:05:18
    几个存放的多个对象的引用,对象本身还是放在堆内存中。 集合可以存放不同类型,不限数量的数据类型 Java集合可以分为Set、List、Map三种体系 Set:无序、不可重复的集合 List:有序,可重复的集合 Map:无序...
  • Python迭代

    2017-03-27 21:35:52
    迭代操作就是对于一个集合,无论该集合是有序还是无序,用 for 循环总是可以依次取出集合的每一个元素集合是指包含一组元素的数据结构,我们已经介绍的包括: 1. 有序集合:list,tuple,str和unicode; 2. 无序...
  • Python练习-迭代

    2018-06-01 14:31:06
    因此,迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用 for 循环总是可以依次取出集合的每一个元素。 注意: 集合是指包含一组元素的数据结构,我们已经介绍的包括: 1. 有序集合:list,tuple,...
  • 迭代

    2019-10-08 23:36:28
    在python中,如果给定一个list或tuple,我们可以通过for循环来遍历...因此,迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用for循环总是可以依次取出集合的每一个元素 有序集合:list tuple str ...
  • 9-1 python之迭代 什么是迭代 在Python中,如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们...因此,迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用 for 循...
  • python之迭代学习

    2016-12-07 17:50:22
    在Python中,如果给定一个list或tuple,我们可以通过for循环来遍历这个...因此,迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用 for 循环总是可以依次取出集合的每一个元素。 注意: 集合是指包含一组
  • 1.迭代 在Python中,如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们成为迭代(Iteration)。...因此,迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用 ...
  • Python 迭代(6)

    2017-10-30 18:52:34
    什么是迭代 在Python中,如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们成为迭代(Iteration)。...因此,迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用
  • 在开始之前,本蟒蛇严重申明,集合和字典是无序的!!集合和字典是无序的!!集合和字典是无序的!!不要看完本蛇说完,然后得到了什么奇奇怪怪的结论!本文基于python3.6进行讲解,什么你还是2.7?兄弟
  • Java集合

    2020-06-23 23:48:38
    2.集合存放的多个集合的引用,对象本身还是放在堆内存中。 3.集合可以存放不同类型,不限数量的数据类型 Java集合可分为Set,list和Map三种体系 集合 内容 Set 无序,不可重复集合 List 有序,可重复...
  • 无论是常用的List<T>、Hashtable还是ListDictionary<...在保存值的时候是有序保存。 SortedList之二分查找法 一个集合有序,意味着什么?意味着可以利用一些算法来提高遍历集合时的效率,最常见...
  • Java集合之HashSet集合

    2020-04-13 18:27:20
    集合存放的多个对象的引用,对象本身还是放在堆内存中 集合可以存放不同类型,不限数量的数据类型 Java集合可分为Set、List、Map Set:无序,不可重复的集合 List:有序,可重复的集合 Map:具有映射关系的集合 ...
  • 集合类型内置方法

    2019-10-05 06:19:06
    目录 1.作用 2.定义方式 3.内置方法 4.存一个值还是多个值 5.有序 or 无序 6.可变 or 不可变(重点) ...存储一大堆元素的东西,容器数据类型。用于关系运算的集合体,由于集合内的元素无序集合元素不可...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 131
精华内容 52
关键字:

集合是有序还是无序