面试

static关键字

https://blog.csdn.net/jsqfengbao/article/details/44724219
https://blog.csdn.net/nobody_1/article/details/92388329
static关键字主要有两种作用：
第一，为某特定数据类型或对象分配单一的存储空间，而与创建对象的个数无关。
第二，实现某个方法或属性与类而不是对象关联在一起
具体而言，在Java语言中，static主要有4中使用情况：成员变量、成员方法、代码块和内部类
（1）static成员变量：
Java类提供了两种类型的变量：用static关键字修饰的静态变量和不用static关键字修饰的实例变量。静态变量属于类，在内存中只有一个复制，只要静态变量所在的类被加载，这个静态变量就会被分配空间，因此就可以被使用了。对静态变量的引用有两种方式，分别是“类.静态变量”和”对象.静态变量”
实例变量属于对象，只有对象被创建后，实例变量才会被分配内存空间，才能被使用，它在内存中存在多个复制，只有用“对象.实例变量”的方式来引用。
（2）static成员方法：
Java中提供了static方法和非static方法。static方法是类的方法，不需要创建对象就可以被调用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用
static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法，因为当static方法被调用时，这个类的对象可能还没被创建，即使已经被创建了，也无法确定调用哪个对象的方法。同理，static方法也不能访问非static类型的变量。
单例设计模式：
static一个很重要的用途就是实现单例设计模式。单利模式的特点是该类只能有一个实例，为了实现这一功能，必须隐藏类的构造函数，即把构造函数声明为private，并提供一个创建对象的方法，由于构造对象被声明为private，外界无法直接创建这个类型的对象，只能通过该类提供的方法来获取类的对象，要达到这样的目的只能把创建对象的方法声明为static，程序实例如下：
class Singleton{
private static Singleton instance=null;
private Singleton(){}
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
}
(3)static代码块
static代码块在类中是独立于成员变量和成员函数的代码块的。注意：这些static代码块只会被执行一次
(4)static与final结合使用表示的意思：
对于变量，若使用static final修饰，表示一旦赋值不能修改，并且通过类名可以访问。
对于方法，若使用static final修饰，表示该方法不可被覆盖，并且可以通过类名直接访问。
public class Test{
public static int testStatic(){
static final int i=0;
System.out.println(i++);
}
public static void main(String[] args){
Test test=new Test();
test.testStatic();
}
}
上述程序运行的结果：
A 0 B 1 C 2 D 编译失败
答案：D
在Java语言中，不能在成员函数内部定义static变量

说说几个关键字的作用(this、super、final、static、abstract)

https://blog.csdn.net/qsbbl/article/details/91345613
this
代表对当前所在类的引用。
super
代表对父类对象的引用，用于子类虽然重写了父类的某个方法，但是依旧想调用父类的这个方法。
final
类，变量，方法等加上它，就代表了“终止”。

static
方便在没有创建对象的情况下，对属性和方法进行调用。
abstract
类和成员方法被abstract修饰后，变为抽象类和抽象方法。

关于 final 关键字的一些总结

final关键字主要用在三个地方：变量、方法、类。

1. 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
   
2. 当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
   
3. 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。
   

   Java中怎么理解volition关键字?

   volatile关键字的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。
   使用volition关键字增加了实例变量在多个线程间的可见性。但volition有个致命的缺点就是不支持原子性。
   下面将volition和synchronized关键字进行一下比较：
   1.volition是线程同步间的轻量级实现，所以volition性能肯定比synchronized性能好，volition只能修饰变量。
   2.多线程访问volition不会发生阻塞，而synchronized会阻塞。
   3.volition能保证数据的可见性，而不能保证原子性；而synchronized既可以保证原子性，也可以间接保证可见性。
   4.再次强调，关键字volition解决的是变量在多个线程之间的可见性；而synchronized关键字解决的是多个线程之间访问资源的同步性。
   线程安全包含原子性和可见性两个方面，java的同步机制都是围绕这两个方面来却保线程安全的。
   关键字volition主要使用的场合是在多个线程中可以感知共享变量被更改了，并且可以获得最新的值使用，也就是用多线程读取共享变量可以获取最新值使用。
   关键字volition提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样保证了数据的可见性。

   浅谈Java中的final关键字

   抽象类和借口的区别

   抽象类和接口的联系和区别

   https://blog.csdn.net/houwanle/article/details/82142960
   

   MVC各个部分有哪些技术实现

   视图层用jsp，javascript
   作用—显示数据，接受用户输入数据
   控制层用servlet
   作用—接收视图层数据，传输 给业务逻辑层（即模型层）
   模型层用普通java class
   作用—业务类的实现，如：数据库操作
   M：hibernate、mybatis、ibatis
   C：severlet、struts、spring、action
   V：jsp、FreeMarker、tails、taglib、EL、Velocity

   MVC的各个部分都有哪些技术来实现？如何实现？

   MVC是三个单词的缩写,分别为： 模型(Model),视图(View)和控制Controller)。 MVC模式的目的就是实现Web系统的职能分工。 Model层实现系统中的业务逻辑，通常可以用JavaBean或EJB来实现。 View层用于与用户的交互，通常用JSP来实现。 Controller层是Model与View之间沟通的桥梁，它可以分派用户的请求并选择恰当的视图以用于显示，同时它也可以解释用户的输入并将它们映射为模型层可执行的操作。
   WeeMVC 是一种微型、简洁的 ActionScript? 快速开发框架。

   同步和异步的区别

   同步：
   同步的思想是：所有的操作都做完，才返回给用户。这样用户在线等待的时间太长，给用户一种卡死了的感觉（就是系统迁移中，点击了迁移，界面就不动了，但是程序还在执行，卡死了的感觉）。这种情况下，用户不能关闭界面，如果关闭了，即迁移程序就中断了。
   异步：
   将用户请求放入消息队列，并反馈给用户，系统迁移程序已经启动，你可以关闭浏览器了。然后程序再慢慢地去写入数据库去。这就是异步。但是用户没有卡死的感觉，会告诉你，你的请求系统已经响应了。你可以关闭界面了。
   同步，是所有的操作都做完，才返回给用户结果。即写完数据库之后，在相应用户，用户体验不好。
   异步，不用等所有操作等做完，就相应用户请求。即先相应用户请求，然后慢慢去写数据库，用户体验较好。
   异步操作例子：
   为了避免短时间大量的数据库操作，就使用缓存机制，也就是消息队列。先将数据放入消息队列，然后再慢慢写入数据库。
   引入消息队列机制，虽然可以保证用户请求的快速响应，但是并没有使得我数据迁移的时间变短（即80万条数据写入mysql需要1个小时，用了redis之后，还是需要1个小时，只是保证用户的请求的快速响应。用户输入完http url请求之后，就可以把浏览器关闭了，干别的去了。如果不用redis，浏览器不能关闭）。
   同步就没有任何价值了吗？
   银行的转账功能。
   

   short和shorts的区别

   https://www.wanmeila.com/question/d6323f376698780847.html

   java中Comparable和Comparator两种比较器的区别

   Comparable和Comparator接口都是为了对类进行比较，众所周知，诸如Integer，double等基本数据类型，java可以对他们进行比较，而对于类的比较，需要人工定义比较用到的字段比较逻辑。可以把Comparable理解为内部比较器，而Comparator是外部比较器，基本的写法如下：

实现了Comparable接口的类需要实现compareTo()方法，传入一个外部参数进行比对，实现了Comparator接口的方法需要实现compare()方法，对外部传入的两个类进行比较，从而让外部方法在比较时调用。
　　两者的区别是实现Comparator接口代码更加灵活，可以定义某个类的多个比较器，从而在排序时根据实际场景自由调用，而Comparable接口实现后便不能改动。两种接口的调用方式如下：

Java中Comparable和Comparator两种比较器

https://blog.csdn.net/sinat_37976731/article/details/79902968

重新认识java（十） —— Enum（枚举类）

https://blog.csdn.net/qq_31655965/article/details/55049192

java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一

https://blog.csdn.net/s10461/article/details/53941091

详解Java中的 枚举与泛型

https://www.jb51.net/article/107123.htm

各类字符集的发展历史

https://blog.csdn.net/qq_43176938/article/details/95861726

java中&和&&的区别

&和&&都是逻辑运算符，都是判断两边同时真则为真，否则为假；但是&&当第一个条件不成之后，后面的条件都不执行了，而&则还是继续执行，直到整个条件语句执行完为止。如&&例子中的i++>5被执行了，而i++<9并没有被执行，这就是他们的差别。&例子中的i++>5和i++<9都被执行了。

Java中final、finally、finalize的区别

简单区别：
final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。
中等区别：
虽然这三个单词在Java中都存在，但是并没有太多关联：
final：java中的关键字，修饰符。
1.如果一个类被声明为final，就意味着它不能再派生出新的子类，不能作为父类被继承。因此，一个类不能同时被声明为absrtact抽象类的和final的类。
2.如果将变量或者方法声明为final，可以保证它们在使用中不被改变.
2.1 被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。
2.2被声明final的方法只能使用，不能重载。

2 finally：java的一种异常处理机制。
finally是对Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，如果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。

3 finalize：Java中的一个方法名。
Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。

Servlet和CGI的区别

https://blog.csdn.net/Logicr/article/details/82259962 比较详细
与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。

java中Collection与Collections的区别

1、Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。

2、Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

Collections 是一个包装类，Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许，一些 collection 是有序的，而另一些则是无序的。

Json传递数据两种方式（json大全）

JSon方法两个

如果要变成js对象必须调用一个方法，调用json的parse方法将json形式的字符串转化成对应的js对象var jsObj=JSON.parse(str);

var list1 = [“number”,”name”];
var param = {};
param[“list1”] = list1;
param[“test”] =”java”;
var json = JSON.stringify(param);
$.ajax({

标准jq的ajax方法

$.ajax({
  type: 'POST',
  url: url,
  data: data,
  success: success,
  dataType: dataType
});

SpringBoot注解大全

Spring 注解大全与详解

Java序列化中如果有些字段不想进行序列化 怎么办

对于不想进行序列化的变量，使用transient关键字修饰。
transient关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。

优美的讲解equals和==的区别

https://blog.csdn.net/qq_36522306/article/details/80550210
== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)
equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：

• 情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
  
• 情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

  构造器 Constructor 是否可被 override

  在讲继承的时候我们就知道父类的私有属性和构造方法并不能被继承，所以 Constructor 也就不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。

  重载和重写的区别

  重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。 　　
  重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。

  String StringBuffer 和 StringBuilder 的区别是什么 String 为什么是不可变的

  可变性　
  简单的来说：String 类中使用 final 关键字字符数组保存字符串， private　final　char　value[]，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串 char[]value 但是没有用 final 关键字修饰，所以这两种对象都是可变的。
  StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。
  线程安全性
  String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。 　　
  性能
  每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
  对于三者使用的总结：

1. 操作少量的数据 = String
   
2. 单线程操作字符串缓冲区下操作大量数据 = StringBuilder
   
3. 多线程操作字符串缓冲区下操作大量数据 = StringBuffer

   自动装箱与拆箱

   装箱：将基本类型用它们对应的引用类型包装起来；
   拆箱：将包装类型转换为基本数据类型；

   自动装箱与拆箱详解

   https://www.cnblogs.com/Latiny/p/10573338.html
   // 自动装箱，将基本数据类型转为包装类型
   Integer i1 = 200;
   Integer i2 = 200;
   // 自动拆箱，将包装类型转为基本数据类型
   int i3 = i1;
   int i4 = i2;
   

装箱与拆箱如何实现
　　装箱的时候JVM自动调用的是Integer的valueOf（value）方法。拆箱时JVM自动调用Integer的intVlue()方法。装箱与拆箱的实现过程即为：装箱过程是通过调用包装器的valueOf(value)方法实现的，而拆箱过程是通过调用包装器的 xxxValue()方法实现的。（xxx代表对应的基本数据类型），包装类型做算术运算时，会自动拆箱为基本数据类型再进行。

创建一个对象用什么运算符?对象实体与对象引用有何不同?

new运算符，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）。

构造方法有哪些特性

1. 名字与类名相同；
   
2. 没有返回值，但不能用void声明构造函数；
   

3. 生成类的对象时自动执行，无需调用。
   

   静态方法和实例方法有何不同

4. 在外部调用静态方法时，可以使用”类名.方法名”的方式，也可以使用”对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
   

5. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制.
   

   对象的相等与指向他们的引用相等,两者有什么不同?

   对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。

   Java 中的异常处理

   
   在 Java 中，所有的异常都有一个共同的祖先java.lang包中的Throwable类。Throwable： 有两个重要的子类：Exception（异常）和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
   
   Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
   
   这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
   
   Exception（异常）:是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 异常由Java虚拟机抛出。NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和 ArrayIndexOutOfBoundsException（下标越界异常）。
   注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。
   **

   Throwable类常用方法

• public string getMessage():返回异常发生时的详细信息
  
• public string toString():返回异常发生时的简要描述
  
• public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
  

• public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

  异常处理总结

• try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
  

• catch 块：用于处理try捕获到的异常。
  
• finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

在以下4种特殊情况下，finally块不会被执行：

1. 在finally语句块第一行发生了异常。 因为在其他行，finally块还是会得到执行
   
2. 在前面的代码中用了System.exit(int)已退出程序。 exit是带参函数 ；若该语句在异常语句之后，finally会执行
   
3. 程序所在的线程死亡。
   
4. 关闭CPU。
   

   Git 与 SVN 区别

   GIT不仅仅是个版本控制系统，它也是个内容管理系统(CMS),工作管理系统等。
   如果你是一个具有使用SVN背景的人，你需要做一定的思想转换，来适应GIT提供的一些概念和特征。
   Git 与 SVN 区别点：
   · 1、GIT是分布式的，SVN不是：这是GIT和其它非分布式的版本控制系统，例如SVN，CVS等，最核心的区别。
   · 2、GIT把内容按元数据方式存储，而SVN是按文件：所有的资源控制系统都是把文件的元信息隐藏在一个类似.svn,.cvs等的文件夹里。
   · 3、GIT分支和SVN的分支不同：分支在SVN中一点不特别，就是版本库中的另外的一个目录。
   · 4、GIT没有一个全局的版本号，而SVN有：目前为止这是跟SVN相比GIT缺少的最大的一个特征。
   · 5、GIT的内容完整性要优于SVN：GIT的内容存储使用的是SHA-1哈希算法。这能确保代码内容的完整性，确保在遇到磁盘故障和网络问题时降低对版本库的破坏。

SVN和Git的优缺点

SVN的优点：
1、采用集中式，易于管理，保证安全性；
2、管理方便，逻辑明确，理念符合常规思维；
3、代码的一致性高；
4、适合人数不多的项目开发；
5、允许一个文件有任意多的可命名属性，会关注所有的文件类型；
6、支持二进制文件，更容易处理大文件；
7、支持空目录。
SVN的缺点：
1、服务器压力太大，数据库容量暴增；
2、必须连接在服务器上，否则基本不能工作、提交、对比、还原等；
3、不适合开源开发。
===========================
Git的优点：
1、适合分布式开发，强调个体；
2、公共的服务器压力和数量都不会太大；
3、速度快， 成熟的架构，开发灵活；
4、任意两个开发者之间可以很容易的解决冲突；
5、离线工作，管理代码成本低，不需要依赖服务器；
6、部署方便。基本上下个命令就可以用；
7、良好的分支机制，可以让主干代码保持干净。
Git的缺点：
1、资料少，学习成本比较大，学习周期比较长，要求人员素质比较高；
2、不符合常规思维；
3、代码保密性差，一旦开发者把整个库克隆下来就可以完全公开所有代码和版本信息。

版本控制：SVN和GIT的一些使用感受

https://blog.csdn.net/zssureqh/article/details/39117601

Git版本控制（完美整理版）

https://blog.csdn.net/ZZQHELLO2018/article/details/82354900

JDBC操作数据库的基本步骤

https://blog.csdn.net/Hpu_A/article/details/51354867

javaj经典程序编程50题

https://blog.csdn.net/wenzhi20102321/article/details/52274976

java过滤器——filter的使用和配置

https://blog.csdn.net/huyuyang6688/article/details/46276529

Java过滤器Filter使用详解

http://www.cnblogs.com/ygj0930/p/6374212.html

Java线程——Callable与Runnable的区别

https://blog.csdn.net/sinat_39634657/article/details/81456810

说说Runnable与Callable（链接有代码demo）

相同点：

1. 两者都是接口；（废话）
2. 两者都可用来编写多线程程序；

3. 两者都需要调用Thread.start()启动线程；

   
   不同点：

4. 两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；

5. Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；

   
   注意点：

• Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！

  面试之：请写一个单例模式的程序

  https://blog.csdn.net/elice_/article/details/84314025

  写一个单例模式

  

  hashCode()和equals()方法比较

  https://blog.csdn.net/qq_34801169/article/details/81777880

  java 多线程总结篇4——锁机制

  数据库中的多表查询总结

  https://blog.csdn.net/u013044310/article/details/82258530

  20 道 Spring Boot 面试题

  https://blog.csdn.net/zl1zl2zl3/article/details/83715633

  从头开始学MySQL———-存储过程与存储函数（1）

  https://blog.csdn.net/yanluandai1985/article/details/83656374

  【mysql】-常见面试题汇总

  https://blog.csdn.net/weixin_43067223/article/details/86691331

  springboot+springcloud相关面试题

  https://blog.csdn.net/panhaigang123/article/details/79587612

Java 集合深入理解（9）：Queue 队列

https://blog.csdn.net/u011240877/article/details/52860924

什么是队列

队列是数据结构中比较重要的一种类型，它支持 FIFO，尾部添加、头部删除（先进队列的元素先出队列），跟我们
生活中的排队类似。

队列的种类

单队列（单队列就是常见的队列, 每次添加元素时，都是添加到队尾，存在“假溢出”的问题也就是明明有位置却
不能添加的情况）
循环队列（避免了“假溢出”的问题）

Java 集合框架中的队列 Queue

Java 集合中的 Queue 继承自 Collection 接口 ，Deque, LinkedList, PriorityQueue, BlockingQueue 等类都实现了
它。 Queue 用来存放 等待处理元素 的集合，这种场景一般用于缓冲、并发访问。 除了继承 Collection 接口的一些
方法，Queue 还添加了额外的 添加、删除、查询操作。

Oracle数据库对象

https://blog.csdn.net/weixin_38506291/article/details/79237268
索引、表、视图、函数、包、过程、同义词、序列、触发器

浅谈对存储过程的理解：什么是存储过程，及它的优点等！
1、什么是存储过程？

我理解的存储过程就是预先定义好的SQL语句，然后存储起来，等你用的时候再把自己所需要的匹配的SQL语句用Execute(即exec)调用就行！
2、为甚么要用存储过程？(即存储过程的优点!)
<1>“一对多”：运用了“一对多”的原理，即一条SQL语句可以被多个地方使用！
<2>性能高：进行复杂的操作时(比如多张表连表查询)可将那些复杂的操作用存储过程先封装起来然后进行查询！
<3>高速并减少网络流量：只在创造时进行编译，以后每次执行都不需要重新编译，这与一般的SQL语句(一般的SQL语句每执行一次就编译一次)相比就速度加快了很多！
<4>安全：可以指定只有某用户才可以进行访问！
3、如何定义存储过程？SQL中如何执行存储过程？

struts框架的运行原理和流程

Oracle 数据库常用操作语句大全

应用服务器优化技术

https://blog.csdn.net/qq_34380327/article/details/81239880

• 分布式缓存
  • JBoss Cache
  • Memchached
• 消息队列
  • RabbitMQ
  • Redis
• 使用集群
• 代码优化
  • 多线程
  • 垃圾回收