牛客刷题练习题整理（一）java

21/9/1

1.java

x.toUpperCase();操作的结果不是x，而是产生了一个空引用“FMN”。
所以输出的结果是Fmnwxy

2.java

java命令行执行程序，格式是 java 类名 参数…
所以程序输入的参数数组是one two three

3.java

检查异常：编译时报错
非检查异常：运行时异常+其他异常（编译时不报错，但也没有继承RuntimeException类）

4.java

jvm区域 = 堆+非堆
堆 = 新生代+老年代
= eden+from survivor +to survivor + 老年代
非堆 = 永久代+代码缓存区+java虚拟机栈+本地方法栈
默认 新生代与老年代的比例为1:2
eden:from:to 约等于 8:1:1
元数据区是jdk8以后，用来替代永久代的

5.java

顺序是Y(x) X Y(z) Z

6.java

1、jps：查看本机java进程信息。 java process status tools
2、jstack：打印线程的栈信息，制作线程dump文件。 java stack
3、jmap：打印内存映射，制作堆dump文件
4、jstat：性能监控工具
5、jhat：内存分析工具 java heap analysis tools
6、jconsole：简易的可视化控制台
7、jvisualvm：功能强大的控制台

7.java

byte是1个字节的对象，对于129:
原码 10000001 (由四个字节的int类型裁剪而来，第一位由数值为变为符号位)
补码 10000001
反码 11111110 +1 = 11111111
原码 10000000 = -127

8.java

顶层容器不能被其他容器包含 JTree可以被包含

9.java

SimpleDateFormat对象是线程不安全的，主要体现在format()和parse()方法。 format()方法中，变量calendar不是线程同步的，多个线程并发执行这个方法时会修改time，所以是线程不安全的。如果要线程安全需要重新实现这个方法，加锁。parse()方法不是原子操作，也会引起线程不安全问题。

Arrays.asList()返回值不是util包下的ArrayList
而是Arrays自定义的一个静态内部类

private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable{
}

ConcurrentHashMap使用ReentrantLock 重入锁对象实现同步，ReentrantLock是java实现独占锁，除synchronized的另一种形式，而且比synchronized更丰富。
重入锁是需要显式操作，可控制性比较高。同一个线程，锁可以重复进入。
重入锁可以使用有参构造函数，当参数fair为true时，创建公平锁，也可以为false，创建非公平锁（不计算等待时间）。而synchronized只能创建非公平锁。无参构造默认创建非公平锁。ReentrantLock可以通过newCondition()返回一个Condition对象，通过wait()和singal()等待和唤醒，不同的线程使用不同的Condition，这样就能区分唤醒的线程，而synchronized是随机唤醒的。ReentrantLock提供了一种中断等待锁的机制，通过lock.lockInterruptibly()来实现这个机制。

10.java

类继承一个类时，就算两个类都有相同类型的构造方法，但也不能直接调用。必须显式地调用父类的构造方法，或者隐式调用父类的无参构造方法。如果没有无参构造方法（只定义了有参）则会编译报错。

11.java

finalize方法是Object类的一个方法，jdk9以后已经过时，如果方法没有被重写，则不会调用这个方法。它的作用是在垃圾回收器工作时，该对象被回收时，释放一些资源或者延缓它的生命。gc判断一个对象应该被垃圾处理的规则是，该对象没有GC roots上的有效引用。如果在finalize()方法中将this指向可达的引用，就可以避免死亡。但是finalize()方法不一定全部执行，可能在执行到某一句就会被杀死。所以关闭文件这样的操作放在finalize()中是不合适的。

12.regex

http://www.bilibili.com/video/av21061574

/^(https?😕/)?([a-zA-Z\d]+).bilibili.com/?video/av(\D{1,8})/?KaTeX parse error: Undefined control sequence: \/ at position 11: / /^(http:\̲/̲\/)?(\w+)\.bili…/
/^(https?😕/)?(\w+).bilibili.com/?\w*KaTeX parse error: Undefined control sequence: \/ at position 11: / /^(http:\̲/̲\/)?([a-zA-Z\d]…/

/^ 表示开头 $/表示结尾
(https?😕/)? 表示出现1次或0次 https://或http://
(http://)? 表示出现1次或0次 http://
都匹配题目的http://

([a-zA-Z\d]+). 表示匹配任意多次字母或数字字符 .表示匹配任意一个字符
匹配www.
(\w+). 表示匹配任意多个字母、数字、下划线 .表示. 匹配www.
bilibili.com/?video/av 表示匹配bilibili 单个字符 com 1次或0次/ video/av符合题意
bilibili.com/?video/av 表示匹配bilibili.com 1次或0次/ video/av 符合题意
bilibili.com/?\w* 表示匹配bilibili.com 1次或0次/ 任意个字母、数字、下划线 只能匹配到video，不能匹配/ 所以C错误
(\D{1,8})/? 表示匹配1-8位的非数字字符 1次或0次/ 不能匹配数字 A错误
(\d{1,8})/? 表示匹配1-8位的数字字符 1次或0次/ B正确
\w*/+ 表示匹配任意个字母、数字、下划线 1次或多次/ 不符合题目后面没有/ D错误

13.java

题目调用t.run()，把线程方法当做一个普通方法来调用。这样执行顺序就是foobar。
如果是t.start() ，执行结果可能是foobar也可能是barfoo

14.java

15.linux

tar命令参数：
-x 解压
-t 查看内容，不解压
-c 建立压缩档案
-r 向压缩档案末尾追加文件
-u 更新压缩包中的文件
-f 只能在参数末尾使用，使用文件名
-v 显示压缩过程

16.java

C选项中的不需要处理的严重错误，描述的是Error而不是RuntimeException

17.java

ServletContext和ServletConfig都有初始化参数的设置。

ServletContext在<web-app>标签的子标签<context-param>标签声明初始化参数
ServletConfig在<servlet>标签的子标签<init-param>标签中声明初始化参数

ServletContext和ServletConfig对象都是通过getInitParameter(key)方法获得初始化参数的值

18.java

什么是哈希冲突：
不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把产生哈希冲突的不同关键字称为同义词。
解决哈希冲突：
（1）开放地址法：（再散列法）
所有输入的元素全部存放在哈希表里，位桶的实现不需要任何的链表。插入一个元素时，先进行判断，如果发生哈希冲突，就以当前地址为基准，根据再寻址的方法，去寻找下一个序列。直到寻找到一个为空的地址为止。
再寻址的方法：
①线性探查：加上一个d = 1，2，3，…，m-1；
冲突发生时，顺序查找下一个单元，直到找到为空的单元或者查遍全表。例子：ThreadLocal里面的 ThreadLocalMap
②二次探查：加上一个d= 12，-12，22，-22，…，k2，-k2 ( k<=m/2 )
③伪随机探测：加上一个d=伪随机数作为起点
（2）拉链法：
HashMap、HashSet都是用拉链法处理散列冲突的，原理就是在每个位桶上设置一个链表存放发生冲突的同义词。

19.java

ServerSocket (int port)
Creates a server socket, bound to the specified port.

Socket(InetAddress address, int port)
Creates a stream socket and connects it to the specified port number at the specified IP address.

20.java

数组命名时名称与[]可以随意排列，但声明的二维数组中第一个中括号中必须要有值，它代表的是在该二维数组中有多少个一维数组。

21.java

四种引用状态
jdk1.2之前，只用2种引用状态：未被引用和已被引用，这些无法描述某些特殊情况下的对象，比如内存充足的情况下保留，内存不足的情况下需要被抛弃的一类对象。

所以jdk1.2之后，将引用状态扩充为4种：强引用(Strong Reference)、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）
（1）强引用：
Object obj = new Object(); 只要obj指向Object对象，就称之为强引用。内存不足，jvm会报出OutOfMemoryError，不会回收对象。如果要切断强引用对象之间的联系，可以让obj =null
（2）软引用：
软引用用来描述一些非必需但有用的对象，内存充足时存在，内存不足时被回收。如果回收了软引用对象之后还是内存不足，才会抛出OutOfMemoryError。这种技术被用来实现网页缓存、图片缓存。java.lang.ref.SoftReference表示软引用对象。（3）弱引用：
弱引用的对象，无论内存是否充足，gc都会对其进行回收。java.lang.ref.WeakReference表示弱引用对象。
（4）虚引用：
如果一个对象持有虚引用，那么和没有引用关系一样，随时可能被回收。java.lang.ref.PhantomReference表示弱引用，查看它的类，发现只有一个构造函数和一个get()方法，get()返回一个null，也就是永远无法通过虚引用获得一个对象。虚引用必须要和ReferenceQueue 引用队列一起使用。

22.java

注释太多会影响编译效率。但编译会去掉注释，所以不会影响.class文件的大小。

23.java

public static void main(String[] args) {      
String str = "test OK";    
System.out.println(System.identityHashCode(str)+"\t1");//920011586    
a(str);
}
public static  void a(String str){    
System.out.println(System.identityHashCode(str)+"\t2");//920011586    
str = "tes";    
System.out.println(System.identityHashCode(str)+"\t3");//1068934215
}

String类型传递形参时，如果修改变量，会改变当前形参的地址，因为String对象是不可变的。但是修改地址对实参没用，所以原来的String对象没有改变。

24.java

客户端通过new Socket()方法创建通信的Socket对象
服务器端通过new ServerSocket()创建TCP连接对象 accept接纳客户端请求

25.java

遵守一个原则，除非是显式super调用方法，或者调用的是子类中没有的方法，执行的都是B类中的方法。
try-finally的原则：只有try块中有返回值时，返回值保留try块的结果，而不受finally块的改变。

26.java

finally 语句块在 catch语句块中的return语句之前执行 这句话错误的地方在于，return语句会执行，否则会因为finally块执行而改变变量结果。但return返回变量的时机是在finally块执行完之后。

27.java

线程安全的类：Vector Stack(继承了Vector，所以也是线程安全的) HashTable Enumeration
Property实现了 Map接口，是HashTable一个子类，所以也是线程安全的
ConcurrentHashMap采用了分段加锁的机制确保线程安全。

21/9/2

1.java

Applet运行之前，先调用 Init() 方法，然后调用 start() 方法，最后调用 paint() 方法。

2.java

无论是什么请求，HttpServlet都会调用service()方法，service()方法用来转向，根据方法的请求类型调用重写的doGet()和doPost()方法

public abstract class HttpServlet extends GenericServlet {protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String method = req.getMethod();
        if(method.equals("GET"))
        {
            long lastModified = getLastModified(req);
            if(lastModified == -1L)
            {
                doGet(req, resp);
            } else
            {
                long ifModifiedSince = req.getDateHeader("If-Modified-Since");
                if(ifModifiedSince < (lastModified / 1000L) * 1000L)
                {
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else
                {
                    resp.setStatus(304);
                }
            }
        } else
        if(method.equals("HEAD"))
        {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);
        } else
        if(method.equals("POST"))
            doPost(req, resp);
        else
        if(method.equals("PUT"))
            doPut(req, resp);
        else
        if(method.equals("DELETE"))
            doDelete(req, resp);
        else
        if(method.equals("OPTIONS"))
            doOptions(req, resp);
        else
        if(method.equals("TRACE"))
        {
            doTrace(req, resp);
        } else
        {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object errArgs[] = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(501, errMsg);
        }
    }}

3.java

for循环的第一个表达式和第三个表达式也可以有返回类型，第一个表达式只允许一次，第三个表达式每次结束都会执行，第二个表达式每次执行for循环体之前都会执行

public class Print{
	static boolean out(char c){
		System.out.println(c);
		return true;
	}
	public static void main(String[] argv){
		int i = 0;
		for(out('A');out('B') && (i<2);out('C')){
			i++;
			out('D');
		}
	}
}

ABDCBDCB
执行顺序：
表达式1
表达式2
循环体
表达式3
表达式2
循环体
表达式3
…

4.java

数组实现分为真数组和伪数组
真数组的特点：
（1）数组元素是连续存放的（线性），内存连续分配
（2）数组所存在的内存空间为数组专用，避免了数据被覆盖的问题。
（3）数组内存放的类型是确定的，唯一的
伪数组的特点：
（1）数组元素是链式存放的
（2）数组元素可以通过名访问，不需要下标访问

Java的数组实现是真数组，同时java对下标进行检查，避免了数组越界对其他数据覆盖的可能。这是java健壮性的体现。

5.java

new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。抛出的MalformedURLException继承IOException
URL的toString方法返回字符串，无论网址是否存在。

6.java

对于jdk1.7来说，
接口里的方法都是public abstract（接口不能有普通方法，抽象类可以有普通方法 ，抽象类的抽象方法可以是public protected default），
接口里的方法不能是静态方法（抽象类可以有静态方法）
接口里的变量都是public static final，
接口不能有构造方法（抽象类可以有构造方法）

7.java

new 创建对象时，调用无参或有参构造函数，完成对象的初始化
反射 创建对象时，如果使用静态方法newInstance()，只能使用无参构造方法创建对象。
clone()底层是native方法，原理是通过引用创建一个新对象，返回一个Object对象。如果使用构造函数new新对象再赋值会很慢。

如果是静态newInstance方法，只能是无参的。
但如果调用Constructor的成员方法，可以使用有参构造函数。

8.java

name属性是字面量字符串，所以都指向字符串常量池里的同一个对象，==也是相等的。

9.java

如果关闭了cookie，要使用session，就要将jsessionid重写到url参数中，然后进行加密。

10.sql

db_accessadmin可以添加、删除用户的用户
db_datareader可以查看所有数据库中用户表内数据的用户

11.sql

DATEDIFF() 函数返回两个日期之间的时间。语法DATEDIFF(datepart,startdate,enddate)
datepart表示时间差的单位，dd表示日
datediff(dd,date,getDate()) == 0 表示相差0天

12.sql

select * into xx from yy 是sql语句，用于将yy表的查询结果插入xx表。类似于oracle的insert into xx (select)语句

13.sql

CASE WHEN condition THEN result
 
[WHEN...THEN...]
 
ELSE result
 
END

通过CHARINDEX如果能够找到对应的字符串，则返回该字符串位置，否则返回0。

所以

case charIndex('A',name)
       when 0 then '没找到'
       when 1 then '在开头'
       when len(name) then '在结尾' --如果长度为5，最后一个字符的下标也是5
       else '在中间位置'
       end 

14.sql

行转列：sum(if())
if(test,yesValue,noValue):第一个是boolean表达式，后两个类似于三目表达式，true的结果和false的结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aL6Il6mJ-1630591122414)(en-resource://database/1223:1)]
行转列思路：新表的每一个列是原来表，每一行对应分类的统计值

select id,sum(if(fenlei='分类1',1,0)) fenlei1, sum(if(fenlei='分类21',1,0)) fenlei2 ,sum(if(fenlei='分类3',1,0)) fenlei3 ,time into newTablefrom oldTable

所以原题
select sno,sum(if(class=‘英语’,score,0)) ‘英语’,sum(if(class=‘数学’,score,0)) ‘数学’ from sc where class in (‘英语’,‘数学’) group by sno
where筛选减少搜索的记录数

15.sql

alter表的结构
modify只可以修改字段的类型
change可以修改字段的名称、类型
alter 字段 set用来修改默认值
rename修改表名
drop 删除字段
add 添加字段

16.sql

需要按用户id分组，不然就是整个表产品购买次数至少一次的结果

17.sql

声明变量时 可以直接 @变量名 类型 也可以 @变量名 as 类型

18.sql

having子句即可包含聚合函数作用的字段也可包括普通的标量字段，事实上所有的where子句都可以用having代替

HAVING子句中能够使用三种要素：常数，聚合函数，GROUP BY子句中指定的列名(聚合键)

19.sql

区别是DF的聚合函数的字段，都可能是null值。这样计算时就会忽略null值的记录
但是ABCE的聚合函数，要么不会取null(count(1),count(星号))，要么是非null的字段(sno,id)，所以会忽略一部分记录。

20.行测

1^2+1=2

2^2-1=3

3^2+1=10

4^2-1=15

5^2+1+26

6^2-1=35

21.行测

0！=1
1！=1
2！=2
3！=6
4！=24

22.行测

（5-3）（6-3）=6
（6-3）（6-3）=9
（6-3）（9-3）=18
（9-3）（18-3）=90

23.行测

20/9=20/9
4/3=24/18,
7/9=28/36,
4/9=32/72,
1/4=36/144,
40/288=5/36

24.行测

25.行测

给出8个数字的话，此时数字比较多
分奇偶项讨论
奇数项：18 12 9 x
18-12 =6
12-9 =3
9 - x = 0
x = 9

26.java

this调用语句不是构造函数第一个可执行语句，而是this()构造方法

27.java

A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、 Future：接口，表示异步计算的结果；
D、 CountDownLatch： 类，可以用来在一个线程中等待多个线程完成任务的类。

28.java

catch error：error是严重错误，不需要catch处理
runtimeException：不需要catch处理，运行时自动会抛出

29.java

List不是泛型接口，其中的元素都会转化为Object类对象。
instanceof的实现

boolean rs;
if (obj == null) {
  rs= false;
} else {
  try {
      T temp = (T) obj; 
      rs= true;
  } catch (ClassCastException e) {
      rs = false;
  }
}
return rs;

因为取到的元素本身就是int自动装箱变成的Integer类型，所以不会发生转换错误，都返回true

30.java

Byte是包装类型，初始值不是0而是null。

31.java

局部变量不是在方法执行时创建的，因为局部变量必须赋初值，所以局部变量是在声明初始化的时候被创建的。

32.java

String是不可变的。String类被final修饰，String底层的实现数组也被final修饰，所以String指向的引用地址不能改变，每个字符也不能改变。
StringBuffer类被final修饰。但是StringBuffer底层实现的char数组不是final修饰的，所以StringBuffer对象是可变的。
StringBuilder也是final类。

33.java

Double d = 100; 100默认是int类型，100.0默认是double类型。但自动装箱只能在对应的数据类型之间发生，不然就会报错。

以int类型为例，
装箱：
int a = 10;
Integer i = new Integer(a);
自动装箱：Integer提供了[-128,127]的自动装箱，这个范围的数字可以自动调用new Integer();或Integer.valueOf();，是由缓存池实现的。
Integer i = 10;
拆箱：
int b = i.intValue();
自动拆箱：缓存池范围的数字可以自动拆箱
int b = i;

自动装箱规则: Double Integer Long Float只接受自己基础类型的数据
Double d = 100;100默认为int类型

21/9/3

1.java

OOP是object abstraction AOP是concern abstraction
OOP是对对象的抽象，而AOP是对公共行为的抽象，即关注点抽象
OOP 负责核心业务，AOP负责处理一些逻辑相同的横向业务。所以AOP不能取代OOP

2.java

反射破坏了封装的特性，可以直接调用私有方法和访问私有属性
mock是在测试中，用于替代测试对象的伪对象。mock对象底层是通过反射机制创建的。

3.java

JAVA 子类重写继承的方法时,不可以降低方法的访问权限，也不能抛出比父类方法更多的异常。
接口方法是public abstract，所以实现接口的方法也是public修饰

4.java

1、创建泛型对象的时候，一定要指出类型变量T的具体类型。争取让编译器检查出错误，而不是留给JVM运行的时候抛出类不匹配的异常。
泛型代码与JVM ① 虚拟机中没有泛型，只有普通类和方法。 ② 在编译阶段，所有泛型类的类型参数都会被Object或者它们的限定边界来替换。(类型擦除) ③ 在继承泛型类型的时候，桥方法的合成是为了避免类型变量擦除所带来的多态灾难。
桥方法是为了在泛型擦除后，对象变为Object类型，系统自动生成桥方法进行强制类型转换，避免了冲突。

5.java

内存泄漏：分配的对象内存没有释放。内存泄漏到一定程度，就会使可用的内存不足，就会抛出OutOfMemoryError。
java是自动管理内存的，通常下运行到稳定状态，内存大小也会稳定在一个值，除非发生内存泄漏。

A答案：FullGC 是老年代内存空间不足的时候，才会触发的，老年代一般是生命周期较长的对象或者大对象，频繁的 FullGC 可能会影响程序性能（因为内存回收需要消耗CPU等资源），但是并不会直接导致内存泄漏。

B 答案：JVM奔溃的可能是内存溢出引起的，也可能是其他导致 JVM崩溃的操作，例如设置了错误的JVM参数等。

6.java

由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器
匿名内部类可以用于形参

public void A(B b,new C(){
public int dd(){
return 1;}})

7.java

两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
故，x==f1[0]中，x将会转换为float类型。

8.java

java类加载的5个过程：
加载、验证、准备、解析、初始化
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rn1zTg4k-1630641014771)(en-resource://database/1228:1)]
加载：将.class字节码文件加载到jvm，存储到方法区
即通过类的全限定类名，来获取定义此类的二进制字节流。把字节流的静态存储结构转化为方法区的运行时数据结构，然后在内存中生成一个代表这个类的java.lang.Class对象，作为方法区该类的各种数据的访问入口
特例：数组类不通过类加载器，而是通过jvm创建

验证：确保加载进来的class文件包含的信息符合jvm的要求
验证分为4部分：文件格式 元数据 字节码 符号引用

准备：为类变量分配内存（在方法区中），设置类变量的初始值（0、false、null），为final变量赋初值

符号引用：不知道类的实际地址，用一个符号替代它的引用

解析：将常量池中的符号引用转换为直接引用
解析的对象包括：类和接口、类方法、接口私有方法、方法类型、方法句柄、字段（不包括实例变量）

初始化：初始化类变量和静态语句块
生成类构造器方法，执行方法，作用是合并所有类变量和静态语句块
子类方法执行前，父类方法一定会执行
所以jvm第一个执行的方法一定是Object的类构造函数
接口与类不同 ，执行子接口的()不需要执行父接口的()

Java语言系统自带有三个类加载器:
Bootstrap ClassLoader最顶层的加载类，主要加载核心类库，%JRE_HOME%lib下的rt.jarresources.jar、charsets.jar和class等。

Extention ClassLoader扩展的类加载器。

Appclass Loader也称为SystemAppClass 加载当前应用的classpath的所有类。
加载顺序：Bootstrap Extention System
Appclass的父类加载器是Extention Extention没有父类加载器

B.类（接口）相同的条件：全限定名相同 + 使用相同类加载器加载

C.类加载器要保证线程安全
D、装载一个不存在的类的时候，因为采用的双亲加载模式，所以强制加载会直接报错，D错误
java.lang.SecurityException: Prohibited package name: java.lang

E、双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，默认是父加载

F、自定义类加载器实现 继承ClassLoader后重写了findClass方法加载指定路径上的class

9.java

ThreadLocal类用于创建一个线程本地变量在Thread中有一个成员变量ThreadLocals，该变量的类型是ThreadLocalMap,也就是一个Map，它的键是threadLocal，值为就是变量的副本。通过ThreadLocal的get()方法可以获取该线程变量的本地副本，在get方法之前要先set,否则就要重写initialValue()方法。

ThreadLocal的使用场景：
数据库连接：在多线程中，如果使用懒汉式的单例模式创建Connection对象，由于该对象是共享的，那么必须要使用同步方法保证线程安全，这样当一个线程在连接数据库时，那么另外一个线程只能等待。这样就造成性能降低。如果改为哪里要连接数据库就来进行连接，那么就会频繁的对数据库进行连接，性能还是不高。这时使用ThreadLocal就可以既可以保证线程安全又可以让性能不会太低。但是ThreadLocal的缺点时占用了较多的空间。

10.java

java中int和boolean使用比较，会报错，显示无法比较
但是其他基本数据类型（除boolean）在比较的时候，因为是二元运算符，所以会自动进行数据类型转换（转换为较大的一种），所以都是可以比较的。

11.java

线程隔离区：虚拟机栈、程序计数器、本地方法栈
线程共享区：堆、方法区

12.java

只要编码的字符集一致，都会转化为对应的Unicode编码，所以能通过

13.java

frame

14.java

因为（1）处的方法带返回类型，所以它只是一个和类重名的普通方法。该类没有显式写构造方法，所以有隐含无参构造方法。但是没有有参构造方法，所以（3）编译报错

15.java

static String str0="0123456789";//常量池
static String str1="0123456789";//常量池
String str2=str1.substring(5);//new新对象
String str3=new String(str2);//new新对象
String str4=new String(str3.toCharArray());//new新对象;
str0=null;

所以除了常量池（PermGen），共有15个字符
垃圾回收主要针对堆区回收。栈区的内存是随着线程释放的。
PermGen，永久代，就是方法区。jdk8后改为元数据区

16.java

jdk1.8对于接口的新特性：
（1）接口内可以有default方法
（2）接口内可以有static方法

17.java

readObject()没有调用反射构造函数，而是通过从一个map里读取出字段信息，通过反射调用Method，最终创建出一个对象

18.java

C错 int a =1;并不指向堆中，它只有值，没有引用地址，Integer b =new Integer(1);指向缓冲池1的地址
D同理

19.sql

B选项 筛选不了12月31号这一整天的
C选项 >= 1.1
D选项 or

20.sql

D选项 对于右边有冗余信息的连接查询，进行了where筛选，得到的也是等值连接的结果

21.sql

having和where的区别在于筛选的对象
一般情况下，having都和group by连用

22.java

执行顺序：
（1）父类静态变量、静态代码块顺序执行
（2）子类静态变量、静态代码块顺序执行
（3）父类成员变量、代码块顺序执行
（4）父类构造函数执行
（5）子类成员变量、代码块顺序执行
（6）子类构造函数执行

23.java

基本数据类型没有方法，wrapper类型有静态方法
toHexString()等
long和double都是8个byte

24.java

规则类似于，静态内部类是外部类的一个静态成员，所以不需要外部类的实例创建。
注意非静态成员内部类里面也是new

25.java

26.java

C选项synchronized修饰两个方法，线程同步
A选项没有成员变量，不涉及并发
D？

27.java

系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展 。正确
系统应该稳定 指的是规范应该稳定不可修改，但可以修改实现方式

28.java

常见的代码优化技术有：复写传播，删除死代码, 强度削弱，归纳变量删除
复写传播：尽量用f = g 用g替代f
复写传播可以进行常量优化、死代码删除（删除不会引用的部分）

代码外提：优化循环
结果不变的语句/表达式提到循环外面，只执行一次

归纳变量删除：优化循环
用于归纳（替代已有另一个变量）的变量删除

强度削弱：优化循环
强度削弱的本质是把强度大的运算换算成强度小的运算，例如将乘法换成加法运算。

21/9/4

1.java

在编译期，字符串字面量的拼接(+)就已经优化完成，不管多少个字面量拼接，都产生一个字符串对象

2.java

B,C语言当中是这样，java不是， String内部是用char[]数组实现的，不过结尾不用\0。
D:char类型存储的是unicode，可以存储字符包括汉字

3.java

构造方法不能被子类继承，所以用final修饰没有意义。构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。此外，Java语言不支持native或synchronized的构造方法。

4.java

不仅反射可以调用，在构造方法的第一行使用this()和super()也可以调用

5.java

持久带中主要存放用于存放静态类型数据，如 Java Class, Method 等， 与垃圾收集器要收集的Java对象关系不大。
所以持久带内存溢出，原因是类信息太多。

年老代溢出原因有 循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存，既A B D选项，原因是对象数据太多

6.java

A选项中，ConcurrentHashMap 使用segment来分段和管理锁，segment继承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock来保证线程安全。

7.java

D. Java程序的类加载器采用双亲委派模型，实现双亲委派的代码集中在java.lang.ClassLoader的loadClass()方法中，此方法实现的大致逻辑是：先检查是否已经被加载，若没有加载则调用父类加载器的loadClass()方法，若父类加载器为空则默认使用启动类加载器作为父类加载器。如果父类加载失败，抛出ClassNotFoundException异常。D错误

8.java

java的关键字（保留字），除了一些常用的关键字，还包括基本数据类型。但不包括所有的引用类型的类名，比如String，Object

9.java

抽象方法也不能用final修饰，因为它一定会被重写。

10.java

编译看左边，运行看右边。编译时左边的Animal类型没有bark()，所以会报编译错误。

11.java

String对象的replace()和replaceAll()方法，第一个参数都是正则表达式

12.java

在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解，子类对象确实拥有父类对象中所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。就像有些东西你可能拥有，但是你并不能使用。所以子类对象是绝对大于父类对象的，所谓的子类对象只能继承父类非私有的属性及方法的说法是错误的。可以继承，只是无法访问到而已。

通过反射也可以看到子类拥有全部成员，但是不能直接调用。

13.java

A也对

14.java

LinkedBlockingQueue:
LinkedBlockingQueue不同于ArrayBlockingQueue，它如果不指定容量，默认为Integer.MAX_VALUE，也就是无界队列。

LinkedBlockingQueue不允许null值

LinkedBlockingQueue是一个阻塞队列，内部由两个ReentrantLock来实现出入队列的线程安全，由各自的Condition对象的await和signal来实现等待和唤醒功能

PriorityQueue:

PriorityQueue是非线程安全的，所以Java提供了PriorityBlockingQueue（实现BlockingQueue接口）用于Java多线程环境。

优先队列不允许空值，而且不支持non-comparable（不可比较）的对象

优先队列的大小是不受限制的

D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的线程安全队列，该队列的元素遵循FIFO原则。

15.java

字符界面就是类似命令行界面，字符流的输入输出都是在io包中实现的。
Scanner是java.util包中的

16.java

编码格式由浏览器决定，浏览器根据html中指定的编码格式进行编码，tomcat根据指定的格式进行解码

17.java

封装、继承、多态是面向对象语言的特性
gc的时间是不确定的

18.java

方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放

19.java

枚举类有三个对象，因此会实例化三次，调用三次构造函数

20.java

计算（i++）后，括号里变成了字面量，++不能对非变量进行运算

21.java

关于此题，《深入理解java虚拟机》有关于OOM（OutOfMemory）问题的解释
A：属于运行时常量池导致的溢出，设置-XX：MaxPermSize可以解决这个问题，
B：属于堆空间不足导致的错误，问题比较少见，解决方式和C相同，
C：属于java堆内存问题，一般的手段是通过内存映像分析工具，对Dump出来的堆转储存快照进行分析，重点是确认内存中的对象是否是有必要的，也就是要判断是出现了内存泄漏，还是出现了内存溢出，如果是内存列楼，通过工具检查泄露对象打GC Roots的引用链信息，可以准确的确定出泄露代码的位置，不存在泄露，就应该检查虚拟机的堆参数，如果可以继续调大，可以设置-Xmx解决问题
D：java.lang.OutOfMemoryError: nativeGetNewTLA指当虚拟机不能分配新的线程本地空间(Thread Local Area）的时候错误信息，此错误是线程申请一个新的TLA时产生的，这个异常一般只会发生在jRockit虚拟机，只有过于绝对。

22.java

A.Class类在java.lang包下
B.通过动态代理可以实现接口，动态代理的底层是反射
C.正确
D.反射不会修建一个类，但是字节码动态修剪可以(cglib)
E.反射会创建额外对象，比类中内容（存储在永久代）多
F.反射的效率低，调用getMethod()会先检查方法权限（可见性），然后得到方法，再拷贝一份返回。
反射需要JVM的动态链接机制动态的进行解析和匹配（即告诉JVM该如何去找这个类），而直接调用则不必

23.java

A a = new A();
B b = new B();
a.set(b);//创建对b对象地址的引用
b = null;//b删除引用，但b对象还被a.ref引用着
a = null;//a也删除引用，此时没有引用指向创建的b和a对象

a和b之间存在着循环引用，但是Jvm采用hotspot实现，对于gc的实现采用引用计数法，即只关注地址的引用数量，不关注引用之间的关系。

24.java

25.java

A is assignable to B 表示A是B的子类
只看<>中的类 ：
（1）如果都是一个类 看有无继承关系 （一个类是本类的子类）
（2）如果是范围 小范围是大范围的子类 子类也是大范围的子类
（3）List等价于List<?>

26.java

对象类型都可以直接赋值给Object。
八大基础类型会自动装箱后赋值给Object。所以对

27.java

远程方法调用 RemoteMethodInvoke 使用通信协议为TCP/IP

28.java

Iterator 支持从源集合中安全地删除对象，只需调用 Iterator.remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。
它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态

29.java

两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

30.java

LinkedList实现List接口
AbstractSet实现Set接口
HashSet继承AbstractSet类
WeakMap（java没有）

31.java

不可能发生的有：初始->(就绪)->运行
阻塞->(就绪)->运行

32.java

除封装类以外，String，StringBuilder，StringBuffer，Math也是final修饰的类

33.java

java中只有boolean类可以在if条件中使用=赋值，其他int等基本类型使用=都是赋值，变量不是boolean类型，所以会编译错误。所以答案为true

34.java

dead状态的线程还能被恢复，所以不会被gc回收

35.java

将a的操作转化为原子的读/写操作

36.java

D正确

37.java

Minor GC触发机制：
　　当年轻代满时就会触发Minor GC，这里的年轻代满指的是Eden代满，通过复制算法 ,回收垃圾。复制算法不会产生内存碎片。.

Major GC的触发机制：

Major GC又称为Full GC。当年老代空间不够用的时候，虚拟机会使用“标记—清除”或者“标记—整理”算法清理出连续的内存空间，分配对象使用。
Full GC触发机制：
　　（1）调用System.gc时，系统建议执行Full GC，但是不必然执行
　　（2）老年代空间不足
　　（3）方法区空间不足
　　（4）通过Minor GC后进入老年代的平均大小大于老年代的可用内存
　　（5）由Eden区、survivor space1（From Space）区向survivor space2（To Space）区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小
　　　　当永久代满时也会引发Full GC，会导致Class、Method元信息的卸载。

21/9/5

1.java

管道是半双工的，同一时间只能有一方发送消息，服务器的通信之间要求是全双工的。

2.java

关于抽象类
JDK 1.8以前，抽象类的方法默认访问权限为protected
JDK 1.8时，抽象类的方法默认访问权限变为default

关于接口
JDK 1.8以前，接口中的方法必须是public的
JDK 1.8时，接口中的方法可以是public的，也可以是default的（不需要有方法主体）
JDK 1.9时，接口中的方法可以是private的（但要有方法主体）

3.java

A只获取了连接，没有加载驱动

4.java

Date()的getClass是继承自Object且没有重写，所以调用的是Object对象里的getClass()方法。getName()返回全类名
package test;
所以是test.SuperTest

5.java

三元操作符的两个结果：
（1）如果不能互相转换，则返回Object类型
（2）如果是明确的表达式/变量，按范围较大的转换
（3）如果是数字+表达式，按范围较大的转换
（4）如果都是数字，按范围较大的来

所以o1是 new Double(1.0);

6.java

C？可以构建对象调用实例方法

7.java

B 可以是不同的格式，可以设置页面请求/响应内容格式，也可以String newUTF8Str = new String(oldGBKStr.getBytes(“GBK”), “UTF8”);
C java的char编码格式通常是UTF-16
D resourcebundle类就是用来处理国际化和本地化的问题

8.java

分为15位身份证号和18位身份证号
15位身份证的构成：六位出生地区码+六位出身日期码+三位顺序码
18位身份证的构成：六位出生地区码+八位出生日期码+三位顺序码+一位校验码

9.java

新生代一般是复制回收，老年代、G1、CMS都是标记回收

10.java

虽然f是private变量，但是main方法也在本类中，所以可以访问到

11.java

doGet/doPost 则是在 javax.servlet.http.HttpServlet 中实现的

12.java

13.java

A不是区别0.0

21/9/6

1.java

A 选项是flash属性，不是jsp指令的属性
B 需要将静态页面加载进来，才能在同一个页面输出pageContext域的信息
C 请求转发 不能保留pageContext域的数据
D 重定向 不能保留pageContext域的数据

2.java

ThreadLocal
ThreadLocal是java实现线程局部存储的一种方式
ThreadLocal是线程隔离的，用于数据隔离 synchronized用于数据共享
解决多线程中的对同一变量的访问冲突的一种技术;
ThreadLocal空间换时间
单例式创建Connection对象，因为connection是共享的，另外一个线程只能等待。使用ThreadLocal对象进行分割操作。

3.java

B 可以是不同的格式，可以设置页面请求/响应内容格式，也可以String newUTF8Str = new String(oldGBKStr.getBytes(“GBK”), “UTF8”);
C java的char编码格式通常是UTF-16
D resourcebundle类就是用来处理国际化和本地化的问题

4.java

java中有几个类/接口（内部、匿名），就会生成几个类
内部类会在外部类名后面加上 $和内部类名，匿名类的类名是数字

5.java

B 接口没有继承Object类， 因为接口不能有实现的方法，而Object继承会有

C Object默认实现equals()会使用==判断，而==直接判断地址相等

6.java

7.java

D错在可能是私有访问修饰符，不能使用类名.访问

8.java

jdk1.5以上引入自动装箱/自动拆箱
封装类型和基本数据类型在==比较时会自动调用xxxValue()转换为基本数据类型进行比较

9.java

使用final修饰的类型不会自动提升
其他选项进行运算的变量，都有一个不是final修饰的

10.java

48个关键字，2个保留字(goto,const），3个特殊直接量:true,false,null
sizeof是c的关键字，java可以使用它作为标识符进行命名

11.java

流程：使用Filter拦截请求，将普通请求转化为包装过的可以处理XSS的自定义请求，之后获取参数时都会经过XSS处理。
可以解决表单提交时XSS攻击和转义的问题

12.java

序列化只会保存对象的状态。
Java在序列化时不会实例化static变量和transient修饰的变量，因为static代表类的成员，transient代表对象的临时数据，被声明这两种类型的数据成员不能被序列化。

13.java

  public static int parseInt(String s, int radix)
                throws NumberFormatException
    {} //相当于拆箱
    
     public int intValue() {
        return value;
    }//相当于拆箱
    
 public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }//相当于装箱

14.java

-xms x是执行的意思 ms memory size for pile and heap，默认内存大小，也就是最小内存大小
-xmx 后一个x是max 最大内存大小
-xmn 年轻代大小
-xss 堆栈大小
-xx 非稳定参数，可能被删除
-xx:NewRatio =4设置年轻代：老年代=4:1
-xx:SurvivorRatio =4 设置年轻代中Eden：Survivor = 4:(1+1) 默认是8 即8/10 :1/10:1/10
-XX:MaxPermSize=16m 设置持久代最大为16m
-XX:MaxTenuringThreshold=0：设置垃圾最大年龄，如果为0年轻代对象不经过survivor去直接进入老年代

最小堆大小10240，年轻代大小5120，eden：survivor = 3:2 survirvor = 5120*0.4=2048m

15.java

HashTable 和 ConcurrentHashMap 都是线程安全的。区别在于他们对加锁的范围不同，HashTable 对整张Hash表进行加锁，而ConcurrentHashMap将Hash表分为16桶(segment)，每次只对需要的桶进行加锁。

Collections 类提供了synchronizedXxx()方法，可以将指定的集合包装成线程同步的集合。比如，
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());

16.java

48个关键字，2个保留字(goto const)，3个字面量（true false null）
sizeof是c的关键字，不是java的，可以作为java标识符

17.java

18.java

java对于字符串的编译优化：
如果是常量相加，编译器会直接优化为常量的结果，因为常量不会变。如果被final修饰也是同样的效果。
如果是值为常量的字符串相加，编译器不会进行优化，因为变量的值可能会变。最终还是new StringBuilder().append()进行，返回对象。

19.java

计算余弦值使用Math类的cos()方法
toRadians()是将角度转换为弧度
toDegrees()是将弧度转换为角度
42是角度 弧度是0.00形式的小数

20.java

接口的变量默认是public static final类型

21.java

超类、子类的实例方法可能是被私有修饰符修饰，只有本类的方法才是一定可以被直接访问的

22.java

表之间的参考关系不能提现到类的关系中

23.java

run()方法结束表示线程的任务完成，线程会销毁。（遇到异常也会销毁）
start()的作用就是让线程转为就绪状态

24.java

如果split()没有匹配任何字符，返回的数组 长度为1，元素为原字符串。

25.java

java.lang.Object 类的 wait 方法

java.lang.Thread 类的 sleep 方法

java.lang.Thread 类的 join 方法
CyclicBarrier的await的方法也会抛出中断异常

26.java

0.0 如果是变量的内容，可以被重写 如果指的是final修饰的方法，不能被重写

27.java

没有说题目是java，所以指针是一个宽泛的概念
D错？

28.java

内部类可以被public修饰，可以在任何访问修饰符修饰的类中定义public类，也可以定义任意多个。

29.java

30.java

java是跨平台的，所以java中的包和操作系统没有任何关系，java的包是用来组织文件的一种虚拟文件系统

31.java

final常量c也是局部变量，因此定义在栈中（方法栈）
如果是类中定义的常量，会存放在方法区（静态存储区）中。

32.java

ABCD都对
D 比如Method.invoke(this)操作的就是对象，或者获取对象的Field然后get()

33.java

Java体系结构包括四个独立但相关的技术：

• Java程序设计语言
• Java.class文件格式
• Java应用编程接口（API）
• Java虚拟机

34.java

hashcode不等，一定不equals
equals相等，hashcode一定相等
hashmap里不会有相同的hashcode作为key
C 可以相同

35.java

A
| |
B C
|
D
所以是3

36.java

Spring只提供了AOP，需要自己用AOP切面编程和log4j编写日志切面

37.java

属于jvm内存规范的只有：

38.java

else if 可以随意写，编译也会通过

39.java

String.format(String,Object…agrs){}
当String中有%s 时 表示后面的对象可以填充到字符串中
如果要使用顺序 $1 $2
还考了方法的重载
语句1的参数符合Object类型 输出Welcome tommy
语句2的参数更符合String类型 输出Hello tommy

40.数据结构

回溯法可以回退
分支限界法，活结点只有一次成为拓展结点的方法

41.数据结构

算法的基本要素有：对数据对象的运算和操作 以及 算法的控制结构

42.Linux

Linux命令行中：ctrl+z是挂起进程 ctrl+c是终止进程 ctrl+d是eof ctrl+l清屏 ctrl+s 中断控制台输出 ctrl+q 恢复控制台输出

43.设计模式

44.Linux

c是重定向输出 会输出到/test中 所以会创建文件

45.Linux

#开头，c错
AB都能用

46.Redis

Redis支持的数据类型：String List hash set和zset

47.Redis

Redis Cluster在设计中没有使用一致性哈希(Consistency Hashing),而是使用数据分片引入哈希槽(hash slot)来实现

如果每次访问一个缓存项都需要遍历所有缓存服务器的所有缓存项，想想就觉得很累，那么，我们该怎么办呢？原始的做法是对缓存项的键进行哈希，将hash后的结果对缓存服务器的数量进行取模操作，通过取模后的结果，决定缓存项将会缓存在哪一台服务器上

48.java

–优先级高于-，所以是c = a-b,a–
c = 50 a = 99
d = 49 a = 98

49.java

CountDownLatch：一个或者多个线程，等待其他多个线程完成某件事情之后才能执行；
CyclicBarrier：多个线程互相等待，直到到达同一个同步点，再继续一起执行。

50.java

多线程访问volatile不会阻塞，synchronized会阻塞

51.java

<aop:aspectj-autoproxy proxy-target-class=“true”/>
使用aop自动代理

21/9/7

1.java

局部变量不能用static修饰

2.java

字符流等于字节流加字符集

创建 InputStreamReader(InputStream in, Charset cs)

3.java

存根类是一个类，它实现了一个接口，它的作用是：如果一个接口有很多方法，如果要实现这个接口，就要实现所有的方法。但是一个类从业务来说，可能只需要其中一两个方法。如果直接去实现这个接口，除了实现所需的方法，还要实现其他所有的无关方法。而如果通过继承存根类就实现接口，就免去了这种麻烦。

stub 充当远程对象的客户端，有着和远程对象相同的远程接口，远程对象的调用实际是通过调用该对象的客户端对象stub来完成的。

每个远程对象都包含一个对象stub，当运行在本地Java虚拟机上的程序调用运行在远程Java虚拟机上的对象方法时，它首先在本地创建该对象的stub, 然后调用对象上匹配的方法。每一个远程对象同时也包含一个skeleton对象，skeleton运行在远程对象所在的虚拟机上，接受来自stub对象的调用。这种方式符合等到程序要运行时将目标文件动态进行链接的思想
动态链接（动态连接使得大部分的连接过程延迟,直到程序开始运行）

4.java

静态分派：非虚方法在编译期确定

在Java语言中符合“编译期可知，运行期不可变”这个要求的方法，主要包括静态方法和私有方法两大类，前者与类型直接关联，后者在外部不可被访问，这两种方法各自的特点决定了他们不可能通过继承或别的方式重写其他版本，因此他们适合在类加载阶段进行解析。

静态方法、私有方法、实例构造器、父类方法。这些方法称为非虚方法，它们在类加载的时候就会把符号引用解析为该方法的直接引用。与之相反，其他方法称为虚方法（除去final方法）。

动态分派：虚方法在运行时确定

所以最终输出的是静态方法，非虚方法，是父类的getType(Collection) 编译期确定了方法，参数也是编译期确定的
Collection col = new HashSet(); 静态类型Collection是编译期确定的

5.java

考察运算符的优先顺序。
++优先级大于/=

6.java

桥接模式:抽象和实现分开
jdbc的各种实现（mysql、oracle）等，实现和接口的规范分开，切换数据库不需要改动太多。

7.java

nativeGetNewTLA：线程申请新的TLA时发生的
这个错误经常是发生JRockit的JVM上的，如果都用hotspot或者J9的JVM可能不会遇到这个问题。

8.java

A.子进程得到的是除了代码段是与父进程共享以外，其他所有的都是得到父进程的一个副本，子进程的所有资源都继承父进程，得到父进程资源的副本，子进程可获得父进程的所有堆和栈的数据，但二者并不共享地址空间。两个是单独的进程，继承了以后二者就没有什么关联了，子进程单独运行；进程的线程之间共享由进程获得的资源，但线程拥有属于自己的一小部分资源，就是栈空间，保存其运行状态和局部自动变量的。

9.sql

mysql数据库，game_order表表结构如下，下面哪些sql能使用到索引（）？

这道题目想考察的知识点是MySQL组合索引（复合索引）的最左优先原则。最左优先就是说组合索引的第一个字段必须出现在查询组句中，这个索引才会被用到。只要组合索引最左边第一个字段出现在Where中，那么不管后面的字段出现与否或者出现顺序如何，MySQL引擎都会自动调用索引来优化查询效率。

10.java

+=会自动强转（自动装箱）

11.java

A,D是正确的；创建Statement是不传参的，PreparedStatement是需要传入sql语句

12.java

针对一消息，不同的对象可以以适合自身的方式加以响应

13.java

deprecation： to suppress warnings relative to deprecation
强制转换：unchecked ： to suppress warnings relative to unchecked operations

14.java

flush（）函数强制将缓冲区中的字符流、字节流等输出，目的是如果输出流输出到缓冲区完成后，缓冲区并没有填满，那么缓冲区将会一直等待被填满。所以在关闭输出流之前要调用flush（）。

15.java

公式-n=_n+1可推出n=-n-1，所以~10=-11再加5结果为-6

16.java

static方法中没有this

17.java

所谓的释放锁资源实际是通知对象内置的monitor对象进行释放
也就是通过wait()来通知对象内置的monitor对象释放
而join()有资格释放资源其实是通过调用wait()来实现的

18.java

B char类型运算会自动转为int类型
C 常量不能赋值
D char类型运算会自动转为int类型

19.java

一个文件中的数据要在控制台显示，首先需要获取文件中的内容，使用FileInputStream fin = new FileInputStream(this.filename);

20.java

无效等价类和有效等价类相反，即不满足程序输入要求或者无效的输入数据构成的集合。
无效等价类即所有不符合的数据集合

21.java

父类引用指向子类对象，无法使用子类中的独有方法，编译器会认为父类对象没有该方法进行报错

22.java

javac -d的作用是指定编译生成文件的目录

23.java

B.File类是对文件整体或者文件属性操作的类，例如创建文件、删除文件、查看文件是否存在等功能，不能操作文件内容；文件内容是用IO流操作的。

C 文本文件/二进制文件正常读到结尾时会返回一个-1，不会抛出eofexception
当ObjectInputStream在不知道读取对象数量的情况下，确实无法判断是否读完，除非你把之前写入对象流的数量记录下来。所以说出现这个异常时就认真分析一下，这个异常是不是代表一个信息。

A 例如Ascii、Unicode等，window中文本文件的后缀名有".txt",".log",各种编程语言的源码文件等；二进制文件就是用文本文档打开是看不懂乱码，只要能用文本打开的文件都可以算是文本文件，只是显示的结果不是你想要的，二进制文件只有用特殊的应用才能读懂的文件，例如".png",".bmp"等，计算机中大部分的文件还是二进制文件。

24.java

实例化Sub()，会调用父类构造方法，父类构造方法调用的callName()是子类的方法，输出的baseName就近调用子类的baseName，但是此时还没有实例化Sub，因为还处于构造方法的调用过程中，还没有执行代码块，所以baseName是null。

25.java

0.0B选项可能说的是字面量，字面量是一个常量

26.java

1.8之前接口没有普通方法

27.java

开头有导包，import EnclosingOne.InsideOne ，可以省略外部类名

成员内部类：
外部类名.内部类名 obj = new 外部类名().new 内部类名()
不能用对象名声明内部类

21/9/8

1.java

在JAVA IO中所有的数据都是采用顺序的读取方式，即对于一个输入流来讲都是采用从头到尾的顺序读取的，如果在输入流中某个不需要的内容被读取进来，则只能通过程序将这些不需要的内容处理掉，为了解决这样的处理问题，在JAVA中提供了一种回退输入流（PushbackInputStream、PushbackReader），可以把读取进来的某些数据重新回退到输入流的缓冲区之中。

2.java

java.net提供了tcp的socket编程，也提供了udp的dataGramSocket和DataGramPacket,所以是支持IP协议以上的高层协议

3.java

即Interrupted exception

4.java

Reader的直接继承类，具体的有：BufferedReader, CharArrayReader, FileReader, InputStreamReader, PipedReader, StringReader等

5.java

A选项 y也是变量可能改变，需要加锁

6.java

泛型只在编译的时候保证数据类型的正确性，和运行期间的性能无关

7.java

this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块(里面不能使用非static类型的)。

8.java

goto和const是保留字也是关键字。
1，Java 关键字列表 (依字母排序 共50组)：
abstract, assert, boolean, break, byte, case, catch, char, class, const（保留关键字）, continue, default, do, double, else, enum, extends, final, finally, float, for, goto（保留关键字）, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while
2，保留字列表 (依字母排序 共14组)，Java保留字是指现有Java版本尚未使用，但以后版本可能会作为关键字使用：
byValue, cast, false, future, generic, inner, operator, outer, rest, true, var, goto （保留关键字） , const （保留关键字） , null

9.java

字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同
例FileInputStream 的read() 方法每次读入一个字节，read(byte b[]) 每次读入b.length个字节
FileReader 的read()方法每次读入一个字符，read(char cbuf[], int offset, int length)每次读入length个字符
另外，字符流和字节流读入一个ASCII字符，字节数是相同的
例UTF-8字符编码中一个汉字占三个字节，数字1占一个字节，用字符流读入的数字1长度为一个字节，用字节流读入的数字1长度也为一个字节

10.java

答案是A
setDaemon()方法必须在线程启动之前调用，当线程正在运行时调用会产生异常。IllegalThreadStateException
如果我们把这个线程动态更改为daemon线程,jvm会认为当前已经不存在用户线程而退出

11.java

Ant 没有生命周期，你必须定义目标和目标之间的依赖。你必须手工为每个目标附上一个任务序列。
Ant特点

• 没有一个约定的目录结构
• 必须明确让ant做什么，什么时候做，然后编译，打包
• 没有生命周期，必须定义目标及其实现的任务序列
• 没有集成依赖管理

Maven特点

• 拥有约定，知道你的代码在哪里，放到哪里去
• 拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程
• 只需要定义一个pom.xml,然后把源码放到默认的目录，Maven帮你处理其他事情
• 拥有依赖管理，仓库管理

12.java

要想事物具有持久性，就得在事物出错时及时恢复。
持久性:一个事务一旦提交，那么它对数据库产生的影响就是永久的不可逆的，如果后面再回滚或者出异常，都不会影响已提交的事务（由DBMS的恢复管理子系统实现的）

13.java

取模运算，结果的符号和被除数符号一致，结果的数值和取模后的取余运算一致

14.java

会话跟踪是一种灵活、轻便的机制，它使Web上的状态编程变为可能。
HTTP是一种无状态协议，每当用户发出请求时，服务器就会做出响应，客户端与服务器之间的联系是离散的、非连续的。当用户在同一网站的多个页面之间转换时，根本无法确定是否是同一个客户，会话跟踪技术就可以解决这个问题。当一个客户在多个页面间切换时，服务器会保存该用户的信息。
有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。

15.java

16.java

多层次的调用模式还有可能增加代码量
一般来讲，使用设计模式都会增加代码量。

17.java

volatile不能保证原子性，也就不能保证线程安全。
禁止指令重排序优化

禁止指令重排序优化。大家知道我们写的代码（尤其是多线程代码），由于编译器优化，在实际执行的时候可能与我们编写的顺序不同。编译器只保证程序执行结果与源代码相同，却不保证实际指令的顺序与源代码相同。这在单线程看起来没什么问题，然而一旦引入多线程，这种乱序就可能导致严重问题。volatile关键字就可以从语义上解决这个问题。

18.java

C（错误）：读取路径信息,request读取路径信息

从request获取各种路径总结
request.getRealPath(“url”); // 虚拟目录映射为实际目录
request.getRealPath("./"); // 网页所在的目录
request.getRealPath("…/"); // 网页所在目录的上一层目录
request.getContextPath(); // 应用的web目录的名称

19.java

20.java

21.java

D 调度算法未必是剥夺式的，而准备就绪但是还没有获得CPU，它的权限更高只能说明它获得CPU被执行的几率更大而已

22.java

ThreadLocal是数据隔离，不是数据共享

23.java

A jdk1.9 接口可以有私有方法
B 多重继承不是多继承

24.java

派生类对象构造函数指的是对象调用了其它构造函数，即对象代码块，早于派生类构造函数

25.java

常量必须赋初值

26.java

is-a:继承关系 has-a:从属关系 like-a:组合关系

27.java

web容器是一种服务程序，在服务器一个端口就有一个提供相应服务的程序，而这个程序就是处理从客户端发出的请求，如JAVA中的Tomcat容器，ASP的IIS或PWS都是这样的容器。一个服务器可以多个容器。

28.java

所有非守护进程（守护进程是后台进程，所以是所有的前台进程）执行完

29.java

C 缺省public

30.java

在java语言中，判断一块内存空间是否符合垃圾收集器收集标准的标准只有两个：
1.给对象赋值为null，以下没有调用过。
2.给对象赋了新的值，重新分配了内存空间。

节点流：

处理流：

31.java

面对对象的特性不能提高编译可靠性

32.java

用户线程（user-level threads）指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。
CMS的GC过程有6个阶段（4个并发，2个暂停其它应用程序）

1. 初次标记(STW initial mark)
2. 并发标记(Concurrent marking)
3. 并发可中断预清理(Concurrent precleaning)
4. 最终重新标记(STW remark)
5. 并发清理(Concurrent sweeping)
6. 并发重置(Concurrent reset)
   在初次标记，重新标志的时候，要求我们暂停其它应用程序，那么这两个阶段用户线程是不会参与的

33.java

USES-A：依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。
关联关系：A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。
HAS-A：聚合关系，拥有关系，是关联关系的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是聚合关系，鸟群中每个部分都是鸟。
IS-A：表示继承。父类与子类，这个就不解释了。
要注意：还有一种关系：组合关系也是关联关系的一种特例，它体现一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分的关系，但这种整体和部分是不可分割的。

34.java

A选项 服务器会直接访问目标地址的URL，不会把控制权转交
D forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.
E:302重定向又称之为暂时性转移(Temporarily Moved )，英文名称：302 redirect。
301 - 资源（网页等）被永久转移到其它URL

21/9/12

1.java

System.arraycopy>clone>Arrays.copyOf>for循环
因为System.arraycopy使用的方法是native方法，效率高于clone()的复制对象。
arrays.copyOf调用的是System.arraycopy，所以速度慢
for循环每次都要找到下标处

2.java

虚拟机规范严格规定了有且只有五种情况必须立即对类进行“初始化”：

1.  使用new关键字实例化对象的时候、读取或设置一个类的静态字段的时候，已经调用一个类的静态方法的时候。
   

2.  使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有初始化，则需要先触发其初始化。
   

3.  当初始化一个类的时候，如果发现其父类没有被初始化就会先初始化它的父类。
   

4.  当虚拟机启动的时候，用户需要指定一个要执行的主类（就是包含main()方法的那个类），虚拟机会先初始化这个类；
   

5.  使用Jdk1.7动态语言支持的时候的一些情况。
   

除了这五种之外，其他的所有引用类的方式都不会触发初始化，称为被动引用。下面是被动引用的三个例子：

1.  通过子类引用父类的的静态字段，不会导致子类初始化。
   

2.  通过数组定义来引用类，不会触发此类的初始化。
   

public class NotInitialization { 

    public static void main(String[] args) { 

        SuperClass[] sca = new SuperClass[10]; 

    }   

}

3.  常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
   

public class ConstClass { 

    static { 

        System.out.println("ConstClass init!"); 

    } 

    public static final int value = 123; 

} 

public class NotInitialization{ 

    public static void main(String[] args) { 

        int x = ConstClass.value; 

    } 

} 

上述代码运行之后，也没有输出“ConstClass init！”，这是因为虽然在Java源码中引用了ConstClass类中的常量HELLOWORLD，但其实在编译阶段通过常量传播优化，已经将此常量的值“hello world”存储到了NotInitialization类的常量池中，以后NotInitialization对常量ConstClass.HELLOWORLD的引用实际都被转化为NotInitialization类对自身常量池的引用了。也就是说，实际上NotInitialization的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译成Class之后就不存在任何联系了。

3.java

执行顺序：
1.public static B t1 = new B();
2.{
System.out.println(“构造块”);
}
3. public static B t2 = new B();
4. {
System.out.println(“构造块”);
}
5.static
{
System.out.println(“静态块”);
}
6. B t = new B();
7.{
System.out.println(“构造块”);
}
2处执行构造块是因为，jvm认为已经执行了static语句，已经对类进行了初始化，不会再次初始化，所以执行对象创建时的代码块和构造函数。

4.java c++

纯虚函数可以不包含定义

5.java

A 操作系统不是必备的，裸机不需要操作系统也可以跑

6.java

RandomAccessFile可以快速定位光标位置，进行文本的追加

7.java

对于堆外内存是指分配的对象直接受操作系统管理的JVM内存堆以外的空间。这部分区域直接受操作系统的管理，别的进程可以直接通过操作系统对其进行访问，减少了从JVM中复制数据的过程。

8.java

AB = 和- 区别0.0

9.java

volatile的操作，从load到store不是原子性的，只有内存屏障才是可见的，所以volatile不具有原子性，不具有原子性，分几步语句执行时就可能被阻塞

10.java

public interface CallableStatement extends PreparedStatement
public interface PreparedStatement extends Statement

11.java

Class类中的forName()方法返回与带有给定字符串名的类或接口相关联的Class对象（装载其他类）

12.java

protected不能修饰接口，因为有时接口被用作静态常量的引用处，需要直接引用其中的常量，不能设为只有包中引用
static不能修饰接口 可以修饰接口的方法

21/9/13

1.java

依赖注入的动机就是减少组件之间的耦合度，使开发更为简洁

2.java

C 在C++中，对象的内存在哪个时刻被回收，是可以确定的，在C++中，析构函数和资源的释放息息相关，能不能正确处理析构函数，关乎能否正确回收对象内存资源。
D 一个对象成为垃圾是没有引用指向着他，一个线程被释放是run()执行结束

3.java

Servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁。
而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于Servlet 。

CGI不可移植，为某一特定平台编写的CGI应用只能运行于这一环境中。每一个CGI应用存在于一个由客户端请求激活的进程中，并且在请求被服务后被卸载。这种模式将引起很高的内存、CPU开销，而且在同一进程中不能服务多个客户。

Servlet提供了Java应用程序的所有优势——可移植、稳健、易开发。使用Servlet Tag技术，Servlet能够生成嵌于静态HTML页面中的动态内容。Servlet对CGI的最主要优势在于一个Servlet被客户端发送的第一个请求激活，然后它将继续运行于后台，等待以后的请求。每个请求将生成一个新的线程，而不是一个完整的进程。多个客户能够在同一个进程中同时得到服务。一般来说，Servlet进程只是在Web Server卸载时被卸载。

4.java

add方法中，尽管使用的是封装类型Byte，但是b++这一操作会将其自动拆箱称为byte类型，所以值不会被修改
a因为在啊传值时就++a，所以a= 127+1 =-128

5.java

重载和返回值类型，和修饰符都没有关系

6.java

0.0 因为a和b是一个对象所以d对了

7.java

catch块发生异常，也会执行finally中的语句，再抛出异常，finally外面的语句不能再执行

8.java

servlet不是线程安全的，并发执行的情况下多个进程会修改类变量，引起问题

9.java

StringBuffer s = new StringBuffer(x); x为初始化容量长度
s.append(“Y”); "Y"表示长度为y的字符串

s.length()是append() 的长度
s.capacity() == y<x?x:(y<2x+2?2x+2:y);

10.java

C : ReentrantLock使用lock和unlock

11.java

12.java

A 获得不了权限不足对象的锁定
D 线程调度算法是平台独立的，每个操作系统的时间片大小可能不同

13.java

B java String操作字符编码的方法是getBytes()和new String()中添加字符集名称，先创建了一个GBK编码的字符串，又用UTF-8方法获得字节。
D encode和decode是js的方法 String没有encode和decode方法

14.java

A 加载过程中会根据全限定类名 生成一个java.lang.Class对象
B 对象成员变量是在创建对象的时候创建的 不在类加载的过程中
C 初始化过程中会调用static构造块
D 类解析过程中会解析方法

15.java

（一）懒汉式（线程不安全）
实现：
public class Singleton {
     private static Singleton uniqueInstance;

     private Singleton() {

    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

（二）饿汉式（线程安全）
实现：

public class Singleton {

    private static Singleton uniqueInstance = new Singleton();

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        return uniqueInstance;
    }

}

（三）懒汉式（线程安全）
实现：

public class Singleton {
    private static Singleton uniqueInstance;

    private static singleton() {
    }

    private static synchronized Singleton getUinqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }

}

（四）双重检查锁实现（线程安全）
实现：

public class Singleton {

    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }  
}

（五）静态内部类实现（线程安全）
实现：

public class Singleton {

    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }

}

（六）枚举类实现（线程安全）
实现：

public enum Singleton {

    INSTANCE;

    //添加自己需要的操作
    public void doSomeThing() {

    }

}

21/9/14

1.java

子类方法是否能够访问父类中的public成员。答案是可以

2.java

下载OpenJDK的源码，可以看到java,javac这些命令都是用java写的，可以导入eclipse单独运行。

3.java

两个封装类的= =比较时不会自动拆箱
一个封装类和基本数据类型的= =比较会将封装类自动拆箱
两个Integer的= =比较，如果在-128，127之间，会使用缓存判断
两个封装类的equals比较会先比较类型，在比较值
一个封装类equals()一个基本类型，基本类型会先自动装箱，再判断类型，再判断值

4.java

nb = lx; nb指向lx当前的引用"LeXin";
lx=“Fenqile”;lx指向fenqi，nb指向lexin，分别指向不同的引用

5.java

抽象类有构造函数，接口没有，抽象类和接口都不能实例化（声明使用）
抽象类和接口不能实例化的原因：抽象类和接口里可能有不完整的方法，让它直接进行实例化是不合理的，所以编译器规定它们不能实例化

6.java

数据库事务的隔离级别有4个，由低到高依次为Read uncommitted、Read committed、Repeatable read、Serializable，这四个级别可以逐个解决脏读、不可重复读、幻读这几类问题。

7.java

运行时常量池存放在方法区中
class文件中的常量池，在类加载后存放在运行时常量池中
方法区和栈的区别：方法区是线程共享的，栈是线程隔离的，方法区存储静态常量，栈存储对象引用和数据类型

8.java

subset(from，true，to，true)是Treeset的非静态方法，第一个true和第二个true表示是否包含边界值

9.spring

10.java

If the argument value is less than zero but greater than -1.0, then the result is negative zero ”，翻译过来就是：如果参数是-1.0到0.0之间的数，结果是-0.0。

11.java

synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性

12.java

get(key)==null也可以是这个key存储的值是null，所以不能这样判断
可以用containsKey()或者遍历KeySet

13.java

application对象只会创建一个

14.java

A：正确main方法是入口
B：J2SDK当然不仅仅包含java API
C：jar选项是java.exe 的选项
D：Appletviewer是运行applet的， applet 不用main方法，继承applet类即可。

15.java

getBytes(编码1)，根据编码1的方式把字符串转换为字节数组，new String(bytes，编码2)，根据编码2将数组转换为字符串

16.java

.length取的是split数组的长度，因为不匹配所以数组中是一个元素，""，所以长度是1

17.java

A Vector不使用泛型也可以正常使用
B 自定义异常的情况 速度：方法是栈，栈是在寄存器之下最快的，而且占的空间也少，自定义异常是堆，堆比栈慢
C 接口中不止包含变量声明，还要包含变量赋值，因为接口中的变量都是public static final修饰的，必须要赋初值

18.java

GenericServlet实现了ServletConfig接口，又关联了它（init()方法需要一个ServletConfig对象）

19.java

如果一个外部类被private修饰，那么它只能被自己访问，其他类使用不到，失去了意义
如果一个外部类被protected修饰，那么它要是想被继承，只有包内的类才能发现，包外的发现不了。那么就和default一样

20.java

effctively final是java8的新特性
匿名内部类和lambda表达式中使用的变量只能是final 的，所以jdk1.8自动缺省final，称为effctively final java7及之前的匿名内部类要是使用一个非final字符串，会编译报错
effctively final只要用户不重新赋值，就会自动有效

C 匿名类只能使用一次，而局部类则可以在自己的定义域内多次使用。
定义上：匿名类用在任何允许存在表达式的地方，而局部内部类用于在任何允许出现局部变量的地方出现。

21.java

逻辑运算符优先级：|| 大于&& 大于< 大于>

22.java

符号引用 ：符号引用以一组符号来描述所引用的目标。符号引用可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。
在解析阶段会有一个步将常量池当中二进制数据当中的符号引用转化为直接引用的过程。

21/9/15

1.java

java9提供接口的私有方法，必须是具体方法，必须有方法体

2.java

		public class Demo {
	public static void main(String[] args) {
		Collection<?>[] collections = 
{new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()};
				Super subToSuper = new Sub();
				for(Collection<?> collection: collections) {
	System.out.println(subToSuper.getType(collection));
}
}
abstract static class Super {
	public static String getType(Collection<?> collection) {
		return “Super:collection”;
}
public static String getType(List<?> list) {
		return “Super:list”;
}
public String getType(ArrayList<?> list) {
		return “Super:arrayList”;
}
public static String getType(Set<?> set) {
		return “Super:set”;
}
public String getType(HashSet<?> set) {
		return “Super:hashSet”;
}
}
static class Sub extends Super {
	public static String getType(Collection<?> collection) {
            return "Sub"; }
}
}

21/9/17

1.java

finally语句先于 return 和 throw语句执行