Java知识持续跟新

Java知识

参考网址一

一、Java基础

1.JDK 和 JRE 有什么区别？

1、面向人群不同：

JDK是面向开发人员使用的SDK。

JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者。

2、重要程度不同：

JRE的地位就象一台PC机一样，编写的Java程序必须要JRE才能运行。只要你的电脑安装了JRE，就可以正确运行Jav a应用程序。

3、安装位置不同：

如果安装JDK，电脑有两套JRE，一套位于 \jre 另外一套位于 C:\Program Files\Java\j2re1.4.1_01 目录下。

2.== 和 equals 的区别是什么？

==是判断两个变量或实例是不是指向同一个内存空间，equals是判断两个变量或实例所指向的内存空间的值是不是相同 
==是指对内存地址进行比较 ， equals()是对字符串的内容进行比较
==指引用是否相同， equals()指的是值是否相同

在JVM中，内存分为堆内存跟栈内存，创建对象在堆中开辟空间（equals） 在栈中分配引用（==）

3.两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？

1、两个对象用equals()比较返回true，那么两个对象的hashCode()方法必须返回相同的结果。

2、两个对象用equals()比较返回false，不要求hashCode()方法也一定返回不同的值，但是最好返回不同值，亿提搞哈希表性能。

3、重写equals()方法，必须重写hashCode()方法，以保证equals方法相等时两个对象hashcode返回相同的值。

补充：
equls返回为true,则两者的hashcode一定相等，意即相等的对象必须具有相等的哈希码。每当equals方法被覆写，通常需要重写hashCode方法从而
保持对象行为的一致性。而具有相等的hashcode的两个对象equals不一定成立。你可以这样认为也行，hashcode是作为一个对象存储的参考，hash表本身是一种散列表，在数据存储这块，功效比较大，而equals是相当于两对象之间的属性（成员变量）“相等”，意即具有相同的行为（方法）。或许这样讲起来理解比较的费劲。举个例子，比如你定义class A有两个属性，int aA,aB,在定义一个class B也有两个属性，int bA,bB,然后覆写hashcode方法，A类为return aA*aB;B类为return bA*bB.现在情况已经很显然了，各自实例化一个对象:a,b,假如:a.aA=b.bA,a.aB=b.bB,相等，或者a.aA=b.bB,a.aB=b.bA两个对象a,b的hashcode一定相等，当时你能说两个对象相等吗？显然不能吧，a与b都是不同类的实例。连equals最基本的obj instance of A或是obj instance of B都不成立。如果是同一个类的不同对象，当两者拥有相同hashcode的时候，则一定相等，或者equals成立的时候则hashcode一定为真，这也就是所谓的相等

4.final 在 java 中有什么作用？

final作为Java中的关键字可以用于三个地方。用于修饰类、类属性和类方法。
特征：凡是引用final关键字的地方皆不可修改！
(1)修饰类：表示该类不能被继承；

(2)修饰方法：表示方法不能被重写；

(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

被final修饰的变量是不能够被改变的. 但是这里的"不能够被改变"对于不同的数据类型是有不同的含义的.
当final修饰的是一个基本数据类型数据时, 这个数据的值在初始化后将不能被改变; 当final修饰的是一个引用类型数据时, 也就是修饰一个对象时, 引用在初始化后将永远指向一个内存地址, 不可修改. 但是该内存地址中保存的对象信息, 是可以进行修改的.
https://blog.csdn.net/qq_24309787/article/details/100942044

5.java 中的 Math.round(-1.5) 等于多少？

-1

6.String 属于基础的数据类型吗？

Java 中 8 种基础的数据类型：byte、short、char、int、long、float、double、boolean

但是 String 类型却是最常用到的引用类型

7.java 中操作字符串都有哪些类？它们之间有什么区别？

Java 中，常用的对字符串操作的类有 String、StringBuffer、StringBuilder

String : final 修饰，String 类的方法都是返回 new String。即对 String 对象的任何改变都不影响到原对象，对字符串的修改操作都会生成新的对象。
StringBuffer : 对字符串的操作的方法都加了synchronized，保证线程安全。
StringBuilder : 不保证线程安全，在方法体内需要进行字符串的修改操作，可以 new StringBuilder 对象，调         用 StringBuilder 对象的 append()、replace()、delete() 等方法修改字符串。

8.String str="i"与 String str=new String(“i”)一样吗？

参见

不一样
两者看似都是创建了一个字符串对象，但在内存中确是各有各的想法。

String str1= “abc”； 在编译期，JVM会去常量池来查找是否存在“abc”，如果不存在，就在常量池中开辟一个空间来存储“abc”；如果存在，就不用新开辟空间。然后在栈内存中开辟一个名字为str1的空间，来存储“abc”在常量池中的地址值。
String str2 = new String("abc") ;在编译阶段JVM先去常量池中查找是否存在“abc”，如果过不存在，则在常量池中开辟一个空间存储“abc”。在运行时期，通过String类的构造器在堆内存中new了一个空间，然后将String池中的“abc”复制一份存放到该堆空间中，在栈中开辟名字为str2的空间，存放堆中new出来的这个String对象的地址值。

也就是说，前者在初始化的时候可能创建了一个对象，也可能一个对象也没有创建；后者因为new关键字，至少在内存中创建了一个对象，也有可能是两个对象。

9.如何将字符串反转？

使用 StringBuilder 或 StringBuffer 的 reverse 方法，本质都调用了它们的父类 AbstractStringBuilder 的 reverse 方法实现。（JDK1.8）
不考虑字符串中的字符是否是 Unicode 编码，自己实现。
递归 
package constxiong.interview;
public class TestReverseString {
	public static void main(String[] args) {
		String str = "ABCDE";
		System.out.println(reverseString(str));
		System.out.println(reverseStringByStringBuilderApi(str));
		System.out.println(reverseStringByRecursion(str));
	}

	/**
	 * 自己实现
	 * @param str
	 * @return
	 */
	public static String reverseString(String str) {
		if (str != null && str.length() > 0) {
			int len = str.length();
			char[] chars = new char[len];
			for (int i = len - 1; i >= 0; i--) {
				chars[len - 1 - i] = str.charAt(i);
			}
			return new String(chars);
		}
		return str;
	}
	
	/**
	 * 使用 StringBuilder
	 * @param str
	 * @return
	 */
	public static String reverseStringByStringBuilderApi(String str) {
		if (str != null && str.length() > 0) {
			return new StringBuilder(str).reverse().toString();
		}
		return str;
	}


	/**
	 * 递归
	 * @param str
	 * @return
	 */
	public static String reverseStringByRecursion(String str) {
		if (str == null || str.length() <= 1) {
			return str;
		}
		return reverseStringByRecursion(str.substring(1)) + str.charAt(0);
	}
}

10.String 类的常用方法都有那些？

equals：字符串是否相同
equalsIgnoreCase：忽略大小写后字符串是否相同
compareTo：根据字符串中每个字符的Unicode编码进行比较
compareToIgnoreCase：根据字符串中每个字符的Unicode编码进行忽略大小写比较
indexOf：目标字符或字符串在源字符串中位置下标
lastIndexOf：目标字符或字符串在源字符串中最后一次出现的位置下标
valueOf：其他类型转字符串
charAt：获取指定下标位置的字符
codePointAt：指定下标的字符的Unicode编码
concat：追加字符串到当前字符串
isEmpty：字符串长度是否为0
contains：是否包含目标字符串
startsWith：是否以目标字符串开头
endsWith：是否以目标字符串结束
format：格式化字符串
getBytes：获取字符串的字节数组
getChars：获取字符串的指定长度字符数组
toCharArray：获取字符串的字符数组
join：以某字符串，连接某字符串数组
length：字符串字符数
matches：字符串是否匹配正则表达式
replace：字符串替换
replaceAll：带正则字符串替换
replaceFirst：替换第一个出现的目标字符串
split：以某正则表达式分割字符串
substring：截取字符串
toLowerCase：字符串转小写
toUpperCase：字符串转大写
trim：去字符串首尾空格

11.抽象类必须要有抽象方法吗？

不一定；
含有抽象方法一定得是抽象类

12.普通类和抽象类有哪些区别？

抽象类不能被实例化
抽象类可以有抽象方法，抽象方法只需申明，无需实现
含有抽象方法的类必须申明为抽象类
抽象类的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类
抽象方法不能被声明为静态
抽象方法不能用 private 修饰
抽象方法不能用 final 修饰

13.抽象类能使用 final 修饰吗？

不能，抽象类是被用于继承的，final修饰代表不可修改、不可继承的。

14.接口和抽象类有什么区别？

抽象类可以有构造方法；接口中不能有构造方法。
抽象类中可以有普通成员变量；接口中没有普通成员变量。
抽象类中可以包含非抽象普通方法；接口中的所有方法必须都是抽象的。
抽象类中的抽象方法的访问权限可以是 public、protected 和 default；接口中的抽象方法只能是 public 类型的，并且默认即为 public abstract 类型。
抽象类中可以包含静态方法；JDK1.8 前接口中不能包含静态方法，JDK1.8 及以后可以包含已实现的静态方法。
public interface TestInterfaceStaticMethod {
 
	static String getA() {
		return "a";
	}
	
}
抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量可以是任意访问权限；接口中变量默认且只能是 public static final 类型。
一个类可以实现多个接口，用逗号隔开，但只能继承一个抽象类。
接口不可以实现接口，但可以继承接口，并且可以继承多个接口，用逗号隔开。

15.java 中 IO 流分为几种？

IO流的分类：
（1）按照数据的流向：
输入流、输出流
（2）按照流数据的格式：
字符流、字节流
（3）按照流数据的包装过程：
节点流（低级流）、处理流（高级流）
最基本的几种进行简单介绍：
•InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
•OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
原文链接：https://blog.csdn.net/qq_41026809/article/details/90317244

16.BIO、NIO、AIO 有什么区别？

•BIO (Blocking I/O): 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。

•NIO (New I/O): NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。NIO提供了与传统BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发

•AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。
原文链接：https://blog.csdn.net/qfc8930858/article/details/89493877

17.Files的常用方法都有哪些？

创建：
createNewFile()在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。
mkdir()  在指定位置创建一个单级文件夹。
mkdirs()  在指定位置创建一个多级文件夹。
renameTo(File dest)如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名， 如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。 

删除：
delete()  删除文件或者一个空文件夹，不能删除非空文件夹，马上删除文件，返回一个布尔值。
deleteOnExit()jvm退出时删除文件或者文件夹，用于删除临时文件，无返回值。
判断：
exists()  文件或文件夹是否存在。
isFile()  是否是一个文件，如果不存在，则始终为false。
isDirectory()  是否是一个目录，如果不存在，则始终为false。
isHidden()  是否是一个隐藏的文件或是否是隐藏的目录。
isAbsolute()  测试此抽象路径名是否为绝对路径名。
获取：
getName()  获取文件或文件夹的名称，不包含上级路径。
getAbsolutePath()获取文件的绝对路径，与文件是否存在没关系
length()  获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。
getParent()  返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。
lastModified()获取最后一次被修改的时间。

文件夹相关：
static File[] listRoots()列出所有的根目录（Window中就是所有系统的盘符）
list()  返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。
listFiles()  返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。
list(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
listFiles(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class FileMethod {

    public static void main(String[] args) throws IOException {
        //创建方法
/*        @SuppressWarnings("unused")
        File file = new File("F:\\a.txt");
        //System.out.println("创建成功了吗？"+file.createNewFile());
        //System.out.println("单级文件夹创建成功了吗？"+file.mkdir());
        //System.out.println("多级文件夹创建成功了吗？"+file.mkdirs());
        //File dest = new File("F:\\电影\\c.txt");
        //System.out.println("重命名成功了吗？"+file.renameTo(dest));
*/
        
/*      //删除方法
        File file = new File("F:\\电影");
        System.out.println("删除成功了吗？"+file.delete());
        file.deleteOnExit();
*/
        
        //判断方法
/*        File file = new File("F:\\a.txt");
        System.out.println("文件或者文件夹存在吗？"+file.exists());
        System.out.println("是一个文件吗？"+file.isFile());
        System.out.println("是一个文件夹吗？"+file.isDirectory());
        System.out.println("是隐藏文件吗？"+file.isHidden());
        System.out.println("此路径是绝对路径名？"+file.isAbsolute());
*/
        
        //获取方法
/*
         File file = new File("f:\\a.txt");
        System.out.println("文件或者文件夹得名称是："+file.getName());
        System.out.println("绝对路径是："+file.getPath());
        System.out.println("绝对路径是："+file.getAbsolutePath());
        System.out.println("文件大小是（以字节为单位）:"+file.length());
        System.out.println("父路径是"+file.getParent());
        //使用日期类与日期格式化类进行获取规定的时间
        long  lastmodified= file.lastModified();
        Date data = new Date(lastmodified);
        SimpleDateFormat simpledataformat = new SimpleDateFormat("YY年MM月DD日 HH:mm:ss");
        System.out.println("最后一次修改的时间是："+simpledataformat.format(data));
*/
        
        //文件或者文件夹的方法

        File[] file = File.listRoots();
        System.out.println("所有的盘符是：");
        for(File item : file){
            System.out.println("\t"+item);
        }
        File filename =new File("F:\\Java workspace\\Java");
        String[] name = filename.list();
        System.out.println("指定文件夹下的文件或者文件夹有：");
        for(String item : name){
            System.out.println("\t"+item);
        }
        File[] f = filename.listFiles();
        System.out.println("获得该路径下的文件或文件夹是：");
        for(File item : f){
            System.out.println("\t"+item.getName());
            }

        }
}

二、容器

LinkedList与ArrayList都是非同步的非线程安全；若要使用多线程，可以创建LinkedList时候再创建同步List：

Listlist=Collections.synchronizedList(newLinkedList(...));

18.java 容器都有哪些？

集合容器

set list hashmap
Set 集合遍历
第一种：for增强循环
Set<String> set = new HashSet<String>(); 
for (String str : set) {
      System.out.println(str);
}
第二种：迭代器遍历（集合类通用）
Iterator<String> it = set.iterator();
while (it.hasNext()) {
  System.out.println(it.next);
}
第三种：用的比较少（主要用于泛型的遍历）
比如：
Set<Object> set = new HashSet<Object>();
for (Object obj: set) {       
      if(obj instanceof Integer){        //若是Integer类型对象
                int aa= (Integer)obj;  //从包装类Integer   转为基本数据类型
             }else if(obj instanceof String){  //若是String类型对象 转为String类型
               String aa = (String)obj
             }
}
-----------------------------------------------------------------------------------
List集合的遍历方法
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
方法一：
超级for循环遍历
for(String attribute : list) {
  System.out.println(attribute);
}
方法二：
对于ArrayList来说速度比较快, 用for循环, 以size为条件遍历:
for(int i = 0 ; i < list.size() ; i++) {
  system.out.println(list.get(i));
}
方法三：
集合类的通用遍历方式, 从很早的版本就有, 用迭代器迭代
Iterator it = list.iterator();
while(it.hasNext()) {
  System.ou.println(it.next);
}

	不允许重复	允许null，但只能有一个	无序	索引
HashSet	√	√	√	×
LinkedHashSet	√	√		×
TreeSet	√	√	√	×

19.Collection 和 Collections 有什么区别？

Collection 是集合的父类
collections 是操作集合的工具类

20.List、Set、Map 之间的区别是什么？

比较	List	Set	Map
继承接口	Collection	Collection	Map
常见实现	AbstractList(其常用子类有ArrayList、LinkedList、Vector)	AbstractSet(其常用子类有HashSet、LinkedHashSet、TreeSet)	HashMap、HashTable
常见方法	add( )、remove( )、clear( )、get( )、contains( )、size( )	add( )、remove( )、clear( )、contains( )、size( )	put( )、get( )、remove( )、clear( )、containsKey( )、containsValue( )、keySet( )、values( )、size( )
元素	可重复	不可重复(用equals()判断)	不可重复
顺序	有序	无序(实际上由HashCode决定)
线程安全	Vector线程安全Listlist=Collections.synchronizedList(newLinkedList(…));		Hashtable线程安全
常用遍历方法	增强for (News news : set) { }； set.forEach(item->{ System.out.println(item.toString()+item.hashCode()+""); }); Iterator iterator = set.iterator();while ( iterator.hasNext()){ System.out.println(iterator.next());}	同list
fail-fast解决办法	CopyOnWriterArrayList，Collections.synchronizedList（会造成遍历阻塞）		ConcurrentHashMap

Map集合的五种遍历方式及Treemap方法

public class Maptest {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("a",10);
        map.put("b",100);
        map.put("c",1000);
        map.put("f",10000);
        System.out.println("Map.Entry----------------------------------------");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("key:"+entry.getKey()+"  value:"+entry.getValue());
        }
        System.out.println("key----------------------------------------");
        for (String s : map.keySet()) {
            System.out.println(s);
        }
        System.out.println("values----------------------------------------");
        for (Integer integer : map.values()) {
            System.out.println(integer);
        }
        System.out.println("forEach Lambda----------------------------------------");
        map.forEach((k,v)->{
            System.out.print(k);
            System.out.println(v);
        });
        System.out.println("Iterator----------------------------------------");
        Iterator<Map.Entry<String, Integer>> entries = map.entrySet().iterator();
        while (entries.hasNext()){
            Map.Entry<String, Integer> entry = entries.next();
            System.out.println("key:"+entry.getKey()+"  value:"+entry.getValue());
        }
    }
}

21.HashMap 和 Hashtable 有什么区别？

1.继承的父类不同
    HashMap是继承自AbstractMap类，而HashTable是继承自Dictionary类。都实现了同时实现了map、		Cloneable（可复制）、Serializable（可序列化）这三个接口；
    
2.对外提供的接口不同
	Hashtable比HashMap多提供了elments() 和contains() 两个方法。
elments()方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的	举。
	contains()方法判断该Hashtable是否包含传入的value。它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
	
3.对Null key 和Null value的支持不同
	HashMap的key，value都可以为NULL（所以不能用get()返回null判断是否有某键，因为键的值本身就可能为空，判断应用containsKey()方法来判断）,但是只能有一个为null的key；
	Hashtable既不支持Null key也不支持Null value；
	
4.线程安全性不同
	Hashtable是线程安全的，速度慢；hashmap是非线程安全的速度快，想要线程安全用ConcurrentHashMap；ConcurrentHashMap使用了分段锁，不对整个数据进行锁定；
	
5.遍历方式的内部实现上不同
	Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。
HashMap的Iterator是fail-fast迭代器。当有其它线程改变了HashMap的结构（增加，删除，修改元素），将会抛出ConcurrentModificationException。不过，通过Iterator的remove()方法移除元素则不会抛出ConcurrentModificationException异常。

6.初始容量大小和每次扩充容量大小的不同
	Hashtable默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。
	创建时，如果给定了容量初始值，那么Hashtable会直接使用你给定的大小，而HashMap会将其扩充为2的幂次方大小。也就是说Hashtable会尽量使用素数、奇数。而HashMap则总是使用2的幂作为哈希表的大小。之所以会有这样的不同，是因为Hashtable和HashMap设计时的侧重点不同。Hashtable的侧重点是哈希的结果更加均匀，使得哈希冲突减少。当哈希表的大小为素数时，简单的取模哈希的结果会更加均匀。而HashMap则更加关注hash的计算效率问题。在取模计算时，如果模数是2的幂，那么我们可以直接使用位运算来得到结果，效率要大大高于做除法。HashMap为了加快hash的速度，将哈希表的大小固定为了2的幂。当然这引入了哈希分布不均匀的问题，所以HashMap为解决这问题，又对hash算法做了一些改动。这从而导致了Hashtable和HashMap的计算hash值的方法不同
7. 计算hash值的方法不同
	为了得到元素的位置，首先需要根据元素的 KEY计算出一个hash值，然后再用这个hash值来计算得到最终的位置。
Hashtable直接使用对象的hashCode。hashCode是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。然后再使用除留余数发来获得最终的位置。
Hashtable在计算元素的位置时需要进行一次除法运算，而除法运算是比较耗时的。
HashMap为了提高计算效率，将哈希表的大小固定为了2的幂，这样在取模预算时，不需要做除法，只需要做位运算。位运算比除法的效率要高很多。
HashMap的效率虽然提高了，但是hash冲突却也增加了。因为它得出的hash值的低位相同的概率比较高，而计算位运算
为了解决这个问题，HashMap重新根据hashcode计算hash值后，又对hash值做了一些运算来打散数据。使得取得的位置更加分散，从而减少了hash冲突。当然了，为了高效，HashMap只做了一些简单的位处理。从而不至于把使用2 的幂次方带来的效率提升给抵消掉

参考地址

22.如何决定使用 HashMap 还是 TreeMap？

TreeMap 默认按照字母顺序进行存储有排序，可以进排序扩展；如果数据需要按照一定的顺序进行存储，可以使用TreeMap。
HashMap 不能排序按hash值存储
TreeMap是SortedMap接口基于红黑树的实现，该类保证了映射按照升序排列关键字。HashMap是根据键的HashCode 值存储数据，取得数据的顺序是完全随机的，HashMap取值的速度更快

23.说一下 HashMap 的实现原理？

HashMap的实现原理：

    1.利用key的hashCode重新hash计算出当前对象的元素在数组中的下标
    2.存储时，如果出现hash值相同的key，此时有两种情况。(1)如果key相同，则覆盖原始值；(2)如果key不同（出现冲突），则将当前的key-value放入链表中
    3.获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。
    4.理解了以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。

24.说一下 HashSet 的实现原理？

HashSet实际上是一个HashMap实例，都是一个存放链表的数组。它不保证存储元素的迭代顺序；此类允许使用null元素。HashSet中不允许有重复元素，这是因为HashSet是基于HashMap实现的，HashSet中的元素都存放在HashMap的key上面，而value中的值都是统一的一个固定对象private static final Object PRESENT = new Object();

HashSet中add方法调用的是底层HashMap中的put()方法，而如果是在HashMap中调用put，首先会判断key是否存在，如果key存在则修改value值，如果key不存在这插入这个key-value。而在set中，因为value值没有用，也就不存在修改value值的说法，因此往HashSet中添加元素，首先判断元素（也就是key）是否存在，如果不存在这插入，如果存在着不插入，这样HashSet中就不存在重复值。

 所以判断key是否存在就要重写元素的类的equals()和hashCode()方法，当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算次对象的哈希值，此哈希值决定了此对象在Set中存放的位置；若此位置没有被存储对象则直接存储，若已有对象则通过对象所在类的equals()比较两个对象是否相同，相同则不能被添加。

25.ArrayList 和 LinkedList 的区别是什么？

ArrayList和LinkedList的大致区别：
1.ArrayList是实现了基于动态数组的数据结构，LinkedList是基于链表结构。
2.对于随机访问的get和set方法，ArrayList要优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。
性能对比：
1.对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对 ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是 统一的，分配一个内部Entry对象。
2.在ArrayList集合中添加或者删除一个元素时，当前的列表所所有的元素都会被移动。而LinkedList集合中添加或者删除一个元素的开销是固定的。
3.LinkedList集合不支持 高效的随机随机访问（RandomAccess），因为可能产生二次项的行为。
4.ArrayList的空间浪费主要体现在在list列表的结尾预留

26.如何实现数组和 List 之间的转换？

//List转数组
	ArrayList<String> strings = new ArrayList<>();
    strings.add("hello");
    strings.add("world");
    String[] array = strings.toArray(new String[strings.size()]);
    for (String s : array) {
        System.out.println(s);
    }
//---------------------------------------------------------------------------------------
//数组转List

    String[] str=new String[] {"hello","world"};
    //方式一：使用for循环把数组元素加进list
    List<String> list=new ArrayList<String>();
    for (String string : str) {
        list.add(string);
    }
    System.out.println(list);

    //方式二：
    List<String> list2=new ArrayList<String>(Arrays.asList(str));
    System.out.println(list2);

    //方式三：
    //同方法二一样使用了asList()方法。这不是最好的，
    //因为asList()返回的列表的大小是固定的。
    //事实上，返回的列表不是java.util.ArrayList类，而是定义在java.util.Arrays中一个私有静态类java.util.Arrays.ArrayList
    //我们知道ArrayList的实现本质上是一个数组，而asList()返回的列表是由原始数组支持的固定大小的列表。
    //这种情况下，如果添加或删除列表中的元素，程序会抛出异常UnsupportedOperationException。
    //java.util.Arrays.ArrayList类具有 set()，get()，contains()等方法，但是不具有添加add()或删除remove()方法,所以调用add()方法会报错。
    List<String> list3 = Arrays.asList(str);
    //list3.remove(1);
    //boolean contains = list3.contains("s");
    //System.out.println(contains);
    System.out.println(list3);

    //方式四：使用Collections.addAll()
    List<String> list4=new ArrayList<String>(str.length);
    Collections.addAll(list4, str);
    System.out.println(list4);

    //方式五：使用Stream中的Collector收集器
    //转换后的List 属于 java.util.ArrayList 能进行正常的增删查操作
    List<String> list5=Stream.of(str).collect(Collectors.toList());
    System.out.println(list5);
    }

27.ArrayList 和 Vector 的区别是什么？

ArrayList 不是线程安全的  扩展之前的0.5
Vector    线程安全       扩展之前的1
vector 多了一个public Vector(int initialCapacity, int capacityIncrement)构造器，可以设置容量增长，arraylist是没有的。

28.Array 和 ArrayList 有何区别？

array 需要声明类型长度，ArrayList不用； ArrayList 可以设置只读

29.在 Queue 中 poll()和 remove()有什么区别？

队列是一个典型的先进先出（FIFO）的容器。即从容器的一端放入事物，从另一端取出，并且事物放入容器的顺序与取出的顺序是相同的。
1、offer()和add()的区别
add()和offer()都是向队列中添加一个元素。但是如果想在一个满的队列中加入一个新元素，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。可以据此在程序中进行有效的判断！

2、peek()和element()的区别
peek()和element()都将在不移除的情况下返回队头，但是peek()方法在队列为空时返回null，调用element()方法会抛出NoSuchElementException异常。

3、poll()和remove()的区别
poll()和remove()都将移除并且返回对头，但是在poll()在队列为空时返回null，而remove()会抛出NoSuchElementException异常

30.哪些集合类是线程安全的？

Vector：就比Arraylist多了个同步化机制（线程安全Collections.synchronizedList(new ArrayList<E>());
Hashtable：就比Hashmap多了个线程安全。
ConcurrentHashMap:是一种高效但是线程安全的集合。
Stack：栈，也是线程安全的，继承于Vector。

31.迭代器 Iterator 是什么？

Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包括了可以返回迭代器实例的迭代方法。迭代器可以在迭代过程中删除底层集合的元素，但是不可以直接调用集合的remove(Object obj)删除，可以通过迭代器的remove()方法删除

32.Iterator 怎么使用？有什么特点？

Iterator<String> iterator = list.iterator();
		while (iterator.hasNext()) {
			String str = iterator.next();
			System.out.println(str);
		}

33.Iterator 和 ListIterator 有什么区别？

ListIterator 继承 Iterator
使用范围不同，Iterator可以迭代所有集合；ListIterator 只能用于List及其子类
ListIterator 比 Iterator多方法
          add(E e)  将指定的元素插入列表，插入位置为迭代器当前位置之前
          set(E e)  迭代器返回的最后一个元素替换参数e
          hasPrevious()  迭代器当前位置，反向遍历集合是否含有元素
          previous()  迭代器当前位置，反向遍历集合，下一个元素
          previousIndex()  迭代器当前位置，反向遍历集合，返回下一个元素的下标
          nextIndex()  迭代器当前位置，返回下一个元素的下标


ListIterator 有 add 方法，可以向 List 中添加对象；Iterator 不能
ListIterator 有 hasPrevious() 和 previous() 方法，可以实现逆向遍历；Iterator不可以
ListIterator 有 nextIndex() 和previousIndex() 方法，可定位当前索引的位置；Iterator不可以
ListIterator 有 set()方法，可以实现对 List 的修改；Iterator 仅能遍历，不能修改

34.怎么确保一个集合不能被修改？

使用Collections.unmodifiable修饰
Collections.unmodifiableList(List)
Collections.unmodifiableSet(Set)
Collections.unmodifiable T（T val）

三、多线程

35.并行和并发有什么区别？

36.线程和进程的区别？

37.守护线程是什么？

38.创建线程有哪几种方式？

39.说一下 runnable 和 callable 有什么区别？

40.线程有哪些状态？

41.sleep() 和 wait() 有什么区别？

42.notify()和 notifyAll()有什么区别？

43.线程的 run()和 start()有什么区别？

44.创建线程池有哪几种方式？

45.线程池都有哪些状态？

46.线程池中 submit()和 execute()方法有什么区别？

47.在 java 程序中怎么保证多线程的运行安全？

48.多线程锁的升级原理是什么？

49.什么是死锁？

50.怎么防止死锁？

51.ThreadLocal 是什么？有哪些使用场景？

52.说一下 synchronized 底层实现原理？

53.synchronized 和 volatile 的区别是什么？

54.synchronized 和 Lock 有什么区别？

55.synchronized 和 ReentrantLock 区别是什么？

56.说一下 atomic 的原理？

四、反射

57.什么是反射？

58.什么是 java 序列化？什么情况下需要序列化？

59.动态代理是什么？有哪些应用？

60.怎么实现动态代理？

五、对象拷贝

61.为什么要使用克隆？

62.如何实现对象克隆？

63.深拷贝和浅拷贝区别是什么？

六、Java Web

64.jsp 和 servlet 有什么区别？

65.jsp 有哪些内置对象？作用分别是什么？

66.说一下 jsp 的 4 种作用域？

67.session 和 cookie 有什么区别？

68.说一下 session 的工作原理？

69.如果客户端禁止 cookie 能实现 session 还能用吗？

70.spring mvc 和 struts 的区别是什么？

71.如何避免 sql 注入？

72.什么是 XSS 攻击，如何避免？

73.什么是 CSRF 攻击，如何避免？

七、异常

74.throw 和 throws 的区别？

75.final、finally、finalize 有什么区别？

76.try-catch-finally 中哪个部分可以省略？

77.try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

78.常见的异常类有哪些？

八、网络

79.http 响应码 301 和 302 代表的是什么？有什么区别？

80.forward 和 redirect 的区别？

81.简述 tcp 和 udp的区别？

82.tcp 为什么要三次握手，两次不行吗？为什么？

83.说一下 tcp 粘包是怎么产生的？

84.OSI 的七层模型都有哪些？

85.get 和 post 请求有哪些区别？

86.如何实现跨域？

87.说一下 JSONP 实现原理？

九、设计模式

88.说一下你熟悉的设计模式？

89.简单工厂和抽象工厂有什么区别？

十、Spring/Spring MVC

90.为什么要使用 spring？

91.解释一下什么是 aop？

92.解释一下什么是 ioc？

93.spring 有哪些主要模块？

94.spring 常用的注入方式有哪些？

95.spring 中的 bean 是线程安全的吗？

96.spring 支持几种 bean 的作用域？

97.spring 自动装配 bean 有哪些方式？

98.spring 事务实现方式有哪些？

99.说一下 spring 的事务隔离？

100.说一下 spring mvc 运行流程？

101.spring mvc 有哪些组件？

102.@RequestMapping 的作用是什么？

103.@Autowired 的作用是什么？

十一、Spring Boot/Spring Cloud

104.什么是 spring boot？

105.为什么要用 spring boot？

106.spring boot 核心配置文件是什么？

107.spring boot 配置文件有哪几种类型？它们有什么区别？

108.spring boot 有哪些方式可以实现热部署？

109.jpa 和 hibernate 有什么区别？

110.什么是 spring cloud？

111.spring cloud 断路器的作用是什么？

112.spring cloud 的核心组件有哪些？

十二、Hibernate

113.为什么要使用 hibernate？

114.什么是 ORM 框架？

115.hibernate 中如何在控制台查看打印的 sql 语句？

116.hibernate 有几种查询方式？

117.hibernate 实体类可以被定义为 final 吗？

118.在 hibernate 中使用 Integer 和 int 做映射有什么区别？

119.hibernate 是如何工作的？

120.get()和 load()的区别？

121.说一下 hibernate 的缓存机制？

122.hibernate 对象有哪些状态？

123.在 hibernate 中 getCurrentSession 和 openSession 的区别是什么？

124.hibernate 实体类必须要有无参构造函数吗？为什么？

十三、Mybatis

125.mybatis 中 #{}和 ${}的区别是什么？

126.mybatis 有几种分页方式？

127.RowBounds 是一次性查询全部结果吗？为什么？

128.mybatis 逻辑分页和物理分页的区别是什么？

129.mybatis 是否支持延迟加载？延迟加载的原理是什么？

130.说一下 mybatis 的一级缓存和二级缓存？

131.mybatis 和 hibernate 的区别有哪些？

132.mybatis 有哪些执行器（Executor）？

133.mybatis 分页插件的实现原理是什么？

134.mybatis 如何编写一个自定义插件？

十四、RabbitMQ

135.rabbitmq 的使用场景有哪些？

136.rabbitmq 有哪些重要的角色？

137.rabbitmq 有哪些重要的组件？

138.rabbitmq 中 vhost 的作用是什么？

139.rabbitmq 的消息是怎么发送的？

140.rabbitmq 怎么保证消息的稳定性？

141.rabbitmq 怎么避免消息丢失？

142.要保证消息持久化成功的条件有哪些？

143.rabbitmq 持久化有什么缺点？

144.rabbitmq 有几种广播类型？

145.rabbitmq 怎么实现延迟消息队列？

146.rabbitmq 集群有什么用？

147.rabbitmq 节点的类型有哪些？

148.rabbitmq 集群搭建需要注意哪些问题？

149.rabbitmq 每个节点是其他节点的完整拷贝吗？为什么？

150.rabbitmq 集群中唯一一个磁盘节点崩溃了会发生什么情况？

151.rabbitmq 对集群节点停止顺序有要求吗？

十五、Kafka

152.kafka 可以脱离 zookeeper 单独使用吗？为什么？

153.kafka 有几种数据保留的策略？

154.kafka 同时设置了 7 天和 10G 清除数据，到第五天的时候消息达到了 10G，这个时候 kafka 将如何处理？

155.什么情况会导致 kafka 运行变慢？

156.使用 kafka 集群需要注意什么？

十六、Zookeeper

157.zookeeper 是什么？

158.zookeeper 都有哪些功能？

159.zookeeper 有几种部署模式？

160.zookeeper 怎么保证主从节点的状态同步？

161.集群中为什么要有主节点？

162.集群中有 3 台服务器，其中一个节点宕机，这个时候 zookeeper 还可以使用吗？

163.说一下 zookeeper 的通知机制？

十七、MySql

164.数据库的三范式是什么？

165.一张自增表里面总共有 7 条数据，删除了最后 2 条数据，重启 mysql 数据库，又插入了一条数据，此时 id 是几？

166.如何获取当前数据库版本？

167.说一下 ACID 是什么？

168.char 和 varchar 的区别是什么？

169.float 和 double 的区别是什么？

170.mysql 的内连接、左连接、右连接有什么区别？

171.mysql 索引是怎么实现的？

172.怎么验证 mysql 的索引是否满足需求？

173.说一下数据库的事务隔离？

174.说一下 mysql 常用的引擎？

175.说一下 mysql 的行锁和表锁？

176.说一下乐观锁和悲观锁？

177.mysql 问题排查都有哪些手段？

178.如何做 mysql 的性能优化？

十八、Redis

179.redis 是什么？都有哪些使用场景？

180.redis 有哪些功能？

181.redis 和 memecache 有什么区别？

182.redis 为什么是单线程的？

183.什么是缓存穿透？怎么解决？

184.redis 支持的数据类型有哪些？

185.redis 支持的 java 客户端都有哪些？

186.jedis 和 redisson 有哪些区别？

187.怎么保证缓存和数据库数据的一致性？

188.redis 持久化有几种方式？

189.redis 怎么实现分布式锁？

190.redis 分布式锁有什么缺陷？

191.redis 如何做内存优化？

192.redis 淘汰策略有哪些？

193.redis 常见的性能问题有哪些？该如何解决？

十九、JVM

194.说一下 jvm 的主要组成部分？及其作用？

195.说一下 jvm 运行时数据区？

196.说一下堆栈的区别？

197.队列和栈是什么？有什么区别？

198.什么是双亲委派模型？

199.说一下类加载的执行过程？

200.怎么判断对象是否可以被回收？

201.java 中都有哪些引用类型？

202.说一下 jvm 有哪些垃圾回收算法？

203.说一下 jvm 有哪些垃圾回收器？

204.详细介绍一下 CMS 垃圾回收器？

205.新生代垃圾回收器和老生代垃圾回收器都有哪些？有什么区别？

206.简述分代垃圾回收器是怎么工作的？

207.说一下 jvm 调优的工具？

208.常用的 jvm 调优的参数都有哪些？

d 是几？

166.如何获取当前数据库版本？

167.说一下 ACID 是什么？

168.char 和 varchar 的区别是什么？

169.float 和 double 的区别是什么？

170.mysql 的内连接、左连接、右连接有什么区别？

171.mysql 索引是怎么实现的？

172.怎么验证 mysql 的索引是否满足需求？

173.说一下数据库的事务隔离？

174.说一下 mysql 常用的引擎？

175.说一下 mysql 的行锁和表锁？

176.说一下乐观锁和悲观锁？

177.mysql 问题排查都有哪些手段？

178.如何做 mysql 的性能优化？

十八、Redis

179.redis 是什么？都有哪些使用场景？

180.redis 有哪些功能？

181.redis 和 memecache 有什么区别？

182.redis 为什么是单线程的？

183.什么是缓存穿透？怎么解决？

184.redis 支持的数据类型有哪些？

185.redis 支持的 java 客户端都有哪些？

186.jedis 和 redisson 有哪些区别？

187.怎么保证缓存和数据库数据的一致性？

188.redis 持久化有几种方式？

189.redis 怎么实现分布式锁？

190.redis 分布式锁有什么缺陷？

191.redis 如何做内存优化？

192.redis 淘汰策略有哪些？

193.redis 常见的性能问题有哪些？该如何解决？

十九、JVM

194.说一下 jvm 的主要组成部分？及其作用？

195.说一下 jvm 运行时数据区？

196.说一下堆栈的区别？

197.队列和栈是什么？有什么区别？

198.什么是双亲委派模型？

199.说一下类加载的执行过程？

200.怎么判断对象是否可以被回收？

201.java 中都有哪些引用类型？

202.说一下 jvm 有哪些垃圾回收算法？

203.说一下 jvm 有哪些垃圾回收器？

204.详细介绍一下 CMS 垃圾回收器？

205.新生代垃圾回收器和老生代垃圾回收器都有哪些？有什么区别？

206.简述分代垃圾回收器是怎么工作的？

207.说一下 jvm 调优的工具？

208.常用的 jvm 调优的参数都有哪些？