第一次面试,我差点被面试官打,就因为Collections.sort

开发 前端
该篇文章主要分享隐藏在Collections.sort()中的坑,有兴趣的看看,已经知道的可以无视。

[[409387]]

本文转载自微信公众号「稀饭下雪」,作者帅气的小饭饭。转载本文请联系稀饭下雪公众号。

该篇文章主要分享隐藏在Collections.sort()中的坑,有兴趣的看看,已经知道的可以无视。

是这样的,今天在review邓老弟的代码的时候,看到一段这样的实现

大家先看看这种写法有没有问题?

觉得没有问题的hxd们就要好好看这篇文章了。

我记得那是三年前的一个下雨天,那雨下的比依萍回陆家拿生活费那天还大

[[409388]]

依萍

我颤颤巍巍的走进了一家办公室,脚步沉重,毕竟这是我第一次面试

「底气不足的小饭饭:」 你好,我是小饭饭,我是来面试的

[[409389]]

瘦小的我

「彪形大汉:」 小李是吧,坐

[[409390]]

一面面试官

我是xxx公司的面试官斯坦森,看你简历还不错,很少会有实习生敢写精通java的,来,我考考你

这么写有什么问题吗?

「底气不足的小饭饭:」 卧槽,竟然还有姓斯的,不过还好,这道题不难 (⊙o⊙)…

这很简单,updateTime1和updateTime2都是long类型,用int强转有可能导致溢出

「彪形大汉:」 嗯,对,还有呢

继续说下去

「底气不足的小饭饭:」 还有?我想想看

还有就是这样会导致排序出现混乱,可能导致大的在前面

「彪形大汉:」 嗯,对,还有呢

「底气不足的小饭饭:」 还有?没有了啊,其他的我不知道了

「彪形大汉:」 嗯,你能答出前两个,对Java的了解算是熟悉了,不过还没达到精通的程度

还有一个问题,当溢出的时候被int强转会变成负数,从而导致这个函数被调用的时候极有可能会触发以下异常

「已经丢了offer的小饭饭:」 为什么会出发异常?

「彪形大汉:」 你可能不知道,

Collections.sort()在JDK6和JDK7中实现的底层排序算法是不一样的在JDK6中使用的是MergeSort排序,而在JDK7中使用的是TimSort,

使用TimSort排序算法对比较大小的要求更高

问题原因是,对某些数据来说,上述代码会导致compare(a,b)<0并且compare(b,a)<0,也就是a

当这类数据遇到某些特殊情况时,就会发生这个异常。

给你贴一波大家都看不懂的源码占占字数

  1. private void mergeHi(int base1, int len1, int base2, int len2) { 
  2.         assert len1 > 0 && len2 > 0 && base1 + len1 == base2; 
  3.  
  4.         // Copy second run into temp array 
  5.         T[] a = this.a; // For performance 
  6.         T[] tmp = ensureCapacity(len2); 
  7.         int tmpBase = this.tmpBase; 
  8.         System.arraycopy(a, base2, tmp, tmpBase, len2); 
  9.  
  10.         int cursor1 = base1 + len1 - 1;  // Indexes into a 
  11.         int cursor2 = tmpBase + len2 - 1; // Indexes into tmp array 
  12.         int dest = base2 + len2 - 1;     // Indexes into a 
  13.  
  14.         // Move last element of first run and deal with degenerate cases 
  15.         a[dest--] = a[cursor1--]; 
  16.         if (--len1 == 0) { 
  17.             System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2); 
  18.             return
  19.         } 
  20.         if (len2 == 1) { 
  21.             dest -= len1; 
  22.             cursor1 -= len1; 
  23.             System.arraycopy(a, cursor1 + 1, a, dest + 1, len1); 
  24.             a[dest] = tmp[cursor2]; 
  25.             return
  26.         } 
  27.  
  28.         Comparator<? super T> c = this.c;  // Use local variable for performance 
  29.         int minGallop = this.minGallop;    //  "    "       "     "      " 
  30.     outer
  31.         while (true) { 
  32.             int count1 = 0; // Number of times in a row that first run won 
  33.             int count2 = 0; // Number of times in a row that second run won 
  34.  
  35.             /* 
  36.              * Do the straightforward thing until (if ever) one run 
  37.              * appears to win consistently. 
  38.              */ 
  39.             do { 
  40.                 assert len1 > 0 && len2 > 1; 
  41.                 if (c.compare(tmp[cursor2], a[cursor1]) < 0) { 
  42.                     a[dest--] = a[cursor1--]; 
  43.                     count1++; 
  44.                     count2 = 0; 
  45.                     if (--len1 == 0) 
  46.                         break outer
  47.                 } else { 
  48.                     a[dest--] = tmp[cursor2--]; 
  49.                     count2++; 
  50.                     count1 = 0; 
  51.                     if (--len2 == 1) 
  52.                         break outer
  53.                 } 
  54.             } while ((count1 | count2) < minGallop); 
  55.  
  56.             /* 
  57.              * One run is winning so consistently that galloping may be a 
  58.              * huge win. So try that, and continue galloping until (if ever) 
  59.              * neither run appears to be winning consistently anymore. 
  60.              */ 
  61.             do { 
  62.                 assert len1 > 0 && len2 > 1; 
  63.                 count1 = len1 - gallopRight(tmp[cursor2], a, base1, len1, len1 - 1, c); 
  64.                 if (count1 != 0) { 
  65.                     dest -= count1; 
  66.                     cursor1 -= count1; 
  67.                     len1 -= count1; 
  68.                     System.arraycopy(a, cursor1 + 1, a, dest + 1, count1); 
  69.                     if (len1 == 0) 
  70.                         break outer
  71.                 } 
  72.                 a[dest--] = tmp[cursor2--]; 
  73.                 if (--len2 == 1) 
  74.                     break outer
  75.  
  76.                 count2 = len2 - gallopLeft(a[cursor1], tmp, tmpBase, len2, len2 - 1, c); 
  77.                 if (count2 != 0) { 
  78.                     dest -= count2; 
  79.                     cursor2 -= count2; 
  80.                     len2 -= count2; 
  81.                     System.arraycopy(tmp, cursor2 + 1, a, dest + 1, count2); 
  82.                     if (len2 <= 1)  // len2 == 1 || len2 == 0 
  83.                         break outer
  84.                 } 
  85.                 a[dest--] = a[cursor1--]; 
  86.                 if (--len1 == 0) 
  87.                     break outer
  88.                 minGallop--; 
  89.             } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP); 
  90.             if (minGallop < 0) 
  91.                 minGallop = 0; 
  92.             minGallop += 2;  // Penalize for leaving gallop mode 
  93.         }  // End of "outer" loop 
  94.         this.minGallop = minGallop < 1 ? 1 : minGallop;  // Write back to field 
  95.  
  96.         if (len2 == 1) { 
  97.             assert len1 > 0; 
  98.             dest -= len1; 
  99.             cursor1 -= len1; 
  100.             System.arraycopy(a, cursor1 + 1, a, dest + 1, len1); 
  101.             a[dest] = tmp[cursor2];  // Move first elt of run2 to front of merge 
  102.         } else if (len2 == 0) { 
  103.             throw new IllegalArgumentException( 
  104.                 "Comparison method violates its general contract!"); 
  105.         } else { 
  106.             assert len1 == 0; 
  107.             assert len2 > 0; 
  108.             System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2); 
  109.         } 
  110.     } 

看不懂没关系,我也看不懂,不过原理大概是这样的,我们假定:

a<b && b<a,也就是代码中出现的bug

假定输入数组a[] = {5,a,7,12,4,b,8,8},其中待归并的两个有序数组分别是{5,a,7,12}和{4,b,8,8}

假定b<7&&7>b。这样可以触发“特殊情况”,即:a和b在某一次归并操作后,会同时成为“是否移动元素”的临界条件。

首先,我们有两个有序数组A和B,如下图所示。

找到待归并区间、做好准备操作:

这样,在划分完待归并区间后,得到的结果是这样的:

第一次归并操作:C2落在了元素b上;

然后,开始第一次归并操作。由于B'[C2]>A'[C1],我们需要从C2开始,在数组B'中找到一个下标n,使得B'[n]

这里需要注意两点:首先,临界点的比较条件是B'[n]

这样,第一轮归并完成后的结果是这样的:

第二次归并操作:C1落在了元素a上:

接下来做第二次归并操作。由于A'[C1]>B'[C2](这是先决条件里的第三点:b<7&&7>b),我们需要从C1开始,从A'中找到一个下标m,使得A'[m]

这里需要注意比较的顺序性和区间半包性。

这一轮操作完,得到的结果是:

第三、四步操作:出现空集、死循环

可以看到,由于此时A'[C1]

然后,由于B'[C2]

如果不加干预,排序操作会在这里无限循环下去。TimSort中的干预方式就是当检测到空集时,抛出异常。

「没看懂没关系,总归就是能答出以下三个,其实就算你满分了:」

  • updateTime1和updateTime2都是long类型,用int强转有可能导致溢出
  • 导致排序出现混乱
  • 因为溢出变成负数,导致排序出现空集、死循环,而TimSort中的干预方式就是当检测到空集时,抛出异常

「彪形大汉:」 虽然你这道题答的一半,但是我给你个补救的机会,怎么解决这个问题

「恢复斗志的小饭饭:」 确保compare(a,b)操作中,如果a>b,那么b

也就是说需要满足以下条件

  • (x op y)的结果必须与(y op x)的结果相反。即,如果a>b,那么b
  • 传递性。即,如果a>b, b>c,那么a>c。
  • x==y时,(x op z) = ( y op z )

其实最好是将答案委托给Java基础类,也就是

「彪形大汉:」 嗯,不错,算是达到及格线了,你再坐会,我去叫下二面的面试官。

这个时候另一个彪形大汉走了进来

[[409395]]

二面面试官

面试流程未完,待续...........

原文链接:https://mp.weixin.qq.com/s/wPIKqEUgP2mTqFvUAv84Uw

 

责任编辑:武晓燕 来源: 稀饭下雪
相关推荐

2020-05-12 11:05:54

MySQL索引数据库

2020-06-22 07:47:46

提交面试官订单

2015-07-14 09:40:57

携程面试前端面试官

2021-12-17 07:30:42

排序算法效率

2020-08-03 07:04:54

测试面试官应用程序

2020-07-13 08:40:48

同事代码

2020-05-22 08:11:48

线程池JVM面试

2024-01-03 21:50:32

缓存机制请求

2024-02-26 08:37:02

Feign项目接口

2024-04-17 08:18:22

MyBatis批量插入SQL

2021-12-02 08:19:06

MVCC面试数据库

2011-07-21 21:01:37

诺基亚塞班苹果

2021-02-05 08:35:21

私活程序员

2023-12-25 09:03:33

MySQL索引数据库

2017-03-22 15:38:28

代码架构Java

2015-04-13 10:32:32

2021-03-16 22:25:06

作用域链作用域JavaScript

2021-03-17 08:39:24

作用域作用域链JavaScript

2015-08-13 10:29:12

面试面试官

2021-09-28 13:42:55

Chrome Devwebsocket网络协议
点赞
收藏

51CTO技术栈公众号