今天开始整理面试和以前学的java等知识点和题目2018-9-20

1.java public,default,protected,private区别

https://www.cnblogs.com/ldq2016/p/6872420.html

2.求n阶层

方法一：for循环

方法二；递归

public class Factorail {

    /**
     * 求5的阶乘? 5*4*3*2*1 = ?
     */
   public static int test(int number){
       if(number == 1){
           return 1;
       }else{
           return number * test(number - 1);
       }

   }

   public static void main(String[] args) {
       System.out.println(test(5));

   }

}

3.水仙花数

https://blog.csdn.net/lcn_lynn/article/details/72675141

4.java抽象类与接口的区别

http://www.importnew.com/12399.html

5.JAVA线程同步的方法

https://www.cnblogs.com/soundcode/p/6295910.html

6.JAVA冒泡排序

public static void bubbleSort(int []arr) {

int[] arr = {12,23,34,56,56,56,78};

for(int i =0;i<arr.length-1;i++) {

for(int j=0;j<arr.length-i-1;j++) {//-1为了防止溢出

if(arr[j]>arr[j+1]) {

int temp = arr[j];

arr[j]=arr[j+1]；

arr[j+1]=temp；}}}}

7.选择排序

择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。

public static void selectSort(int[]a)

{

int minIndex=0;

int temp=0;

if((a==null)||(a.length==0))

return;

for(int i=0;i<a.length;i++)

{

minIndex=i;//无序区的最小数据数组下标

for(int j=i+1;j<a.length;j++)

{

//在无序区中找到最小数据并保存其数组下标

if(a[j]<a[minIndex])

{

minIndex=j;

}

//将最小元素放到本次循环的前端

temp=a[i];

a[i]=a[minIndex];

a[minIndex]=temp;

}

8.希尔排序

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

public static void main(String [] args)

{

int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};

System.out.println("排序之前：");

for(int i=0;i<a.length;i++)

{

System.out.print(a[i]+" ");

}

//希尔排序

int d=a.length;

while(true)

{

d=d/2;

for(int x=0;x<d;x++)

{

for(int i=x+d;i<a.length;i=i+d)

{

int temp=a[i];

int j;

for(j=i-d;j>=0&&a[j]>temp;j=j-d)

{

a[j+d]=a[j];

}

a[j+d]=temp;

}

if(d==1)

{

break;

}

System.out.println();

System.out.println("排序之后：");

for(int i=0;i<a.length;i++)

{

System.out.print(a[i]+" ");

}

9.快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

class　Quick

{

　public　void　sort(int　arr[],int　low,int　high)

　{

　int　l=low;

　int　h=high;

　int　povit=arr[low];

　while(l<h)

　{

　while(l<h&&arr[h]>=povit)

　h--;

　if(l<h){

　int　temp=arr[h];

　arr[h]=arr[l];

　arr[l]=temp;

　l++;

　}

　while(l<h&&arr[l]<=povit)

　l++;

　if(l<h){

　int　temp=arr[h];

　arr[h]=arr[l];

　arr[l]=temp;

　h--;

　}

　print(arr);

　System.out.print("l="+(l+1)+"h="+(h+1)+"povit="+povit+"\n");

　if(l>low)sort(arr,low,l-1);

　if(h<high)sort(arr,l+1,high);

　}

/*//////////////////////////方式二////////////////////////////////*/

更高效点的代码：

public<TextendsComparable<?superT>>

T[]quickSort(T[]targetArr,intstart,intend)

{

inti=start+1,j=end;

Tkey=targetArr[start];

SortUtil<T>sUtil=newSortUtil<T>();

if(start>=end)return(targetArr);

/*从i++和j--两个方向搜索不满足条件的值并交换

*

*条件为：i++方向小于key，j--方向大于key

*/

while(true)

{

while(targetArr[j].compareTo(key)>0)j--;

while(targetArr[i].compareTo(key)<0&&i<j)i++;

if(i>=j)break;

sUtil.swap(targetArr,i,j);

if(targetArr[i]==key)

{

j--;

}else{

i++;

}

/*关键数据放到‘中间’*/

sUtil.swap(targetArr,start,j);

if(start<i-1)

{

this.quickSort(targetArr,start,i-1);

}

if(j+1<end)

{

this.quickSort(targetArr,j+1,end);

}

returntargetArr;

}

/*//////////////方式三：减少交换次数，提高效率/////////////////////*/

private<TextendsComparable<?superT>>

voidquickSort(T[]targetArr,intstart,intend)

{

inti=start,j=end;

Tkey=targetArr[start];

while(i<j)

{

/*按j--方向遍历目标数组，直到比key小的值为止*/

while(j>i&&targetArr[j].compareTo(key)>=0)

{

j--;

}

if(i<j)

{

/*targetArr[i]已经保存在key中，可将后面的数填入*/

targetArr[i]=targetArr[j];

i++;

}

/*按i++方向遍历目标数组，直到比key大的值为止*/

while(i<j&&targetArr[i].compareTo(key)<=0)

/*此处一定要小于等于零，假设数组之内有一亿个1，0交替出现的话，而key的值又恰巧是1的话，那么这个小于等于的作用就会使下面的if语句少执行一亿次。*/

{

i++;

}

if(i<j)

{

/*targetArr[j]已保存在targetArr[i]中，可将前面的值填入*/

targetArr[j]=targetArr[i];

j--;

}

/*此时i==j*/

targetArr[i]=key;

/*递归调用，把key前面的完成排序*/

this.quickSort(targetArr,start,i-1);

/*递归调用，把key后面的完成排序*/

this.quickSort(targetArr,j+1,end);

}

10.插入排序

/**

*插入排序

*@paramarr

*@return

*/

private static int[] insertSort(int[]arr){

if(arr == null || arr.length < 2){

return arr;

}

for(inti=1;i<arr.length;i++){

for(intj=i;j>0;j--){

if(arr[j]<arr[j-1]){

//TODO:

int temp=arr[j];

arr[j]=arr[j-1];

arr[j-1]=temp;

}else{

//接下来是无用功

break;

}

return arr;

}

11.JAVA类加载机制与双委派模型

https://blog.csdn.net/u011080472/article/details/51332866

https://blog.csdn.net/u012900118/article/details/79525931

http://www.cnblogs.com/ITtangtang/p/3978102.html

http://www.importnew.com/25295.html

12.其他

https://blog.csdn.net/a2011480169/article/details/50242055

https://blog.csdn.net/xinyu2015/article/details/51182981

https://blog.csdn.net/u013322876/article/details/51714543

13.加密解密算法

https://blog.csdn.net/u013565368/article/details/53081195?_t=t

14.

子网掩码主要作用：

1 用于屏蔽IP地址的一部分以区别网络标识和主机标识，并说明该IP地址是在局域网上，还是在远程网上。

2 是用于将一个大的IP网络划分为若干小的子网络。

15.三次握手？为什么不是两次？

https://bbs.csdn.net/topics/390706512?page=1

16.time_wait

https://blog.csdn.net/u013616945/article/details/77510925

17.TCP/UDP区别

https://zhidao.baidu.com/question/216414120.html

18事物ACID，脏读，幻读

https://www.jdon.com/transaction.html

https://www.cnblogs.com/melody210218/p/7120559.html

19.B/B+数

https://www.cnblogs.com/George1994/p/7008732.html

20JAVA HashMap原理

https://www.cnblogs.com/yuanblog/p/4441017.html

21 JavaHashMap原理，和HashTable区别ConcurrentHashMap和他们的区别

https://www.cnblogs.com/heyonggang/p/9112731.html

22 java代码中线程安全级别

https://blog.csdn.net/zeng622peng/article/details/62228824?locationNum=9&fps=1

23valotile关键字如何使用？

https://www.cnblogs.com/dolphin0520/p/3920373.html

24 Spring MVC工作流程

https://www.cnblogs.com/jiyukai/p/7629498.html

25红黑树

http://www.cnblogs.com/skywang12345/p/3245399.html

25 REST四种请求(get,delete,put,post)

https://blog.csdn.net/shi_weihappy/article/details/41944347

26Java中集合框架，Collection接口、Set接口、List接口、Map接口，已经常用的它们的实现类，简单的JDK源码分析底层实现

https://www.cnblogs.com/shangxinfeng/p/6685082.html

Map底层结构是平衡二叉树（如红黑树）;HashMap底层结构是数组加链表，实际上是“链表散列。
Set底层结构是红黑树；HashSet底层数据结构是散列表。
List底层结构是数组；ArrayList和Vector底层结构是数组；LinkList底层结构是链表。

27数据库索引

索引问题就是一个查找问题。
(0)索引起源：大多数时候，我们不知道某一条记录在第几个位置，只知道主键（primary key）的值。这时为了读取数据，可以一条条比对记录。但是这样做效率太低。
（1）索引介绍：数据库索引，是数据库管理系统中一个排序的数据结构，这些数据结构以某种方式引用（指向）数据，以协助快速查询、更新数据库表中数据。
（2）底层实现：索引的实现通常使用B树及其变种B+树。
（3）代价：为表设置索引要付出代价的：一是增加了数据库的存储空间，二是在插入和修改数据时要花费较多的时间进行索引的维护(因为索引也要随之变动)。
（4）结构：
Image
(5)创建索引可以大大提高系统的性能。
第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二，可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四，在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
（6）在哪些列上适合创建索引？
在经常需要搜索的列上，可以加快搜索的速度；
在经常用在连接的列上，这些列主要是一些外键，可以加快连接的速度；
在经常需要排序的列上创建索引，因为索引已经排序，这样查询可以利用索引的排序，
加快排序查询时间；
在经常使用在WHERE子句中的列上面创建索引，加快条件的判断速度。
（7)哪列不应该创建索引？
第一，对于那些在查询中很少使用或者参考的列不应该创建索引。
第二，对于那些只有很少数据值的列也不应该增加索引。
第三，对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为，这些列的数据量要么相当大，要么取值很少。
第四，当修改性能远远大于检索性能时，不应该创建索引。这是因为，修改性能和检索性能是互相矛盾的。当增加索引时，会提高检索性能，但是会降低修改性能。当减少索引时，会提高修改性能，降低检索性能。因此，当修改性能远远大于检索性能时，不应该创建索引。
（8）数据库设计器中创建三种索引：唯一索引、主键索引和聚集索引。
唯一索引
唯一索引是不允许其中任何两行具有相同索引值的索引。
当现有数据中存在重复的键值时，大多数数据库不允许将新创建的唯一索引与表一起保存。数据库还可能防止添加将在表中创建重复键值的新数据。例如，如果在employee表中职员的姓(lname)上创建了唯一索引，则任何两个员工都不能同姓。
主键索引
主键索引指的就是主键，主键既是约束，也是索引，主键是索引的一种，是唯一索引的特殊类型。创建主键的时候，数据库默认会为主键创建一个唯一索引。
该索引要求主键中的每个值都唯一。当在查询中使用主键索引时，它还允许对数据的快速访问。
聚集索引
在聚集索引中，表中行的物理顺序与键值的逻辑（索引）顺序相同。一个表只能包含一个聚集索引。
如果某索引不是聚集索引，则表中行的物理顺序与键值的逻辑顺序不匹配。与非聚集索引相比，聚集索引通常提供更快的数据访问速度。
（9)主键索引和唯一索引的区别？
主键创建后一定包含一个唯一性索引，唯一性索引并不一定就是主键。
唯一性索引列允许空值，而主键列不允许为空值。
主键可以被其他表引用为外键，而唯一索引不能。
一个表最多只能创建一个主键，但可以创建多个唯一索引。
主键更适合那些不容易更改的唯一标识，如自动递增列、身份证号等。

28 Vector和ArrayList 区别

https://www.cnblogs.com/rnmb/p/6553711.html

29 String,StringBuffer与StringBuilder的区别??

https://blog.csdn.net/rmn190/article/details/1492013

30数据库优化设计

https://blog.csdn.net/liaozhongping/article/details/48543523

31XML解析——Java中XML的四种解析方式

https://blog.csdn.net/rickyit/article/details/53813246

32 Spring AOP详解

http://www.cnblogs.com/hongwz/p/5764917.html

33Spring IOC原理

https://www.cnblogs.com/ITtangtang/p/3978349.html

34　堆和栈的区别：
　　一、堆栈空间分配区别：
　　1、栈（操作系统）：由操作系统自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；
　　2、堆（操作系统）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。
　　二、堆栈缓存方式区别：
　　1、栈使用的是一级缓存，他们通常都是被调用时处于存储空间中，调用完毕立即释放；
　　2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。
　　三、堆栈数据结构区别：
　　堆（数据结构）：堆可以被看成是一棵树，如：堆排序；
　　栈（数据结构）：一种先进后出的数据结构。