精华内容
下载资源
问答
  • Hash排序(JAVA)

    2018-03-12 18:03:11
    什么是hash表:哈希表(Hash table,也叫散列表),是根据key而直接进行访问数据结构。也就是说,它通过把key映射到表中一个位置来访问记录,以加快查找速度。这个映射函数叫做散列函数,存放记录数组叫做散...

    什么是hash表:

    哈希表(Hash table,也叫散列表),是根据key而直接进行访问的数据结构。也就是说,它通过把key映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。

      哈希表的做法其实很简单,就是把key通过一个固定的算法函数即所谓的哈希函数转换成一个整型数字,然后就将该数字对数组长度进行取余,取余结果就当作数组的下标,将value存储在以该数字为下标的数组空间里。

        而当使用哈希表进行查询的时候,就是再次使用哈希函数将key转换为对应的数组下标,并定位到该空间获取value,如此一来,就可以充分利用到数组的定位性能进行数据定位


    展开全文
  • hasnext用于判断是否有下一个,用于循环遍历条件判断 remove要和next一起用,先用next指向具体元素,再remove从collection中移除。 迭代器,一般用于set,map集合,很少用于list集合,因为有索引 此处定义...

    内存分析
    局部变量存在栈Stack中
    ———————————————————————————

    容器

    集合框架
    集合框架已内置过(包中),可以直接调用包使用。方便快捷

    在这里插入图片描述
    用法见视频
    在这里插入图片描述
    hasnext用于判断是否有下一个,用于循环遍历的条件判断
    remove要和next一起用,先用next指向具体元素,再remove从collection中移除。
    迭代器,一般用于set,map集合,很少用于list集合,因为有索引
    两种遍历的用法
    此处定义string类型的,也可定义自定义的类。
    1)增强型for循环
    直接遍历输出
    !由于这种循环在Java中经常被使用。此处解释一下用法
    for((要循环的主体的类型eg:int string file) 空格 代号名 如图中的f1 :要遍历的数组或结构等)
    {for循环主体}
    在这里插入图片描述

    2)用iterator迭代器输出
    在这里插入图片描述
    在这里插入图片描述
    list接口包括Arraylist,Linklist实现类 etc

    All:接口定义了方法(抽象),list set 都继承了Collection的方法。list set还是抽象类,并未实现方法,其方法由实现类(如Arraylist)实现。


    在这里插入图片描述
    注意:TreeSet需要排序,string类型已有定义好的排序函数。
    若是自定义的类型,则需要自己定义函数来进行比较,否则会报错。

    Map接口

    字典,根据key可找到value,一对一
    在这里插入图片描述
    新建hashmap并插入
    在这里插入图片描述
    在这里插入图片描述
    常用Hashmap和TreeMap
    要排序时用Treemap

    工具类里的常用算法

    在这里插入图片描述
    可直接使用 用法如下
    sort用法在这里插入图片描述
    shuffle binaryseach max min在这里插入图片描述
    reverse,swap用法
    在这里插入图片描述
    更多参考JDK帮助文档

    展开全文
  • java的数据结构: 线性表,链表,哈希是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。 Collection ├List │├LinkedList │├...

    java的数据结构:
    线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。
    Collection
    ├List
    │├LinkedList
    │├ArrayList
    │└Vector
    │ └Stack
    └Set

    Map
    ├Hashtable
    ├HashMap
    └WeakHashMap

    HashMap和Hashtable的区别:HashMap是非同步的,允许空值。即null value和null key。但是将HashMap视为Collection时
    (values()方法可返回Collection),其迭代操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将
    HashMap的初始化容量设得过高,或者load factor过低。
    HashMap和Hashtable的例子:

    package cn.Hash.day08;
    public class Student {
    String name;
    int number;

     public Student(String name,int number){
         this.name=name;
         this.number=number;
     }
    
    @Override
    public String toString() {
        String s = this.name+"\t"+this.number;
        return s;
    }
    

    }

    package cn.Hash.day08;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.Hashtable;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    /**
    * 构造一个HashMap,向里面存入至少4个学生对象,
    * 要求遍历HashMap输出所有学生信息。
    */

    public class HashMapTest {

    public static void main(String[] args) {
        Student xiaoming = new Student("小明",101);
        Student xiaoli = new Student("小李",102);
        Student xiaowang = new Student("小王",103);
        Student xiaozhang = new Student("小张",104);
        /**HashMap
         * 元素存取:
         * HashMap中元素的排列顺序是不固定的。只有HashMap可以让你将空值作为一个表的条目的key或value 
         */
        HashMap<String,Student> map = new HashMap<String, Student>();
        map.put("小明", xiaoming);//将对象添加到HashMap集合,我认为相当于arrayList的add。小明为关键字
        map.put("小李", xiaoli);
        map.put("小王", xiaowang);
        map.put("小张", xiaozhang);
    
    Student zhangsan = map.get("小张");
    Student zhangsa = map.get("张");//打印为空
    System.out.println(zhangsan.name+zhangsan.number);
    System.out.println(zhangsa);
    
    
        /**
         * 元素遍历
         */
        Set<String> keySet = map.keySet(); //取元素
        Iterator<String> iterator = keySet.iterator();//迭代器
        while(iterator.hasNext()){ //查看是否存在,如果仍有元素,可以迭代
            String key = iterator.next();//返回迭代的下一个元素
            System.out.println("关键字:"+key);
            Student i = map.get(key);
            System.out.println(i);//重写toString
        }
        System.out.println();
    
        /**
         * Hashtable
         */
        Hashtable<String,Integer> table = new Hashtable<>();
        table.put("one", 1);
        table.put("two",2);
        table.put("three", 3);
        table.put("four",4);
    
        Integer ss = table.get("one");
        System.out.println(ss);
    
    
        Set<String> keySet1 = table.keySet();
        Iterator<String> iterator1 = keySet1.iterator();
        while(iterator1.hasNext()){
            String key1=iterator1.next();
            System.out.println("关键字:"+key1);
            Integer j = table.get(key1);
            System.out.println(j);
        }
    }
    

    }

    collections工具类及sort排序:(引用上面的Student类)

    package cn.Hash.day08;
    import java.util.Comparator;
    /**
    * 比较器,根据学号进行比较
    * @author Administrator
    *
    */
    public class ComparatorNumber implements Comparator {

    @Override
    public int compare(Student o1, Student o2) {
        int num = o1.number;
        int numb = o2.number;
        if(num>numb){
            return 1;//此处只能返回正数,原因暂不详(大于用正数,小于用负数,如果是等于可直接)
        }else{
        return -1;//此处只能返回负数
        }
    }
    

    }

    package cn.Hash.day08;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Iterator;

    public class CollectionsSortTest {

    public static void main(String[] args) {
        Student xiaoming = new Student("小明",108);
        Student xiaoli = new Student("小李",102);
        Student xiaowang = new Student("小王",107);
        Student xiaozhang = new Student("小张",104);
    
        ArrayList<Student> lists = new ArrayList();
        lists.add(xiaoming);
        lists.add(xiaoli);
        lists.add(xiaowang);
        lists.add(xiaozhang);
    
        /**
         *排序前:for()each{}循环
         */
        for(Student student:lists){
            System.out.println(student);
        }
        System.out.println();
        /**
         * for循环
         */
        int size=lists.size();
        for(int i=0;i<size;i++){
            Student s = lists.get(i);
            System.out.println(s);
        }
        System.out.println();
        /**
         * 迭代器  循环取值
         */
        Iterator iterator = lists.iterator();
        while(iterator.hasNext()){
            Student ss = (Student) iterator.next();
            System.out.println(ss);
        }
        System.out.println();
    
        /**
         * 排序后:
         * Clooections是工具类,sort是方法
         */
        ComparatorNumber comparator = new ComparatorNumber();
        Collections.sort(lists, comparator); 
        for(int i=0;i<size;i++){
            Student s = lists.get(i);
            System.out.println(s);
        }
        /**
         * 采用匿名内部类后排序  则不用comparator方法实现
         */
    Collections.sort(lists,new Comparator<Student>(){
            public int compare(Student o1,Student o2){
                if(o1.number<o2.number){
                    return 1;
                }else{
                    return -1;
                }
            }
        });
        for(int i=0;i<size;i++){
            Student sss = lists.get(i);
            System.out.println(sss);
        }
    }
    

    }

    展开全文
  • java List的排序

    2019-02-21 11:27:27
    由于报表数据是分段获取,不能在获取时排序,只能在输出时排序。 有两种情况,一种是表头排序,另一种数据。 表头,可以使用如下方法,先定义原始数据表头,在输出时位于第几列: private static final Map&...

    项目中输出报表时,需要对List<String>进行排序。由于报表数据是分段获取的,不能在获取时排序,只能在输出时排序。

    有两种情况,一种是表头排序,另一种数据。

    表头,可以使用如下方法,先定义原始数据表头,在输出时位于第几列:

        private static final Map<String,Integer> PERSONAL_SORT = new HashMap<>();
        static {
            PERSONAL_SORT.put("表头1", 16);//原始数据第一列,输出时显示在第16列
            PERSONAL_SORT.put("表头2", 10);
            PERSONAL_SORT.put("表头3", 5);
            PERSONAL_SORT.put("表头4", 9);
            PERSONAL_SORT.put("表头5", 8);
            PERSONAL_SORT.put("表头6", 2);
            PERSONAL_SORT.put("表头7", 6);
            PERSONAL_SORT.put("表头8", 3);
            PERSONAL_SORT.put("表头9", 14);
            PERSONAL_SORT.put("表头10", 7);
            PERSONAL_SORT.put("表头11", 15);
            PERSONAL_SORT.put("表头12", 11);
            PERSONAL_SORT.put("表头13", 12);
            PERSONAL_SORT.put("表头14", 13);
            PERSONAL_SORT.put("表头15", 4);
            PERSONAL_SORT.put("表头16", 1);
        }
    再进行排序(selColumnsList是需要排序的对象):
    Collections.sort(selColumnsList, new Comparator<String>() {
        @Override
        public int compare(String s, String t1) {
            if(PERSONAL_SORT.get(s) >PERSONAL_SORT.get(t1)) {
                return 1;
            }else
            {
                return -1;
            }
        }
    });

    数据部分,原始数据是一行行的生成的,因此可以在原始数据的每一行生成后,进行顺序调换。

    先定义一个数组,用来描述每一行,从原始数据的哪个列取值:

    //第5列从原始数据的第20列取值,第6列从原始数据第10列取值
    private static int[] COLUMNS_SORT2 = {1,2,3,4,20,10,12,19,7,11,14,9,8,6,16,17,18,13,15,5};

    再进行顺序调换:

    private static List<String> SortList(List<String> list, int[] order) {
            if(list.size() != order.length)
                //如果指定顺序的数组和原始数据长度不一致,直接返回原始数据
                return list;
            else
            {
                List<String> newList = new ArrayList<>();
                for(int i=0;i<order.length;i++)
                {
                    newList.add(list.get(order[i]-1));
                }
                return newList;
            }
        }

    当然,表头也可以用数据的排序方法进行顺序调整,效率应该更高,只是用上面的方法更加直观。

    上面表头顺序和数组都可以写在配置文件里面,方便调整。

    展开全文
  • 简介现在几乎所有O2O应用中都会存在“按范围...实现为了方便下面说明,先给出一个初始结构,我使用是MySQL:CREATE TABLE `customer` ( `id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增主键', ...
  • 这里假设已知输入数据范围在1000以内 public class SortByHash { public static void sortByHash(int[] array){ int[] hash=new int[1000]; for (int i=0;i<array.length;i++){ hash[array[i...
  • 简介现在几乎所有O2O应用中都会存在“按范围...实现为了方便下面说明,先给出一个初始结构,我使用是MySQL:CREATE TABLE `customer` (`id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增主键',`n...
  • 简介现在几乎所有O2O应用中都会存在“按范围...实现为了方便下面说明,先给出一个初始结构,我使用是MySQL:CREATE TABLE customer ( id INT(11) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增主键', name...
  • 排序算法分为两种:比较算法、非比较算法 其中比较排序是将要排序内容通过比较数值大小方法,决定排列顺序。为了降低时间复杂度引入分治,递归等方法。...计数算法:计数算法原理类似于Hash表的原理。
  • 集合遍历三种方式: List list; for(int i =0;i<list.size();i++){} for(Object o :list){} 只适用于集合,不能在数组中使用: list.foreach(temp->{}); ArrayList和LinkedList最主要区别: 底层...
  • HashMap是一个数组和链表组成的一种链表散列结构,存储方式是根据key的hash值来决定存储的位置,这就导致了存储后的元素不会维持插入时的顺序。 Comparator 如果我们需要控制某个类的次序并且该类本身不支持排序,...
  • 最近遇到需要将mysql中数据缓存到redis中,而列表展示... 首先利用ZSET将A中id以value形式进行存储,以及利用ZSET中score进行排序处理; 2. 将A中数据以HASH结构进行存储,id作为HASH中key; 3. 利用redis中...
  • 解决查询速度慢方案除了哈希外,还可以使用二叉排序树。我们知道,查询慢主要是因为不知道元素位置,使用hash函数映射虽然解决了问题,但其并不稳定,当出现大量哈希碰撞后其表现更像一个链表,查询速度大大...
  • 前言归并排序算法是连接算法中比较复杂算法,相比嵌套循环与Hash匹配而言。本节会通过实例来说明该算法在PG中具体实现。在PG中,通过状态机来实现——归并-连接。当然这里完整流程是排序——归并——连接,...
  • Java集合:哈希

    2017-10-25 17:13:59
    Hash表也称散列表,也有直接译作哈希表,Hash表是一种特殊数据结构,它同数组、链表以及二叉排序树等相比较有很明显区别,它能够快速定位到想要查找记录,而不是与表中存在记录关键字进行比较来进行查找。...
  • java集合操作查找

    2017-06-27 21:22:09
    2017年6月27日总结 Map接口 Map接口定义集合又称...根据内部数据结构不同,Map接口有多种实现类,其中常用有内部为hash表实现HashMap和内部为排序二叉树实现TreeMap。 V put(K key, V value)方法: 将key-
  • 这次就用到hash排序了吧,当然也可以不用毕竟不是最优,问题是给出乱序0,1,2数组代表三种颜色(并没有什么意义),然后要求排序从小到大0,1,2。 问题链接:https://leetcode.com/problems/sort-colors/ 相关问题...
  • 二叉排序树中,还会将数据排序以进行二分查找,将时间复杂度从O(n)降低到O(lg n)。出现这个问题根源在于,我们没有办法直接根据一个元素找到它存储位置。那有没有办法消除这个对比过程呢?哈希就是解决...
  • (HashSet或TreeSet,取决于它们是否可以以某种方式进行排序,或者可以是hash),使用addAll.默认情况下,集合不包含重复项.如果需要结束,您可以将此Set转换为(Array)列表.注意,如果您决定使用HashSet,您将需要为您...
  • 解决查询速度慢方案除了哈希外,还可以使用二叉排序树。我们知道,查询慢主要是因为不知道元素位置,使用hash函数映射虽然解决了问题,但其并不稳定,当出现大量哈希碰撞后其表现更像一个链表,查询速度大大...
  • list是接口,arraylist是实现该接口类,arraylist底层是动态数组,有序且可以重复hashset底层是hash表,由于会比较hash值和equals,所以他是不可重复并且是无序。简单说一个是有序可重复,一个是无序不可重复...
  • ###1. 什么是哈希表 散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行...  Hash表也称散列表,也有直接译作哈希表,Hash表是一种特殊数据结构,它同数组、链表以及二叉排序树等相比较...
  • 1. 什么是哈希表 散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问数据结构.... Hash表也称散列表,也有直接译作哈希表,Hash表是一种特殊数据结构,它同数组、链表以及二叉排序
  • javaset

    千次阅读 多人点赞 2020-07-01 14:05:03
    HashSet: HashSet是采用hash表算法来实现,其中元素没有按顺序排列。(遍历时输出元素顺序是不可控) TreeSet:采用红黑树算法,进行排序。(遍历时输出元素顺序是默认是从小到大地输出) ...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 287
精华内容 114
关键字:

java的hash表排序

java 订阅