标签：heapsort 好的 面试题1 sys art EAP author 插入 不可
1、简述synchroized和java.util.concurrent.locks.Lock的异同？
1.synchronized 用在方法和代码块的区别? a. 可以只对需要同步的使用 b.与wait（），notify（）和notifyall（）方法使用比较方便 2.wait（） a。释放持有的对象锁，线程进入等待池，释放cpu，其他正在等待的线程可以获得锁，而sleep方法，线程会休眠一段时间，线程不会释放锁。 3.ReentrantLock 还包括了中断锁等待和定时锁等待， 在并发量小的时候，用synchronize是比较好的选择，并发量大的时候用Lock。 synchronize是自动释放锁，Lock是主动释放锁 Lock可以设定所等待的时间， 有些操作不会发生冲突现象，需要用Lock解决，比如同时读文件。
2、Collerction框架中实现比较要实现什么接口？
Comparable和Comparator接口 如果一个类的不同对象需要比较大小，那么就需要实现这两个接口，根据业务需求定义规则。 使用区别: (1)Comparable接口 是需要比较的类实现自己实现，例如：定义的Student类需要比较,需要Student类自己实现这个接口，实现ComParaTo()方法。 (2)Comparator接口 自己定义一个比较容器，去实现这个接口（实现compare方法），然后在集合生成的时候，用一个比较对象做参数，跟集合绑定。 例： Class A implements Comparator{}//定义比较容器，实现compare方法 A a = new A();//生成比较对象 Set set = new TreeSet(a);//构造集合对象时，传入比较器。
3、java排序都有哪几种方法？请列举
1 排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序） 2 用Java语言实现的各种排序，包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。 3 4 插入排序： 5 6 package org.rut.util.algorithm.support; 7 8 import org.rut.util.algorithm.SortUtil; 9 /** 10 * @author dongji 11 * @since 2019-12-28 12 * @version 1.0 13 */ 14 public class InsertSort implements SortUtil.Sort{ 15 16 /* (non-Javadoc) 17 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 18 */ 19 public void sort(int[] data) { 20 int temp; 21 for(int i=1;i<data.length;i++){ 22 for(int j=i;(j>0)&&(data[j]<data[j-1]);j–){ 23 SortUtil.swap(data,j,j-1); 24 } 25 } 26 } 27 28 } 29 30 冒泡排序： 31 32 package org.rut.util.algorithm.support; 33 34 import org.rut.util.algorithm.SortUtil; 35 36 /** 37 * @author dongji 38 * @since 2019-12-28 39 * @version 1.0 40 */ 41 public class BubbleSort implements SortUtil.Sort{ 42 43 /* (non-Javadoc) 44 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 45 */ 46 public void sort(int[] data) { 47 int temp; 48 for(int i=0;i<data.length;i++){ 49 for(int j=data.length-1;j>i;j–){ 50 if(data[j]<data[j-1]){ 51 SortUtil.swap(data,j,j-1); 52 } 53 } 54 } 55 } 56 57 } 58 59 选择排序： 60 61 package org.rut.util.algorithm.support; 62 63 import org.rut.util.algorithm.SortUtil; 64 65 /** 66 * @author dongji 67 * @since 2019-12-28 68 * @version 1.0 69 */ 70 public class SelectionSort implements SortUtil.Sort { 71 72 /* 73 * (non-Javadoc) 74 * 75 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 76 */ 77 public void sort(int[] data) { 78 int temp; 79 for (int i = 0; i < data.length; i++) { 80 int lowIndex = i; 81 for (int j = data.length – 1; j > i; j–) { 82 if (data[j] < data[lowIndex]) { 83 lowIndex = j; 84 } 85 } 86 SortUtil.swap(data,i,lowIndex); 87 } 88 } 89 90 } 91 92 Shell排序： 93 94 package org.rut.util.algorithm.support; 95 96 import org.rut.util.algorithm.SortUtil; 97 98 /** 99 * @author dongji 100 * @since 2019-12-28 101 * @version 1.0 102 */ 103 public class ShellSort implements SortUtil.Sort{ 104 105 /* (non-Javadoc) 106 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 107 */ 108 public void sort(int[] data) { 109 for(int i=data.length/2;i>2;i/=2){ 110 for(int j=0;j<i;j++){ 111 insertSort(data,j,i); 112 } 113 } 114 insertSort(data,0,1); 115 } 116 117 /** 118 * @param data 119 * @param j 120 * @param i 121 */ 122 private void insertSort(int[] data, int start, int inc) { 123 int temp; 124 for(int i=start+inc;i<data.length;i+=inc){ 125 for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){ 126 SortUtil.swap(data,j,j-inc); 127 } 128 } 129 } 130 131 } 132 133 快速排序： 134 135 package org.rut.util.algorithm.support; 136 137 import org.rut.util.algorithm.SortUtil; 138 139 /** 140 * @author dongji 141 * @since 2019-12-28 142 * @version 1.0 143 */ 144 public class QuickSort implements SortUtil.Sort{ 145 146 /* (non-Javadoc) 147 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 148 */ 149 public void sort(int[] data) { 150 quickSort(data,0,data.length-1); 151 } 152 private void quickSort(int[] data,int i,int j){ 153 int pivotIndex=(i+j)/2; 154 //swap 155 SortUtil.swap(data,pivotIndex,j); 156 157 int k=partition(data,i-1,j,data[j]); 158 SortUtil.swap(data,k,j); 159 if((k-i)>1) quickSort(data,i,k-1); 160 if((j-k)>1) quickSort(data,k+1,j); 161 162 } 163 /** 164 * @param data 165 * @param i 166 * @param j 167 * @return 168 */ 169 private int partition(int[] data, int l, int r,int pivot) { 170 do{ 171 while(data[++l]<pivot); 172 while((r!=0)&&data[--r]>pivot); 173 SortUtil.swap(data,l,r); 174 } 175 while(l<r); 176 SortUtil.swap(data,l,r); 177 return l; 178 } 179 180 } 181 182 改进后的快速排序： 183 184 package org.rut.util.algorithm.support; 185 186 import org.rut.util.algorithm.SortUtil; 187 188 /** 189 * @author dongji 190 * @since 2019-12-28 191 * @version 1.0 192 */ 193 public class ImprovedQuickSort implements SortUtil.Sort { 194 195 private static int MAX_STACK_SIZE=4096; 196 private static int THRESHOLD=10; 197 /* (non-Javadoc) 198 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 199 */ 200 public void sort(int[] data) { 201 int[] stack=new int[MAX_STACK_SIZE]; 202 203 int top=-1; 204 int pivot; 205 int pivotIndex,l,r; 206 207 stack[++top]=0; 208 stack[++top]=data.length-1; 209 210 while(top>0){ 211 int j=stack[top--]; 212 int i=stack[top--]; 213 214 pivotIndex=(i+j)/2; 215 pivot=data[pivotIndex]; 216 217 SortUtil.swap(data,pivotIndex,j); 218 219 //partition 220 l=i-1; 221 r=j; 222 do{ 223 while(data[++l]<pivot); 224 while((r!=0)&&(data[--r]>pivot)); 225 SortUtil.swap(data,l,r); 226 } 227 while(l<r); 228 SortUtil.swap(data,l,r); 229 SortUtil.swap(data,l,j); 230 231 if((l-i)>THRESHOLD){ 232 stack[++top]=i; 233 stack[++top]=l-1; 234 } 235 if((j-l)>THRESHOLD){ 236 stack[++top]=l+1; 237 stack[++top]=j; 238 } 239 240 } 241 //new InsertSort().sort(data); 242 insertSort(data); 243 } 244 /** 245 * @param data 246 */ 247 private void insertSort(int[] data) { 248 int temp; 249 for(int i=1;i<data.length;i++){ 250 for(int j=i;(j>0)&&(data[j]<data[j-1]);j–){ 251 SortUtil.swap(data,j,j-1); 252 } 253 } 254 } 255 256 } 257 258 归并排序： 259 260 package org.rut.util.algorithm.support; 261 262 import org.rut.util.algorithm.SortUtil; 263 264 /** 265 * @author dongji 266 * @since 2019-12-28 267 * @version 1.0 268 */ 269 public class MergeSort implements SortUtil.Sort{ 270 271 /* (non-Javadoc) 272 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 273 */ 274 public void sort(int[] data) { 275 int[] temp=new int[data.length]; 276 mergeSort(data,temp,0,data.length-1); 277 } 278 279 private void mergeSort(int[] data,int[] temp,int l,int r){ 280 int mid=(l+r)/2; 281 if(l==r) return ; 282 mergeSort(data,temp,l,mid); 283 mergeSort(data,temp,mid+1,r); 284 for(int i=l;i<=r;i++){ 285 temp[i]=data[i]; 286 } 287 int i1=l; 288 int i2=mid+1; 289 for(int cur=l;cur<=r;cur++){ 290 if(i1==mid+1) 291 data[cur]=temp[i2++]; 292 else if(i2>r) 293 data[cur]=temp[i1++]; 294 else if(temp[i1]<temp[i2]) 295 data[cur]=temp[i1++]; 296 else 297 data[cur]=temp[i2++]; 298 } 299 } 300 301 } 302 303 改进后的归并排序: 304 305 package org.rut.util.algorithm.support; 306 307 import org.rut.util.algorithm.SortUtil; 308 309 /** 310 * @author dongji 311 * @since 2019-12-28 312 * @version 1.0 313 */ 314 public class ImprovedMergeSort implements SortUtil.Sort { 315 316 private static final int THRESHOLD = 10; 317 318 /* 319 * (non-Javadoc) 320 * 321 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 322 */ 323 public void sort(int[] data) { 324 int[] temp=new int[data.length]; 325 mergeSort(data,temp,0,data.length-1); 326 } 327 328 private void mergeSort(int[] data, int[] temp, int l, int r) { 329 int i, j, k; 330 int mid = (l + r) / 2; 331 if (l == r) 332 return; 333 if ((mid – l) >= THRESHOLD) 334 mergeSort(data, temp, l, mid); 335 else 336 insertSort(data, l, mid – l + 1); 337 if ((r – mid) > THRESHOLD) 338 mergeSort(data, temp, mid + 1, r); 339 else 340 insertSort(data, mid + 1, r – mid); 341 342 for (i = l; i <= mid; i++) { 343 temp[i] = data[i]; 344 } 345 for (j = 1; j <= r – mid; j++) { 346 temp[r - j + 1] = data[j + mid]; 347 } 348 int a = temp[l]; 349 int b = temp[r]; 350 for (i = l, j = r, k = l; k <= r; k++) { 351 if (a < b) { 352 data[k] = temp[i++]; 353 a = temp[i]; 354 } else { 355 data[k] = temp[j--]; 356 b = temp[j]; 357 } 358 } 359 } 360 361 /** 362 * @param data 363 * @param l 364 * @param i 365 */ 366 private void insertSort(int[] data, int start, int len) { 367 for(int i=start+1;i<start+len;i++){ 368 for(int j=i;(j>start) && data[j]<data[j-1];j–){ 369 SortUtil.swap(data,j,j-1); 370 } 371 } 372 } 373 374 } 375 376 堆排序： 377 378 package org.rut.util.algorithm.support; 379 380 import org.rut.util.algorithm.SortUtil; 381 382 /** 383 * @author dongji 384 * @since 2019-12-28 385 * @version 1.0 386 */ 387 public class HeapSort implements SortUtil.Sort{ 388 389 /* (non-Javadoc) 390 * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) 391 */ 392 public void sort(int[] data) { 393 MaxHeap h=new MaxHeap(); 394 h.init(data); 395 for(int i=0;i<data.length;i++) 396 h.remove(); 397 System.arraycopy(h.queue,1,data,0,data.length); 398 } 399 400 private static class MaxHeap{ 401 402 void init(int[] data){ 403 this.queue=new int[data.length+1]; 404 for(int i=0;i<data.length;i++){ 405 queue[++size]=data[i]; 406 fixUp(size); 407 } 408 } 409 410 private int size=0; 411 412 private int[] queue; 413 414 public int get() { 415 return queue[1]; 416 } 417 418 public void remove() { 419 SortUtil.swap(queue,1,size–); 420 fixDown(1); 421 } 422 //fixdown 423 private void fixDown(int k) { 424 int j; 425 while ((j = k << 1) <= size) { 426 if (j < size && queue[j]<queue[j+1]) 427 j++; 428 if (queue[k]>queue[j]) //不用交换 429 break; 430 SortUtil.swap(queue,j,k); 431 k = j; 432 } 433 } 434 private void fixUp(int k) { 435 while (k > 1) { 436 int j = k >> 1; 437 if (queue[j]>queue[k]) 438 break; 439 SortUtil.swap(queue,j,k); 440 k = j; 441 } 442 } 443 444 } 445 446 } 447 448 SortUtil： 449 450 package org.rut.util.algorithm; 451 452 import org.rut.util.algorithm.support.BubbleSort; 453 import org.rut.util.algorithm.support.HeapSort; 454 import org.rut.util.algorithm.support.ImprovedMergeSort; 455 import org.rut.util.algorithm.support.ImprovedQuickSort; 456 import org.rut.util.algorithm.support.InsertSort; 457 import org.rut.util.algorithm.support.MergeSort; 458 import org.rut.util.algorithm.support.QuickSort; 459 import org.rut.util.algorithm.support.SelectionSort; 460 import org.rut.util.algorithm.support.ShellSort; 461 462 /** 463 * @author dongji 464 * @since 2019-12-28 465 * @version 1.0 466 */ 467 public class SortUtil { 468 public final static int INSERT = 1; 469 public final static int BUBBLE = 2; 470 public final static int SELECTION = 3; 471 public final static int SHELL = 4; 472 public final static int QUICK = 5; 473 public final static int IMPROVED_QUICK = 6; 474 public final static int MERGE = 7; 475 public final static int IMPROVED_MERGE = 8; 476 public final static int HEAP = 9; 477 478 public static void sort(int[] data) { 479 sort(data, IMPROVED_QUICK); 480 } 481 private static String[] name={ 482 “insert”, “bubble”, “selection”, “shell”, “quick”, “improved_quick”, “merge”, “improved_merge”, “heap” 483 }; 484 485 private static Sort[] impl=new Sort[]{ 486 new InsertSort(), 487 new BubbleSort(), 488 new SelectionSort(), 489 new ShellSort(), 490 new QuickSort(), 491 new ImprovedQuickSort(), 492 new MergeSort(), 493 new ImprovedMergeSort(), 494 new HeapSort() 495 }; 496 497 public static String toString(int algorithm){ 498 return name[algorithm-1]; 499 } 500 501 public static void sort(int[] data, int algorithm) { 502 impl[algorithm-1].sort(data); 503 } 504 505 public static interface Sort { 506 public void sort(int[] data); 507 } 508 509 public static void swap(int[] data, int i, int j) { 510 int temp = data[i]; 511 data[i] = data[j]; 512 data[j] = temp; 513 } 514 }
4、为什么要用ORM?它和JDBC有何不一样？
ORM是一种思想,就是把object转变成数据库中的记录,或者把数据库中的记录转变成为object,我们可以用JDBC来实现这个思想,其实,如果我们的项目是严格按照oop方式编写的话,我们的JDBC程序不管是有意还是无意,就已经实现ORM的工作了。
现在有许多ORM工具,它们底层调用JDBC来实现ORM工作,我们直接使用这些工具,就省去了之间使用JDBC的繁琐细节,提高了开发效率,现在用的较多的ORM工具是hibernate。也听说一谢其他ORM工具,如toplink,ojb等。
5、B/S与C/S的联系与区别。
C/S 是Client/Server 的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用 大型数据库系统，如Oracle、Sybase、Informix 或SQL Server。客户端需要安装专用的客户 端软件。 B/Ｓ是Brower/Server 的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator 或Internet Explorer，服务器安装Oracle、Sybase、Informix 或SQL Server 等数据 库。在这种结构下，用户界面完全通过WWW 浏览器实现，一部分事务逻辑在前端实现， 但是主要事务逻辑在服务器端实现。浏览器通过Ｗeb Server 同数据库进行数据交互。 C/S 与B/S 区别： １．硬件环境不同: C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服 务器提供连接和数据交换服务. B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行 ２．对安全要求不同 C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的 信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息. B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。 ３．对程序架构不同 C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少 考虑. B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S 有更高的要求B/S 结构的程序架构是发展的趋势, 从MS 的.Net 系列的BizTalk 2000 Exchange 2000 等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术 等,使B/S更加成熟. ４．软件重用不同 C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S 要求下的构件的 重用性好. B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐 桌可以再利用,而不是做在墙上的石头桌子 ５．系统维护不同 C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可 能是再做一个全新的系统 B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小. 用户从网上自己下载安装就可以实现升级. ６．处理问题不同 C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相 关. 应该都是相同的系统 B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S 无法作到的. 与操 作系统平台关系最小. ７．用户接口不同 C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高 B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难 度减低,减低开发成本. ８．信息流不同 C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低 B/S 信息流向可变化, B-B B-C B-G 等信息、流向的变化, 更像交易中心。
6、Spring框架中都用到了哪些设计模式？
数据库词典40-60
标签：heapsort 好的 面试题1 sys art EAP author 插入 不可
原文地址：https://www.cnblogs.com/blackboc-java/p/12111593.html
