Java刷题1

1.ArrayList和Array之间相互转换，基本类型只能转为包装类
一维：list.toArray(new int[list.size()])
List<int[]> list = new ArrayList<>();
二维：list.toArray(new int[list.size()][]);

2.静态数组在什么情况下，可以声明数组大小？
为什么二维以上一定要声明第一维数组的长度？
属于动态初始化。
不允许同时使用静态初始化和动态初始化。
静态初始化，即声明时就赋值了。
动态初始化，声明时不赋值，二维以上，第一维一定要赋值。

3.vscode关闭代码提示。
设置--》搜索prevent---》打开setting.json文件，添加下面两行。
“editor.quickSuggestions”: false,
“editor.suggestOnTriggerCharacters”: false

4.java枚举类型如何使用？
枚举是中每个属性都是枚举实例，所以每一个实例都会初始化构造函数。
可以给它添加方法，获取实例的属性

5.死锁怎么写？
使用分别创建定义两个线程，在构造方法中传入obj1，obj2。通过两重synchronized不同的obj作为锁，先让t1拿到obj1，然后t2拿到obj2;之后t1等到obj2,t2等待obj1。
获取线程的名Thread.currentThread().getName()
让当前线程睡眠Thread.sleep(mills);

6.为什么内部类要不能直接new,而需要要通过new外部类.内部类才能new。静态类内部类则可以直接new。
因为类加载是能不加载就不加载？所以你这外部类还未加载轮不到内部类加载。
静态类早就加载了。

7.线程的wait()方法怎么用？既然它是只在同步代码中才能用。
8.抽象类和普通区别不大，加多了一个抽象方法。其他都一样。可以有构造函数。
接口和抽象类区别较大，全是public权限。不能有普通方法，不能有构造方法，不能普通成员变量。

9.servlet的生命周期
servlet：init()-->service()-->destroy()
init():ServletConfig Servlet
service():doPost() doGet() requestServlet/responseServlet
destroy():destroy
读取ServletConfig的init参数
servletConfig.getInitParameter();

10.throws声明抛异常，不能抛的异常有

11.byte[]转String，直接使用构造函数 new String(src,"该btye数组约定的编码")

12.如何记忆0 A a的ascii对应的数字486597 486 597 486+111 65对应的A--六六大顺

13.只要前台线程都结束了，jre就结束jvm进程，后台的线程会直接杀死，不会继续执行。后台线程进守护线程

14.父类 子类，静态域 子类成员初始化 子类构造块 子类构造函数

15.HashMap的value可以为null。key也可以为null，它存在table[0]的这个桶中。已经有则更新为新的value，没有则插入进入。
HashTable ConcurrentHashMap的value不能为null，当它们获得一个null时，不能判断是异常还是值为null，因为调用contains(key)，这个key对应的value会被修改，如果另一个线程修改为非null，那么你就会报错了，本来不应该报错。
key也不能为null。

16.Map的遍历方法
it = map.entrySet().iterator(); it.hasNext() Entry<Integer,Node> entry = it.next();
for(Object obj:map.keySet()) map.get(obj)
for(Map.Entry<String,Object> entry:map.entrySet()){ entry.getKey() + entry.getValue()}

17.this(x)在本类中调用其他构造方法

18.不使用new创建对象在比较对象时-127,128时共享一个对象，这时对象比较会返回true。（Integer i=-127;Integer i = Integer.valueOf(9)）
而使用new创建对象，每一个new都会直接创建一个对象。比较对象时返回true

19.数组equals比较的是内存地址，不是数组的每个值。数组长度不可动态修改。
数组是对象。Arrays.equals()可以比较值两个数组的值。

20.对象的转型，类比基本类型的转型，高转低需要强转指定类型，低可以自动向上转。对象的父类可以直接转子类，子类需要强转父类。

21.实现线程的方法，Thread Runnable Callable；Callable是可以有返回值的
public class ThreadCall impls Callable{
public String call() throws Exception{ xxx return "xxx";}
}
FutrueTask ft = new FutrueTask<>(new ThreadCall());
new Thread(ft).start();
22.Byte是包装类初始化为null，输出未初始化的Byte打印null

23.在所有数字都最优的情况下，插入排序的时间最少。

24.spring中定义的事务传播行为。
PROPAGATION_REQUIRED需要 支持主方法的事务，假设主方法没有事务。就新建一个事务
PROPAGATION_SUPPORTS支持 支持主方法的事务，假设主方法没有事务，就以非事务方式运行
PROPAGATION_MANDATORY强制 支持主方法事务，假设当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW必须要新的 新建事务，假设当前存在事务。把当前事务挂起
PROPAGATION_NOT_SUPPORTED不支持 以非事务方式运行操作。假设当前存在事务，就把当前事务挂起
PROPAGATION_NEVER绝不 以非事务方式运行，假设当前存在事务，则抛出异常
PROPAGATION_NESTED嵌套 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

25.spring中的事务的只读
如果在使用事务的情况下，所有操作都是读操作，那建议把事务设置成只读事务，或者事务的传播途径最好能设置为 supports （运行在当前的事务范围内，如果当前没有启动事务，那么就不在事务范围内运行）或者 not supports （不在事务范围内执行，如果当前启动了事务，那么挂起当前事务），这样不在事务下，就不会调用transactionContext.managedFlush(); 方法。
所有只读事务与读写事务的比较大的运行性能区别就是只读事务避免了Hibernate的检测和同步持久对象的状态的更新,提升了运行性能。

int a = 10;
System.out.println(a++ + a--);
输出21，a是10 a变成11

27.equals()方法不重写比较的是对象的地址，String等类重写了equals的除外
如果一个对象a.equals(b)返回true，那么这两个对象是同一个对象，所以hashcode一定相等。

28.强引用：不能被回收
软引用：内存不够时才回收
弱引用：只能活到下一次垃圾回收之前
虚引用：虚引用的目的不影响垃圾回收，只是在垃圾回收的时候收到一个系统通知。

29.遍历map的value，for(Object val: map.values())

30.bean的作用域,
singleton--每个请求共享一个bean、
prototype每个bean请求分配一个实例、
下面三个只适用于浏览器
request--每个请求一个bean、
session--每个session一个bean、
globalsession--所有session共享一个bean
31.bean的生命周期

32.反射
1)首先得到Class
得到Class的3个方法：
data.getClass()
Data.class
Class.forName("java.util.Date");
2)类的信息
getPackage()
getSuperClass()
getInterface()
3)反射取构造方法
getConstructor("参数")
getDeclaredConstructor("参数")
取得所有构造方法
getConstructors()//取得父类和public的构造方法
getDeclearedConstructors()//取得所有权限的构造方法
根据构造方法对象创建实例:构造方法对象.
4)取得普通方法
getMethods()//取得父类和本类的public方法
getDeclaredMethods()//取得父类及本类的所有方法
获取指定类型的方法
getMehods(方法名,参数)
getDeclaredMethods(方法名,参数)
反射调用方法
普通方法对象.invoke(类的实例化对象,当前方法的参数)
5)反射中类的属性
getFields()
getDeclearedFields()
getField(属性名);
getDeclearedField(属性名);
设置属性
属性对象.set(类实例,要设置的值)
如果当前方法是封装的需要先接触当前属性的封装:属性对象.setAccessible(true)
Filed/Method/Constructor在Java.lang.reflet中，而Class而是在Java.lang中。
反射可以通过类的路径来得到该类的全部信息。
反射可以动态的调用类和对象的任意方法，不能动态修剪一个类。
通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法。动态代理就是。
33.双亲委派机制的应用。

34.aop的使用。

35.char[]数组转string：String.valueOf(chars)

36.工厂方法和抽象工厂的区别。
工厂方法：是一个厂生产一个产品。一个厂只有个产品
抽象工厂是：一个厂生产多个产品。一个厂有它的品牌的多个产品。每个厂相当于一个品牌。
不仅抽象了产品还抽象了工厂
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
37.异或运算满足交换律和结合律。

38.string的速度：String<StringBuffer<StringBuilder
因为String是常量要添加字符要重新拼接

39.只有 instanceOf只能向上比较才是true，向它的叔叔比较会是false

1、jps：查看本机java进程信息。
2、jstack：打印线程的栈信息，制作线程dump文件。
3、jmap：打印内存映射，制作堆dump文件
4、jstat：性能监控工具 jstat -gcutil pid interval（多少秒监控一次gc的状况）
5、jhat：内存分析工具
6、jconsole：简易的可视化控制台，选择某个进程进行查看。
7、jvisualvm：功能强大的控制台

41.full GC触发的条件
来年代满、持久代满、System.gc()

42.minorGC
1)如果Eden区满了，会把垃圾回收到survivor区，2）保证一个survivor区是满的，互相复制存活对象。survivor区也满了触发Minor GC将对象复制到老年代
垃圾收集器：
Serial收集器 jdk1.3
ParNew收集器 jdk1.4
Parallel Scavenge收集器 ~~1.4
CMS ~~1.5
Serial Old（MSC） ~~1.5
Parallel Old ~~1.6
G1 收集器

1.Serial收集器
单线程收集器，收集时会暂停所有工作线程（我们将这件事情称之为Stop The World，下称STW），使用复制收集算法，虚拟机运行在Client模式时的默认新生代收集器。
2.ParNew收集器
ParNew 收集器就是Serial的多线程版本，除了使用多条收集线程外，其余行为包括算法、STW、对象分配规则、回收策略等都与Serial收集器一摸一样。对 应的这种收集器是虚拟机运行在Server模式的默认新生代收集器，在单CPU的环境中，ParNew收集器并不会比Serial收集器有更好的效果。
3.Parallel Scavenge收集器
Parallel Scavenge收集器（下称PS收集器）也是一个多线程收集器，也是使用复制算法，但它的对象分配规则与回收策略都与ParNew收集器有所不同，它是 以吞吐量最大化（即GC时间占总运行时间最小）为目标的收集器实现，它允许较长时间的STW换取总吞吐量最大化。
4.Serial Old收集器
Serial Old是单线程收集器，使用标记－整理算法，是老年代的收集器，上面三种都是使用在新生代收集器。
5.Parallel Old收集器
老年代版本吞吐量优先收集器，使用多线程和标记－整理算法，JVM 1.6提供，在此之前，新生代使用了PS收集器的话，老年代除Serial Old外别无选择，因为PS无法与CMS收集器配合工作。

6.CMS（Concurrent Mark Sweep）收集器
CMS 是一种以最短停顿时间为目标的收集器，使用CMS并不能达到GC效率最高（总体GC时间最小），但它能尽可能降低GC时服务的停顿时间，这一点对于实时或 者高交互性应用（譬如证券交易）来说至关重要，这类应用对于长时间STW一般是不可容忍的。CMS收集器使用的是标记－清除算法，也就是说它在运行期间会 产生空间碎片，所以虚拟机提供了参数开启CMS收集结束后再进行一次内存压缩。

45.count=count++ count会是 相当于 temp = count; count = count+1; count = temp;

46.dubbo
dubbo的10个划分

finally没有return时：catch中有return finally后再进行return，finally不会执行了。
finally中有return时：try或catch中也有return，不会再回去return了。
一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效
如果try中i++，return，finnaly 中也i++return，这两个return的只是不一样的。try中return try中的i，finally中return finally的i。
48.list.add(0,4);在0的位置添加4，其他元素先后移动。

49.java中char可以表示一个汉字，因为在java中一个char占两个字节。

50.java中不明确指定数据类型，整型默认是int，浮点型默认是double。

51.volatile禁止指令重排

52.super()和this()，不能在静态类或者静态代码块中使用，因为静态方法或静态代码中不能使用this或super
super和this都只能位于构造器的第一行，不能

1.父类静态成员和静态初始化快，按在代码中出现的顺序依次执行。
2.子类静态成员和静态初始化块，按在代码中出现的顺序依次执行。
3. 父类的实例成员和实例初始化块，按在代码中出现的顺序依次执行。
4.执行父类的构造方法。
5.子类实例成员和实例初始化块，按在代码中出现的顺序依次执行。
6.执行子类的构造方法。
除了子类的静态代码块和静态成员能够和父类竞争，其他的都输了
并不是静态xx，而是静态域，静态域是静态变量、静态块、(静态方法不属于静态域)。按照先后顺序初始化。

54.在接口里面的变量默认都是public static final 的，它们是公共的,静态的,最终的常量.相当于全局常量，可以直接省略修饰符。
实现类可以直接访问接口中的变量

55.ThreadLocal使用了开放定址法 解决哈希冲突。开放定址法：一直走直到找到厕所。拉链法：会排队。

56.局部变量，没有像成员变量那样类加载时会有初始化赋值，所以要使用局部变量时，一定要显式的给它赋值，也就是定义时就给它数值。

yield会使当前线程重回到可执行状态，等待cpu的调度，不释放锁
join是等待该线程结束，再继续执行。t.join()会等t结束main再继续执行。它的底层是调用了wait()方法。
58.内部类中，只有静态内部类才可以声明静态方法。

深堆和浅堆的问题
深堆：自己的和引用别的对象
浅堆：只有自己的
当浅堆为null时还不能释放，还需要其他引用它的也释放才能回收(因为它不被b指向，还可以被a指向。)。

byte
+=会自动强转（自动装箱功能） a+=b
a = a+b不会自动转型转成byte。需要a = (byte)(a+b)
两个操作数.....，否则（操作数为：byte、short、int 、char），两个数都会被转换成int类型，并且结果也是int类型。
byte b6;
final byte b4=4,b5=5;
语句2：b6=b4+b5
语句 2：b4 、b5被声明final 所以类型是不会转换， 计算结果任然是byte ，所以 语句2正确。

application对象是共享的，多个用户共享一个，以此实现数据共享和通信
JSP内置对象和属性列举如下：
1.request对象
客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。
2.response对象
response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。
3.session对象
session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.
4.out对象
out对象是JspWriter类的实例,是向客户端输出内容常用的对象
5.page对象
page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例
6.application对象
application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。
7.exception对象
exception对象是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象
8.pageContext对象
pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的SESSION，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本 类名也叫pageContext。
9.config对象
config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）
62.标识符可以包括这4种字符：字母、下划线、$、数字；开头不能是数字；不能是关键字，不能是显式常量（null，true，false）

final关键字
1.final修饰变量，则等同于常量
2.final修饰方法中的参数，称为最终参数。
3.final修饰类，则类不能被继承
4.final修饰方法，则方法不能被重写。
final修饰的成员变量只允许赋值一次，且只能在类方法赋值
抽象类和接口不能被final修饰，它们需要被继承和实现。
64.自定义Servlet时尽量不要定义成员变量，多线程环境下定义的成员变量会成为线程共享变量，

考察组合索引的知识。有一个最左优先的原则，组合索引(a, b, c)，会建立三个索引, (a), (a, b), (a, b, c)。
在查询语句中，
1)where a = xxx
2)或者 where a = xxx and b = yyy
3)或者where a = xxx and b = yyy and c = zzz
4)或者 where b = yyy and c = zzz and a = xxx
都可以使用索引。第4）中情况可以优化成第3）种。
不包含a的情况，则用不到索引。例如where b = yyy and c = zzz

use-a是聚合
is-a继承
has-a是组合
67.存根（Stub）与以下哪种技术有关
68.AbastctCollection ---AbastactList(实现了List接口也就是所有子类都要实现List接口)---AbstactSequentialList---LinkedList
---Vector和ArrayList
---Stack
----AbstactSet（还实现了Set接口也就是所有子类都要实现Set接口）-----TreeSet（还实现了SotedSet）和HashSet和LinkedHashSet
Map(interface)----AbstractMap（还实现了Map接口也就是所有子类都要实现Map接口）----TreeMap(还实现了SotedMap)、HashMap、WeakHashMap、IdentityHashMap。LinkedHashMap继承了HashMap
70.客户端拥有一个Stub，远程服务器有一个Sketons。需要是调用Sketons，相当于运行时的动态链接。

1、开闭原则——面向对象设计原则
2、里氏替换原则——面向对象设计原则
3、依赖倒置原则——面向对象设计原则
4、单一职责原则——面向对象设计原则
5、接口隔离原则——面向对象设计原则
6、迪米特法则——面向对象设计原则
7、合成复用原则——面向对象设计原则
迪，开里合接一单
（1）创建型模式：主要用于创建对象。
共5种：简单工厂（Simple Factory）模式、抽象工厂（Factory Method）模式、单例（Singleton）模式、建造者（Builder）模式和原型（Prototype）模式。
（2）结构型模式：主要用于处理类或者对象的组合。
共7种：适配器模式（Adapter）、装饰（Decorator）模式、代理（Proxy）模式、外观/门面（Facade）模式、桥接（Bridge）模式、组合/合成（Composite）模式和享元（Flyweight Pattern）模式。
（3）行为型模式：主要用于描述类或者对象怎样交互和怎样给分配职责。
共11中：策略（Strategy）模式、模板方法（Templete Method）模式、观察者（Observer）模式、迭代子（Iterator）模式、责任链（Chain of Responsibility）模式、命令（Command）模式、备忘录（Memento）模式、状态（State）模式、访问者（Visitor）模式、中介者/调停者（Mediator）模式和解释器（Interpreter）模式。

72.spring如何解决循环依赖。

73.for循环不符合条件，不会再走for中的最后一条语句了

74.ASCII码是ANSI码的子集
在简体中文的Windows系统中，ANSI就是GB2312

75.真数组： 数组元素在内存中是一个接着一个线性存放的，通过第一个元素就能访问随后的元素，和数据类型覆盖并没有关系。

76.jsp中实现分页
1.取总记录数 2.计算页数，3.获取要显示的页的记录
//1.查询得到rowCount
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
Connection ct=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;dataBaseName=System","sa","");
Statement sm=ct.createStatement();
ResultSet rs=sm.exeuteQuery("select count() form users "); if(rs.next()){
rowCount=rs.getInt(1);
} //2。计算pageCount if(rowCount%pageSize==0){
pageCount=rowCount/pageSize;
}else{
pageCount=rowCount/pageSize+1;
} //3.4查询出需要显示的记录
rs=sm.exeuteQuery("select top "+pageSize +" * from users where userId not in(select top " +pageSize(pageNow-1)+" userId from users) "); %> //显示

指定永久代的大小-XX:PermSize和-XX:MaxPermSize来指定最小值和最大值。
off-heap指的是堆外内存，JVM进程管理。
方法其实存放在方法区，这道题其实想考察的是，方法区中包括类信息、常量、静态变量、即时编译器编译后的代码。
方法自然就是类信息（是类的方法嘛）

78. C++是编译型语言，所谓编译型语言，就是源码一次编译，直接在编译的过程中链接了，形成了机器码。Java不是编译型语言，是解释性语言，所谓的解释型语言，就是源码会先经过一次编译，成为中间码，中间码再被解释器解释成机器码。

c++存在虚函数是为了多态，java中的普通方法相当于虚函数，加上final变成非虚函数。
Java抽象函数(纯虚函数)

都是运算完的结果

Java默认提供的三个ClassLoader是BootStrap ClassLoader，Extension ClassLoader，App ClassLoader
(1)启动类加载器 : 它用来加载 Java 的核心库，比如String、System这些类
(2)扩展类加载器 : 它用来加载 Java 的扩展库。
(3) 应用程序类加载器 : 负责加载用户类路径上所指定的类库，一般来说，Java 应用的类都是由它来完成加载的。
JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。

保证线程安全的前提是必须保证原子性,可见性,有序性，（有 远 见）
有序性就要求线程在访问读写共享变量时只能“串行”执行

83.枚举
枚举在java.lang.Enum;

Bean的生命周期5个阶段：
1）实例化：实例化是指Bean 从Class到Object
2）初始化前 postProcessBeforeInitialization
3）初始化 afterPropertiesSet
4）初始化后postProcessAfterInitialization
5）销毁 DisposableBean

85.对象头

86.位运算
较短的数位会补零，然后参与运算。

87.Math.ceil() //向上取整

88.file.canWrite();
file.canRead();

主键可以作为外键与另一个表相关。
B. 主键不能为NULL值
C. 外键不可以接受多个空值。
D. 一个表中可以有多个外键。

接口和interface无关
Map map = new HashMap();
map.clone();//报错，

91.maven的几个命令

92.缓存击穿

93.redis分布式锁，
如果不存在我才能够返回OK，也就是只有一个线程能够设置锁，其他线程设置不到就不会返回OK。等到线程完成后我重新调用一次getSkuInfo方法，就可以从redis中得到数据了

94.接口中的default在实现类可以不实现，也可以实现