精华内容
下载资源
问答
  • java如何做一个进度条展示

    千次阅读 2018-01-14 19:58:43
    跪求大神帮忙啊!展现程序员能量的时候到了!就是在做一个插入,比如说有一张表里的数据是100条 这个进度条能达到的效果是插入一条 变为1/100 2/100 3/100...直到全部插入变为100/100提示插入完成
    跪求大神帮忙啊!展现程序员能量的时候到了!就是在做一个全表插入,比如说有一张表里的数据是100条 这个进度条能达到的效果是插入一条 变为1/100 2/100 3/100...直到全部插入变为100/100提示插入完成
    展开全文
  • Java集合之—HashMap

    万次阅读 多人点赞 2018-11-02 23:59:41
    也叫散列表,是种非常重要的数据结构,应用场景及其丰富,许多缓存技术(比如memcached)的核心其实就是在内存中维护一张大的哈希,本文会对java集合框架中的对应实现HashMap的实现原理进行讲解,然后会对JDK7的...

    深入浅出学Java——HashMap

    哈希表(hash table)
    也叫散列表,是一种非常重要的数据结构,应用场景及其丰富,许多缓存技术(比如memcached)的核心其实就是在内存中维护一张大的哈希表,本文会对java集合框架中HashMap的实现原理进行讲解,并对JDK7的HashMap源码进行分析。

    一、什么是哈希表

    在讨论哈希表之前,我们先大概了解下其他数据结构在新增,查找等基础操作执行性能

    数组:采用一段连续的存储单元来存储数据。对于指定下标的查找,时间复杂度为O(1);通过给定值进行查找,需要遍历数组,逐一比对给定关键字和数组元素,时间复杂度为O(n),当然,对于有序数组,则可采用二分查找,插值查找,斐波那契查找等方式,可将查找复杂度提高为O(logn);对于一般的插入删除操作,涉及到数组元素的移动,其平均复杂度也为O(n)

    线性链表:对于链表的新增,删除等操作(在找到指定操作位置后),仅需处理结点间的引用即可,时间复杂度为O(1),而查找操作需要遍历链表逐一进行比对,复杂度为O(n)

    二叉树:对一棵相对平衡的有序二叉树,对其进行插入,查找,删除等操作,平均复杂度均为O(logn)。

    哈希表:相比上述几种数据结构,在哈希表中进行添加,删除,查找等操作,性能十分之高,不考虑哈希冲突的情况下(后面会探讨下哈希冲突的情况),仅需一次定位即可完成,时间复杂度为O(1),接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。

    我们知道,数据结构的物理存储结构只有两种:顺序存储结构链式存储结构(像栈,队列,树,图等是从逻辑结构去抽象的,映射到内存中,也这两种物理组织形式),而在上面我们提到过,在数组中根据下标查找某个元素,一次定位就可以达到,哈希表利用了这种特性,哈希表的主干就是数组

    比如我们要新增或查找某个元素,我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置,通过数组下标一次定位就可完成操作。
      
    这个函数可以简单描述为:存储位置 = f(关键字) ,这个函数f一般称为哈希函数,这个函数的设计好坏会直接影响到哈希表的优劣。举个例子,比如我们要在哈希表中执行插入操作:
    插入过程如下图所示
    哈希表数据插入过程

    查找操作同理,先通过哈希函数计算出实际存储地址,然后从数组中对应地址取出即可。

    哈希冲突

    然而万事无完美,如果两个不同的元素,通过哈希函数得出的实际存储地址相同怎么办?也就是说,当我们对某个元素进行哈希运算,得到一个存储地址,然后要进行插入的时候,发现已经被其他元素占用了,其实这就是所谓的哈希冲突,也叫哈希碰撞。前面我们提到过,哈希函数的设计至关重要,好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是,我们需要清楚的是,数组是一块连续的固定长度的内存空间,再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢?哈希冲突的解决方案有多种:开放定址法(发生冲突,继续寻找下一块未被占用的存储地址),再散列函数法,链地址法,而HashMap即是采用了链地址法,也就是数组+链表的方式。

    二、HashMap的实现原理

    HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元,每一个Entry包含一个key-value键值对。(其实所谓Map其实就是保存了两个对象之间的映射关系的一种集合)

    //HashMap的主干数组,可以看到就是一个Entry数组,初始值为空数组{},主干数组的长度一定是2的次幂。
    //至于为什么这么做,后面会有详细分析。
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
    

    Entry是HashMap中的一个静态内部类。代码如下

        static class Entry<K,V> implements Map.Entry<K,V> {
            final K key;
            V value;
            Entry<K,V> next;//存储指向下一个Entry的引用,单链表结构
            int hash;//对key的hashcode值进行hash运算后得到的值,存储在Entry,避免重复计算
    
            /**
             * Creates new entry.
             */
            Entry(int h, K k, V v, Entry<K,V> n) {
                value = v;
                next = n;
                key = k;
                hash = h;
            } 
    

    所以,HashMap的总体结构如下:
    在这里插入图片描述

    简单来说,HashMap由数组+链表组成的,数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的,如果定位到的数组位置不含链表(当前entry的next指向null),那么查找,添加等操作很快,仅需一次寻址即可;如果定位到的数组包含链表,对于添加操作,其时间复杂度为O(n),首先遍历链表,存在即覆盖,否则新增;对于查找操作来讲,仍需遍历链表,然后通过key对象的equals方法逐一比对查找。所以,性能考虑,HashMap中的链表出现越少,性能才会越好。

    其他几个重要字段

    /**实际存储的key-value键值对的个数*/
    transient int size;
    
    /**阈值,当table == {}时,该值为初始容量(初始容量默认为16);当table被填充了,也就是为table分配内存空间后,
    threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold,后面会详细谈到*/
    int threshold;
    
    /**负载因子,代表了table的填充度有多少,默认是0.75
    加载因子存在的原因,还是因为减缓哈希冲突,如果初始桶为16,等到满16个元素才扩容,某些桶里可能就有不止一个元素了。
    所以加载因子默认为0.75,也就是说大小为16的HashMap,到了第13个元素,就会扩容成32。
    */
    final float loadFactor;
    
    /**HashMap被改变的次数,由于HashMap非线程安全,在对HashMap进行迭代时,
    如果期间其他线程的参与导致HashMap的结构发生变化了(比如put,remove等操作),
    需要抛出异常ConcurrentModificationException*/
    transient int modCount;
    

    HashMap有4个构造器,其他构造器如果用户没有传入initialCapacity 和loadFactor这两个参数,会使用默认值

    initialCapacity默认为16,loadFactory默认为0.75

    我们看下其中一个

    public HashMap(int initialCapacity, float loadFactor) {
         //此处对传入的初始容量进行校验,最大不能超过MAXIMUM_CAPACITY = 1<<30(230)
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal initial capacity: " +
                                                   initialCapacity);
            if (initialCapacity > MAXIMUM_CAPACITY)
                initialCapacity = MAXIMUM_CAPACITY;
            if (loadFactor <= 0 || Float.isNaN(loadFactor))
                throw new IllegalArgumentException("Illegal load factor: " +
                                                   loadFactor);
    
            this.loadFactor = loadFactor;
            threshold = initialCapacity;
         
            init();//init方法在HashMap中没有实际实现,不过在其子类如 linkedHashMap中就会有对应实现
        }
    

    从上面这段代码我们可以看出,在常规构造器中,没有为数组table分配内存空间(有一个入参为指定Map的构造器例外),而是在执行put操作的时候才真正构建table数组

    OK,接下来我们来看看put操作的实现

    public V put(K key, V value) {
            //如果table数组为空数组{},进行数组填充(为table分配实际内存空间),入参为threshold,
            //此时threshold为initialCapacity 默认是1<<4(24=16)
            if (table == EMPTY_TABLE) {
                inflateTable(threshold);
            }
           //如果key为null,存储位置为table[0]或table[0]的冲突链上
            if (key == null)
                return putForNullKey(value);
            int hash = hash(key);//对key的hashcode进一步计算,确保散列均匀
            int i = indexFor(hash, table.length);//获取在table中的实际位置
            for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            //如果该对应数据已存在,执行覆盖操作。用新value替换旧value,并返回旧value
                Object k;
                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }
            modCount++;//保证并发访问时,若HashMap内部结构发生变化,快速响应失败
            addEntry(hash, key, value, i);//新增一个entry
            return null;
        }
    

    inflateTable这个方法用于为主干数组table在内存中分配存储空间,通过roundUpToPowerOf2(toSize)可以确保capacity为大于或等于toSize的最接近toSize的二次幂,比如toSize=13,则capacity=16;to_size=16,capacity=16;to_size=17,capacity=32.

    private void inflateTable(int toSize) {
            int capacity = roundUpToPowerOf2(toSize);//capacity一定是2的次幂
            /**此处为threshold赋值,取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值,
            capaticy一定不会超过MAXIMUM_CAPACITY,除非loadFactor大于1 */
            threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
            table = new Entry[capacity];
            initHashSeedAsNeeded(capacity);
        }
    

    roundUpToPowerOf2中的这段处理使得数组长度一定为2的次幂,Integer.highestOneBit是用来获取最左边的bit(其他bit位为0)所代表的数值.

     private static int roundUpToPowerOf2(int number) {
            // assert number >= 0 : "number must be non-negative";
            return number >= MAXIMUM_CAPACITY
                    ? MAXIMUM_CAPACITY
                    : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
        }
    
    

    hash函数

    /**这是一个神奇的函数,用了很多的异或,移位等运算
    对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀*/
    final int hash(Object k) {
            int h = hashSeed;
            if (0 != h && k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
    
            h ^= k.hashCode();
    
            h ^= (h >>> 20) ^ (h >>> 12);
            return h ^ (h >>> 7) ^ (h >>> 4);
        }
    

    以上hash函数计算出的值,通过indexFor进一步处理来获取实际的存储位置

    /**
         * 返回数组下标
         */
        static int indexFor(int h, int length) {
            return h & (length-1);
        }
    

    h&(length-1)保证获取的index一定在数组范围内,举个例子,默认容量16,length-1=15,h=18,转换成二进制计算为index=2。位运算对计算机来说,性能更高一些(HashMap中有大量位运算)

    所以最终存储位置的确定流程是这样的:
    HashMap如何确定元素位置

    再来看看addEntry的实现:

    void addEntry(int hash, K key, V value, int bucketIndex) {
            if ((size >= threshold) && (null != table[bucketIndex])) {
                resize(2 * table.length);//当size超过临界阈值threshold,并且即将发生哈希冲突时进行扩容
                hash = (null != key) ? hash(key) : 0;
                bucketIndex = indexFor(hash, table.length);
            }
    
            createEntry(hash, key, value, bucketIndex);
        }
    

    通过以上代码能够得知,当发生哈希冲突并且size大于阈值的时候,需要进行数组扩容,扩容时,需要新建一个长度为之前数组2倍的新的数组,然后将当前的Entry数组中的元素全部传输过去,扩容后的新数组长度为之前的2倍,所以扩容相对来说是个耗资源的操作。

    三、为何HashMap的数组长度一定是2的次幂?

    我们来继续看上面提到的resize方法

    void resize(int newCapacity) {
            Entry[] oldTable = table;
            int oldCapacity = oldTable.length;
            if (oldCapacity == MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return;
            }
    
            Entry[] newTable = new Entry[newCapacity];
            transfer(newTable, initHashSeedAsNeeded(newCapacity));
            table = newTable;
            threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
        }
    

    如果数组进行扩容,数组长度发生变化,而存储位置 index = h&(length-1),index也可能会发生变化,需要重新计算index,我们先来看看transfer这个方法

    void transfer(Entry[] newTable, boolean rehash) {
            int newCapacity = newTable.length;
         //for循环中的代码,逐个遍历链表,重新计算索引位置,将老数组数据复制到新数组中去(数组不存储实际数据,所以仅仅是拷贝引用而已)
            for (Entry<K,V> e : table) {
                while(null != e) {
                    Entry<K,V> next = e.next;
                    if (rehash) {
                        e.hash = null == e.key ? 0 : hash(e.key);
                    }
                    int i = indexFor(e.hash, newCapacity);
                    //将当前entry的next链指向新的索引位置,newTable[i]有可能为空,有可能也是个entry链,如果是entry链,直接在链表头部插入。
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                }
            }
        }
    

    这个方法将老数组中的数据逐个链表地遍历,扔到新的扩容后的数组中,我们的数组索引位置的计算是通过 对key值的hashcode进行hash扰乱运算后,再通过和 length-1进行位运算得到最终数组索引位置。

    HashMap的数组长度一定保持2的次幂,比如16的二进制表示为 10000,那么length-1就是15,二进制为01111,同理扩容后的数组长度为32,二进制表示为100000,length-1为31,二进制表示为011111。从下图可以我们也能看到这样会保证低位全为1,而扩容后只有一位差异,也就是多出了最左位的1,这样在通过 h&(length-1)的时候,只要h对应的最左边的那一个差异位为0,就能保证得到的新的数组索引和老数组索引一致(大大减少了之前已经散列良好的老数组的数据位置重新调换),个人理解。

    在这里插入图片描述

    还有,数组长度保持2的次幂,length-1的低位都为1,会使得获得的数组索引index更加均匀

    在这里插入图片描述
    我们看到,上面的&运算,高位是不会对结果产生影响的(hash函数采用各种位运算可能也是为了使得低位更加散列),我们只关注低位bit,如果低位全部为1,那么对于h低位部分来说,任何一位的变化都会对结果产生影响,也就是说,要得到index=21这个存储位置,h的低位只有这一种组合。这也是数组长度设计为必须为2的次幂的原因。
    在这里插入图片描述
    如果不是2的次幂,也就是低位不是全为1此时,要使得index=21,h的低位部分不再具有唯一性了,哈希冲突的几率会变的更大,同时,index对应的这个bit位无论如何不会等于1了,而对应的那些数组位置也就被白白浪费了。

    get方法

     public V get(Object key) {
         //如果key为null,则直接去table[0]处去检索即可。
            if (key == null)
                return getForNullKey();
            Entry<K,V> entry = getEntry(key);
            return null == entry ? null : entry.getValue();
     }
    

    get方法通过key值返回对应value,如果key为null,直接去table[0]处检索。我们再看一下getEntry这个方法

    final Entry<K,V> getEntry(Object key) {
                
            if (size == 0) {
                return null;
            }
            //通过key的hashcode值计算hash值
            int hash = (key == null) ? 0 : hash(key);
            //indexFor (hash&length-1) 获取最终数组索引,然后遍历链表,通过equals方法比对找出对应记录
            for (Entry<K,V> e = table[indexFor(hash, table.length)];
                 e != null;
                 e = e.next) {
                Object k;
                if (e.hash == hash && 
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            }
            return null;
        }    
    

    可以看出,get方法的实现相对简单,key(hashcode)–>hash–>indexFor–>最终索引位置,找到对应位置table[i],再查看是否有链表,遍历链表,通过key的equals方法比对查找对应的记录。要注意的是,有人觉得上面在定位到数组位置之后然后遍历链表的时候,e.hash == hash这个判断没必要,仅通过equals判断就可以。其实不然,试想一下,如果传入的key对象重写了equals方法却没有重写hashCode,而恰巧此对象定位到这个数组位置,如果仅仅用equals判断可能是相等的,但其hashCode和当前对象不一致,这种情况,根据Object的hashCode的约定,不能返回当前对象,而应该返回null,后面的例子会做出进一步解释。

    四、重写equals方法需同时重写hashCode方法

    最后我们再聊聊老生常谈的一个问题,各种资料上都会提到,“重写equals时也要同时覆盖hashcode”,我们举个小例子来看看,如果重写了equals而不重写hashcode会发生什么样的问题

    
    public class MyTest {
        private static class Person{
            int idCard;
            String name;
    
            public Person(int idCard, String name) {
                this.idCard = idCard;
                this.name = name;
            }
            @Override
            public boolean equals(Object o) {
                if (this == o) {
                    return true;
                }
                if (o == null || getClass() != o.getClass()){
                    return false;
                }
                Person person = (Person) o;
                //两个对象是否等值,通过idCard来确定
                return this.idCard == person.idCard;
            }
    
        }
        public static void main(String []args){
            HashMap<Person,String> map = new HashMap<Person, String>();
            Person person = new Person(1234,"乔峰");
            //put到hashmap中去
            map.put(person,"天龙八部");
            //get取出,从逻辑上讲应该能输出“天龙八部”
            System.out.println("结果:"+map.get(new Person(1234,"萧峰")));
        }
    }
    
    实际输出结果:null
    

    如果我们已经对HashMap的原理有了一定了解,这个结果就不难理解了。尽管我们在进行get和put操作的时候,使用的key从逻辑上讲是等值的(通过equals比较是相等的),但由于没有重写hashCode方法,所以put操作时,key(hashcode1)–>hash–>indexFor–>最终索引位置 ,而通过key取出value的时候 key(hashcode1)–>hash–>indexFor–>最终索引位置,由于hashcode1不等于hashcode2,导致没有定位到一个数组位置而返回逻辑上错误的值null(也有可能碰巧定位到一个数组位置,但是也会判断其entry的hash值是否相等,上面get方法中有提到。)

    所以,在重写equals的方法的时候,必须注意重写hashCode方法,同时还要保证通过equals判断相等的两个对象,调用hashCode方法要返回同样的整数值。而如果equals判断不相等的两个对象,其hashCode可以相同(只不过会发生哈希冲突,应尽量避免)。

    五、JDK1.8中HashMap的性能优化

    假如一个数组槽位上链上数据过多(即拉链过长的情况)导致性能下降该怎么办?
    JDK1.8在JDK1.7的基础上针对增加了红黑树来进行优化。即当链表超过8时,链表就转换为红黑树,利用红黑树快速增删改查的特点提高HashMap的性能,其中会用到红黑树的插入、删除、查找等算法。
    关于这方面的探讨我们以后的文章再做说明。
    附:HashMap put方法逻辑图(JDK1.8)
    在这里插入图片描述

    展开全文
  • java计算两个时间差值

    千次阅读 2019-01-21 21:02:51
     java计算两字符串时间差值和两Date时间差值,判断两个时间大小注意:  计算机时间是1970年1月1日0点规定为时间起点. 1.示例 /** 比较两字符串时间大小 */ public static int compareTwoTime(String time1...

    场景:
        java计算两个字符串时间差值和两个Date时间差值,判断两个时间大小
    注意:
        计算机时间是1970年1月1日0点规定为时间起点.
    1.示例

    	/** 比较两个字符串时间大小 */
    	public static int compareTwoTime(String time1, String time2) {
    
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
    				"yyyy-MM-dd HH:mm:ss");
    		int flagValue = 0;
    		try {
    			Date date1, date2;
    			date1 = simpleDateFormat.parse(time1);
    			date2 = simpleDateFormat.parse(time2);
    			long millisecond = date1.getTime() - date2.getTime();
    			if (millisecond > 0) {
    				flagValue = 1;
    			} else if (millisecond < 0) {
    				flagValue = -1;
    			} else if (millisecond == 0) {
    				flagValue = 0;
    			}
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return (flagValue);
    	}
    
    	/** 表两个时间差 */
    	public static int compareTwoTime(Date time1, Date time2) {
    		int flagValue = 0;
    		try {
    			long millisecond = time1.getTime() - time2.getTime();
    			if (millisecond > 0) {
    				flagValue = 1;
    			} else if (millisecond < 0) {
    				flagValue = -1;
    			} else if (millisecond == 0) {
    				flagValue = 0;
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return (flagValue);
    	}
    
    	/** 比较两个时间相差天数 */
    	public static float calculateTimeGapDay(String time1, String time2) {
    
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
    				"yyyy-MM-dd HH:mm:ss");
    
    		float day = 0;
    		Date date1 = null;
    		Date date2 = null;
    
    		try {
    			date1 = simpleDateFormat.parse(time1);
    			date2 = simpleDateFormat.parse(time2);
    			long millisecond = date2.getTime() - date1.getTime();
    			day = millisecond / (24 * 60 * 60 * 1000);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return (day);
    	}
    
    	/** 比较两个时间相差天数 */
    	public static float calculateTimeGapDay(Date time1, Date time2) {
    		float day = 0;
    		try {
    			Date date1, date2;
    			date1 = time1;
    			date2 = time2;
    			long millisecond = date2.getTime() - date1.getTime();
    			day = millisecond / (24 * 60 * 60 * 1000);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return (day);
    	}
    
    	/** 比较两个时间相差小时 */
    	public static double calculatetimeGapHour(String time1, String time2) {
    
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
    				"yyyy-MM-dd HH:mm:ss");
    		double hour = 0;
    		try {
    			Date date1, date2;
    			date1 = simpleDateFormat.parse(time1);
    			date2 = simpleDateFormat.parse(time2);
    			double millisecond = date2.getTime() - date1.getTime();
    			hour = millisecond / (60 * 60 * 1000);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return hour;
    	}
    
    	/** 比较两个时间相差小时 */
    	public static double calculatetimeGapHour(Date date1, Date date2) {
    		double hour = 0;
    		double millisecond = date2.getTime() - date1.getTime();
    		hour = millisecond / (60 * 60 * 1000);
    		return hour;
    	}
    
    	/** 比较两个时间相差分钟 */
    	public static double calculatetimeGapMinute(String time1, String time2) {
    
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
    				"yyyy-MM-dd HH:mm:ss");
    		double minute = 0;
    		try {
    			Date date1, date2;
    			date1 = simpleDateFormat.parse(time1);
    			date2 = simpleDateFormat.parse(time2);
    			double millisecond = date2.getTime() - date1.getTime();
    			minute = millisecond / (60 * 1000);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return minute;
    	}
    
    	/** 比较两个时间相差分钟 */
    	public static double calculatetimeGapMinute(Date date1, Date date2) {
    		double minute = 0;
    		double millisecond = date2.getTime() - date1.getTime();
    		minute = millisecond / (60 * 1000);
    		return minute;
    	}
    
    	/** 比较两个时间相差秒 */
    	public static double calculatetimeGapSecond(String time1, String time2) {
    
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
    				"yyyy-MM-dd HH:mm:ss");
    		double second = 0;
    		try {
    			Date date1, date2;
    			date1 = simpleDateFormat.parse(time1);
    			date2 = simpleDateFormat.parse(time2);
    			double millisecond = date2.getTime() - date1.getTime();
    			second = millisecond / (1000);
    		} catch (ParseException e) {
    			e.printStackTrace();
    		}
    		return second;
    	}
    
    	/** 比较两个时间相差秒 */
    	public static double calculatetimeGapSecond(Date date1, Date date2) {
    		double second = 0;
    		double millisecond = date2.getTime() - date1.getTime();
    		second = millisecond / (1000);
    		return second;
    	}
    	

    以上,TKS.

    展开全文
  • 1.前言链表是种非常基础也非常重要的数据结构,在实际中使用非常广泛,也是各种面试里特别容易出现的类型。尤其在各大IT公司的校招中,不管笔试还是面试,链表几乎都是必出现的题型。因此不管从实际工作场景中,...

    项目github地址:bitcarmanlee easy-algorithm-interview-and-practice
    欢迎大家star,留言,一起学习进步

    1.前言

    链表是一种非常基础也非常重要的数据结构,在实际中使用非常广泛,也是各种面试里特别容易出现的类型。尤其在各大IT公司的校招中,不管笔试还是面试,链表几乎都是必出现的题型。因此不管从实际工作场景中,还是在找工作的过程中,熟练掌握链表的相关操作都显得非常重要。

    看看wiki里给链表的介绍:
    链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而顺序表相应的时间复杂度分别是O(logn)和O(1)。

    使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。

    在计算机科学中,链表作为一种基础的数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成,每个节点包含任意的实例数据(data fields)和一或两个用来指向上一个/或下一个节点的位置的链接(“links”)。链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的访问往往要在不同的排列顺序中转换。而链表是一种自我指示数据类型,因为它包含指向另一个相同类型的数据的指针(链接)。链表允许插入和移除表上任意位置上的节点,但是不允许随机存取。链表有很多种不同的类型:单向链表,双向链表以及循环链表。

    理论部分就介绍到这里,相信只要稍微有点计算机基础的同学都能看懂是什么意思。接下来,我们上代码,看看怎么在java中实现链表的相关操作。

    2.链表的初始化

    一般链表初始化的时候,会将Node节点作为内部类至于LinkedList中。但是因为这次我们的操作比较多,代码比较复杂,为了方便起见,将Node类单独拎出来作为一个类。

    public class Node<T> {
    
        public T data;
        public Node next;
    
        public Node(T data) {
            this.data = data;
        }
    }
    
    

    Node类很简单,一个数值域data,一个指针域next,另外加一个构造方法。
    接下来看我们的MyLinkedList类:

    public class MyLinkedList {
    
        public Node head;
        public Node current;
    
        public void add(int data) {
    
            //如果头结点为空,为头结点
            if(head == null) {
                head = new Node(data);
                current = head;
            } else {
                current.next = new Node(data);
                current = current.next;
            }
        }
    
        //打印链表
        public void print(Node node) {
            if(node == null) {
                return;
            }
    
            current = node;
            while(current != null) {
                System.out.print(current.data + " ");
                current = current.next;
            }
        }
    
        //初始化链表,并且返回表头
        public Node init() {
            for(int i=0; i<10; i++) {
                this.add(i);
            }
            return head;
        }
    
        //求链表长度
        public int get_length(Node head) {
            if (head == null) {
                return -1;
            }
    
            int length = 0;
            current = head;
            while(current != null) {
                length++;
                current = current.next;
            }
    
            return length;
        }
    
    }
    

    这个MyLinkedList类中,包含有添加节点,打印链表,初始化链表,以及求链表长度的操作。MyLinkedList类以及Node类,将在我们后续的代码中多处被使用到。

    3.初步测试

    public class TestDemo {
    
        public static void main(String[] args) {
            MyLinkedList list = new MyLinkedList();
            Node head = list.init();
            list.print(head);
    
            int length = list.get_length(head);
            System.out.println();
            System.out.println("The length of list is: " + length);
        }
    }
    

    将测试代码run起来:

    0 1 2 3 4 5 6 7 8 9 
    The length of list is: 10
    
    展开全文
  • java判断一个Date时间在不在某段Date时间范围之内
  • Java发展的时间表。 (版本号 名称 中文名 发布日期)  JDK 1.1.4 Sparkler 宝石 1997-09-12  JDK 1.1.5 Pumpkin 南瓜 1997-12-13  JDK 1.1.6 Abigail 阿比盖尔--女子名 1998-04-24  JDK 1.1.7 Brutus 布...
  • java实现日程

    万次阅读 多人点赞 2019-07-30 12:03:57
    上级要求每人每周的工作日和休息日必须是固定的,不能在周间变更。 此外,由于工作需要,还有如下要求: 1. 所有人的连续工作日不能多于3天(注意:周日连到下周也是连续)。 2. 周中,至少有3天所有人都是...
  • JavaJava计时器(秒表)

    万次阅读 多人点赞 2016-01-12 21:13:02
    应用名称:Java计时器 用到的知识:Java GUI编程 开发环境:win8+eclipse+jdk1.8 效果图: 源代码: import javax.swing.*; import java.awt.HeadlessException; import java.awt.BorderLayout; ...
  • 设置Java导出Excel表头

    千次阅读 2015-11-04 14:35:06
    1、问题背景 有一个学生,需要导出到Excel,有学号、姓名、性别和年龄四个字段2、实现源码/** * * @Project:Report * @Title:ExcelExport.java * @Package:com.you.excel * @Description: * @Author:...
  • java 做一个真的进度条去实时获取方法进行状态

    万次阅读 热门讨论 2017-11-16 10:24:35
    场景: 导入案件的时候,由于导入数据量大的时候。loading的前台效果要转很久给用户...导入案件的后台操作比较复杂,没有想出在方法执行完毕之前去前台返回各个状态的值,方法里包含excel数据的校验和条数据要分别导
  • 一个字符串的字符按ASCII的顺序从小到大排序,如将字符串“asdafxcvMADb”排序为“ADMaabcdfsvx” 算法的基本思想: 先将字符串转化为一个char类型的数组,来进行存储(因Java中的字符串并不像C++中那样直接使用...
  • Java线程池七参数详解

    万次阅读 多人点赞 2019-04-23 11:14:33
    java多线程开发时,常常用到线程池技术,这篇文章是对创建java线程池时的七参数的详细解释。 从源码中可以看出,线程池的构造函数有7参数,分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、...
  • Java】用java打印中文九九乘法

    万次阅读 多人点赞 2018-05-04 17:30:56
    在练习java基础的时候,想到了一个经典的案例九九乘法,随后于是敲下了如下代码:package jiujiuchengfabiao; public class convert { public static void main(String[] args) { for (int i = 1; i &lt;...
  • java不难,你可以如下学习 、到相应的培训机构付费学习 别在这说培训机构没用什么的,不过一定要找正规的培训机构,不然容易被坑。培训机构里面的课程都是现在工作中需要用到的,时间短,所以可能学生消化得没...
  • Java实现链表结构

    万次阅读 多人点赞 2012-08-19 22:09:18
    Java实现链表结构这里主要记录了一下学习用Java实现链表的方法。假设你有一点Java基础,了解...(最近读严老师应该没记错名字吧,如果错了抱歉>的帖子说应该在博文中说明帖子的读者范围,不要浪费大家的时间,这最近写
  • Java虚拟机(JVM)你只要看这篇就够了!

    万次阅读 多人点赞 2018-08-14 12:55:02
    1. Java 内存区域与内存溢出异常 ...字节码解释器工作是就是通过改变这计数器的值来选取下条需要执行指令的字节码指令,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖计数器完成 如果线程正...
  • 一个牛人给JAVA初学者的建议

    万次阅读 多人点赞 2018-10-22 19:14:55
    给初学者之一:浅谈java及应用 学java不知不觉也已经三年了...由于我国高等教育制度教材陈旧,加上java自身发展不过十年左右的时间,还有一个很重要的原因就是java这门语言更适合商业应用,所以高校里大部分博士老...
  • java从oracle中获取个人信息中的生日(日期时间),有的小一个小时,有的正常。 数据库中:1987-08-21 返回前端为: 1987-08-20 23:00:00 而1999-07-22 等前台返回的就是 1999-07-22 00:00:00
  • 如上所述。如果修改就返回false没有就返回true。然后在另一个地方绑定onblur事件。判断false就触发事件,true就不触发事件?
  • Java数据结构与算法解析()——

    万次阅读 多人点赞 2017-08-27 13:27:07
    线性表是一个线性结构,它是一个含有n≥0个结点的有限序列,对于其中的结点,有且仅有一个开始结点没有前驱但有一个后继结点,有且仅有一个终端结点没有后继但有一个前驱结点,其它的结点都有且仅有一个前驱和一个...
  • 工作三年Java程序员计划##3年内 ## 6月 – HTML+css + jsp/servlet + ssh+ mysql+maven+ git+svn . 6月到一年内– 写博客,读透彻 java编程基础 一年到2年– 造轮子–设计模式熟练手写–重构–effective Java...
  • java中HashMap与Hash详解

    万次阅读 多人点赞 2018-04-03 09:44:39
    转载至... 哈希算法,是类算法; 哈希(Hash Table)是种数据结构; 哈希函数,是支撑哈希类函数;...Map是映射、地图的意思,在Java中Map表示种把K映...
  • 一个class文件深入理解Java字节码结构

    万次阅读 多人点赞 2018-05-15 10:01:56
    前言 我们都知道,Java程序最终是转换成class文件执行在虚拟机上的,那么class文件是个怎样的结构,虚拟机又是...首先,编写一个简单的Java源码: package com.april.test; public class Demo { private int n...
  • java项目组月度考核(KPI)

    万次阅读 2014-03-26 12:01:16
    为了保密性,我将个人信息隐藏了...每次的PKI表格。  * 月度考核 姓名: ** 考核周期: 3月01日 --- 3月31日  部门: **开发部 岗 位: java开发工程师  KPI   内容
  • java数据结构与算法之顺序与链表深入分析

    万次阅读 多人点赞 2016-11-05 16:24:30
    开篇直接奔主题,无论是顺序还是链表,它们都是线性表的种,用比较官方的话来讲,线性表是其组成元素间具有线性关系的种线性结构,而我们恰好可以采用顺序存储和链式存储结构来表示线性表。接下来将从以下几点...
  • 使用Java+MySQL一个简单的注册登录页面

    万次阅读 多人点赞 2016-04-17 20:33:35
    昨天开始接触MySQL数据库,大概熟悉了一下在java中操作mysql数据库的基本用法,今天尝试着上手一个简单的注册登录的小例子,包括界面布局等,纯手工,感觉收获满满,特来分享一下。 我只用了5个类,包括 “连接...
  • 今天同事拿了个问题问我,有一个回调工程,会一直查询今日订单和回调中的订单数据,然后这条sql今日订单日期是动态的, select * from QYPT_QUERY_GOODS goods,qypt_pay_history_20180512 pay where goods....
  • 今天继续分享一道Java经典面试题: 题目描述:Java 中的 LinkedList 是单向链表...于是对于LinkedList的实现了进一步的探索,得到了这些知识(注:看懂下面的知识需要一些数据结构的知识): Java—–Colle...
  • java中的线程控制程序从一个数据库中定时自动抽取数据到另一个数据库,实现数据库的同步。代码很详细。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 757,302
精华内容 302,920
关键字:

java做一个时间表

java 订阅