每日一练（1）

注：由于全部写在同一篇博客中，篇幅太长，所以以后每十天的练习作为一篇博客

DAY 01

选择题

1. HashMap的数据结构是怎样的？
   A：数组
   B：链表
   C：数组+链表
   D：二叉树
   答：C，数组+链表
   解析：
   在Java中，数组和引用是最基本的两种结构，它们可以构造所有的数据结构，HashMap实际上是一个链表的数组，是数组和链表的结合体。HashMap底层就是一个数组结构，数组中的每一项又是一个链表。
2. 以下关于构造方法的描述错误的是？
   A：构造方法的返回类型只能是void型
   B: 构造方法是类的一种特殊方法，它的方法名必须与类名相同。
   C：构造方法的主要作用是完成对类的对象的初始化工作。
   D：一个类可以定义多个构造方法
   答：A
   解析：
   ·Java中构造方法的特点有：构造方法名与类名相同；构造方法没有返回值类型，不写void；构造方法可以重载。
   ·Java中构造方法的作用：在创建对象时，给属性赋初值，构造方法在创建对象时被调用。
   ·Java中构造方法的分类：分为显示构造方法和隐式构造方法；当声明了构造方法时，系统不会提供隐式的默认的无参构造方法。
3. 下列叙述错误的是？
   A：在接口中定义的方法除了 default 和 static 关键字修饰的方法拥有方法体，其他方法都应是没有方法体的抽象方法（JDK1.8以后）
   B：一个Java类只能有一个父类，但可以实现多个接口
   C：在类声明中，用 implements 关键字声明该类实现的接口
   D：定义接口时使用 implements 关键字
   答：D
   解析：
   JDK8开始，接口中可以定义有方法体的方法，方法必须被 default 和 static 修饰；Java是单继承，继承可以传递；在类的生命中用 implements 关键字实现接口，用 extends 关键字继承父类，先继承后实现；定义类时使用 class 关键字，定义接口时使用 interface 关键字。
4. 下列哪种异常是检查型异常，需要在编写程序时声明？
   A：NullPointerException
   B：ClassCastException
   C：FileNotFoundException
   D：IndexOutOfBoundsException
   答：C
   解析：
   Java中异常通常分为编译时异常和运行时异常。编译时异常需要我们手动进行处理；运行时异常在运行时才会出现。C为检查型异常。
5. 非抽象类实现接口后，必须实现接口中的所有抽象方法，除了 abstract 外，方法头必须完全一致。
   答案：错误
   解析：
   两同两小一大原则：方法名、参数类型相同（两同）；子类返回类型小于等于父类返回类型、子类抛出异常大小小于等于父类抛出异常（两小）；子类访问权限大于等于父类访问权限（一大）。
6. 在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的？
   A：管道
   B：消息队列
   C：高速缓存数据库
   D：套接字
   答：A
   解析：
   暂无
7. ResultSet 中记录行的第一列索引为？
   A：-1
   B：0
   C：1
   D：以上都不是
   答：C
   解析：
   ResultSet 不同于普通数组，其索引从1开始而不是0
8. 以下代码将打印出
   A：com. jd
   B：com/jd/MyClass.class
   C：///MyClass.class
   D：com.jd.MyClass

public static void main (String[] args) { 
    String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
    System.out.println(classFile);
}

答：C
解析：
这个题目的坑在于 replaceAll 方法的第一个参数是一个正则表达式，"." 在正则表达式中表示任意字符，所以把前面字符串的所有字符全部替换为 “/”,若只想替换 “.”，可将第一个参数写为 “\.”

9. Java关于异常处理机制的叙述哪些正确
   A：catch部分捕捉到异常情况时，才会执行finally部分
   B：当try区段的程序发生异常时，才会执行catch区段的程序
   C：在try区段不论程序是否发生异常及捕获到异常，都会执行finally部分
   D： 以上都是
   答：BC
   解析：
   将需要处理的代码放在 try 中，创建相应的 catch 块列表（try 后可能存在多个 catch 块，每个处理不同的异常），如果产生的异常与 catch 中的相匹配，那么 catch 中的块语句就会被执行。而 finally 语句是定义一个总是执行的代码，并不考虑异常是否被捕获。
10. 已知 boolean result = false 则下面哪个选项是合法的？
    A：result=1
    B：result=true;
    C：if(result!=0) {//so something…}
    D：if(result) {//do something…}
    答：BD
    解析：
    boolean类型只有两个直接量值：true 和 false；除了成员变量会有默认初始值之外，其他变量必须在第一次使用之前初始化。注：String 默认初始为 null

数据类型	默认初始值
byte	(byte) 0
short	(short) 0
int	0
long	0L
float	0.0f
double	0.0d
char	\u0000
boolean	false

编程题

leetcode 1816
句子是一个单词列表，列表中的单词之间用单个空格隔开，且不存在前导或尾随空格。每个单词仅由大小写英文字母组成（不含标点符号）。例如，“Hello World”、“HELLO” 和 “hello world hello world” 都是句子。给你一个句子 s​​​​​​ 和一个整数 k​​​​​​ ，请你将 s​​ 截断 ​，​​​使截断后的句子仅含前 k​​​​​​ 个单词。返回 截断 s​​​​​​ 后得到的句子。

示例：

class Solution {
    public String truncateSentence(String s, int k) {
        int n = s.length();		//获取字符串长度
        int count = 0, end = 0; //count用来记录遍历过的单词数量，end用来记录截取字符串末尾下标
        for (int i = 0; i <= n; i++) {
        	//如果遇见' '或者到字符串末尾（i 等于字符串的长度的时候）count++
            if (i == n || s.charAt(i) == ' ') {
                count++;
                //当 count 等于给出的整数 k 的时候记录 i 的值为要截取的末端end
                if (count == k) {
                    end = i;
                    break;
                }
            }
        }
        //输出字符串 0 到 end 
        return s.substring(0, end);
    }
}

Day 02

选择题

1. 在 WEB 应用程序的文件与目录结构中，web.xml 是放置在（）中。
   A：WEB-INF目录
   B：conf目录
   C：lib目录
   D：classes目录
   答：A
   解析：
   web.xml 文件是用来初始化配置信息，它是放置在 WEB-INF 目录中。
2. 哪个关键字可以对对象加互斥锁？
   A：synchronized
   B：volatile
   C：serialize
   D：static
   答：A
   解析：
   ·synchronized 关键字：用来给对象和方法或者代码块加锁，当锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。
   ·volatile：作用是确保将变量的更新操作通知到其他线程。
   ·serialize：Java 对象序列化。
   ·static：该关键字可以修饰变量，方法，静态代码块。
3. 分析以下代码，说法正确的是？
   A：运行时报错
   B：程序正常运行，输出值为5
   C：程序正常运行，输出值为10
   D：程序正常运行，输出值为15

 public static void main(String[] args) {
     System.out.println(val());
 }
  
 public static int val() {
     int num = 5;
     try {
     num = num / 0;
 } catch (Exception e) {
     num = 10;
 } finally {
     num = 15;
 }
 	return num;
 }

答： D
解析：
无论是否有异常，finally块中的代码一定会执行且在最后执行。

4. 顺序执行下列程序语句后，则b的值是？
   A：Hello
   B：Hel
   C：He
   D：null

String a="Hello";
String b=a.substring(0,2);

答：C
解析：
substring，左闭右开。

5. 一般情况下，以下哪个选项不是关系数据模型与对象模型之间匹配关系？
   A：表对应类
   B：记录对应对象
   C：表的字段对应类的属性
   D：表之间的参考关系对应类之间的依赖关系
   答：D
   解析：
   对象数据模型和关系数据模型有以下对应关系：表-类；记录-对象；表的字段-类的属性。
6. 下列程序执行后输出结果为？
   A：
   static BaseClass
   I’m BaseClass class
   static Base
   I’m Base class
   B：
   I’m BaseClass class
   I’m Base class
   static BaseClass
   static Base
   C：
   I’m BaseClass class
   static BaseClass
   I’m Base class
   static Base
   D：
   static BaseClass
   static Base
   I’m BaseClass class
   I’m Base class

class BaseClass {
    public BaseClass() {}
 
    {
        System.out.println("I’m BaseClass class");
    }
 
     static {
         System.out.println("static BaseClass");
     }
 }
 
 public class Base extends BaseClass {
     public Base() {}
 
     {
         System.out.println("I’m Base class");
     }
 
     static {
         System.out.println("static Base");
     }
 
     public static void main(String[] args) {
         new Base();
     }
 }

答：D
解析：
执行顺序：父类静态代码块→子类静态代码块→父类非静态代码块→父类构造函数→子类非静态代码块→子类构造函数

7. 下列代码执行结果为？
   A：21
   B：12
   C：可能为12，也可能为21
   D：以上答案都不对

public static void main(String args[])throws InterruptedException{
	Thread t=new Thread(new Runnable() {
    	public void run() {
    		try {
    			Thread.sleep(2000);
    		} catch (InterruptedException e) {
    			throw new RuntimeException(e);
    		}
            System.out.print("2");
        }
    });
    t.start();
    t.join();
    System.out.print("1");
}

答：A
解析：
子线程用了join函数，因此主线程必须等待子线程执行完毕才结束因此输出结果只能是21

8. 将下列哪个代码替换下列程序中的【代码】不会导致编译错误？
   A：public int f(){return 100+M;}
   B：int f(){return 100;}
   C：public double f(){return 2.6;}
   D：public abstract int f();

interface Com{
    int M=200;
    int f();
}
class ImpCom implements Com{
    【代码】
}

答：A
解析：
实现类是可以获取接口中的属性；实现接口中的方法需要遵守两同两小一大原则。接口中方法的public abstract 可以省略，但仍存在。

9. 关于多线程和多进程，下面描述正确的是？
   A：多进程里，子进程可获得父进程的所有堆和栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间。
   B：线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护。
   C：线程的通信速度更快，切换更快，因为他们在同一地址空间内。
   D： 一个线程可以属于多个进程。
   答：AC
   解析：
   待总结
10. JDK提供的用于并发编程的同步器有哪些？
    A：Semaphore
    B：CyclicBarrier
    C：CountDownLatch
    D：Counter
    答：ABC
    解析：
    待总结

编程题

leetcode 7
给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。

class Solution {
    public int reverse(int x) {
    	//用来记录反转后的数字
        int rev = 0;
        while (x != 0) {
        	//如果反转后的数超过范围则返回0
            if (rev < Integer.MIN_VALUE / 10 || rev > Integer.MAX_VALUE / 10) {
                return 0;
            }
            //分别取出给出数字的各位数字
            int digit = x % 10;
            //将x更新为下一阶段的数
            x /= 10;
            //将翻转过来的数计算出来并返回
            rev = rev * 10 + digit;
        }
        return rev;
    }
}

DAY 03

选择题

1. “先进先出” 的容器是？
   A：堆栈(Stack)
   B：队列（Queue）
   C：字符串(String)
   D：迭代器(Iterator)
   答：B
   解析：
   堆栈(Stack) 是一种具有先进后出特点的容器；队列(Queue) 是具有先进先出的特点。字符串是一个存储数据的结构，并没有严格规定出入要求；迭代器的数据读取取决于迭代方式。

2. 以下的变量定义语句中，合法的是？
   A：byte a =128;
   B：boolean b =null;
   C：long c=123L;
   D：float d = 0.9239;
   答：C
   解析：
   byte 的范围 [-128, 127]；boolean 类型的取值只能是 true 或 false；Java 默认 0.9239 为 double 类型的。

3. 下面哪个选项放在 point X 这里可以正确执行？
   A：import java.io.PrintWriter;
   B：include java.io.PrintWriter;
   C：import java.io.OutputStreamWriter;
   D：include java.io.OutputStreamWriter;
   E：no statement is needed.

//point X
public class Foo {
    public static void main(String[] args) throws Exception {
 
        PrintWriter out = new PrintWriter(
                new java.io.OutputStreamWriter(System.out), true);
        out.println("Hello");
    }
}

答：A
解析：
由于代码使用了 printWriter 类，所以需要导入，而 Java 中并没有使用 include 关键字，故选择A；至于 OutputStreamWriter ，在使用的时候是类的全名称，所以并不需要导包。

4. 已知有下列 Test 类的说明，在该类的main方法的横线处，则下列哪个语句是正确的？
   A：t.f = 1;
   B：this.n = 1;
   C：Test.m = 1;
   D：Test.f = 1;

public class Test {
	private float f = 1.0f;
	int m = 12;
	static int n = 1;
	public static void main (String args[]) {
		Test t = new Test();
		————————
	}
}

答：A
解析：
A 选项，虽然 f 为 Test 类的私有成员属性，但是 main 方法在 Test 类内部，因此可以访问到；B 选项，static 静态方法中不能使用 this；C D选项，m 和 f 都是普通成员属性，因此并不能使用类名.来调用。

5. 设 x = 1 , y = 2 , z = 3，则表达式 y += z-- / ++x 的值是？
   A：3
   B：3.5
   C：4
   D：5
   答：A
   解析：
   由于自增自减优先级高于除，所以上式可变为 y = 2 + 3 / 2 但又因为x, y, z 都是 int 型的，所以 y = 2 + 1 即 y = 3 结束。

6. 在开发中使用泛型取代非泛型的数据类型（比如用ArrayList< String >取代ArrayList），程序的运行时性能会变得更好。
   答：错误
   解析：
   泛型只是提高了数据传输安全性，并没有改变程序运行的性能。

7. 以下代码运行输出的是？
   A：输出：Person
   B：没有输出
   C：编译出错
   D：运行出错

public class Person{
    private String name = "Person";
    int age=0;
}
public class Child extends Person{
    public String grade;
    public static void main(String[] args){
        Person p = new Child();
        System.out.println(p.name);
    }
}

答案：C
解析：
待总结

8. 对Collection和Collections描述正确的是？
   A：Collection是java.util下的类，它包含有各种有关集合操作的静态方法
   B：Collection是java.util下的接口，它是各种集合结构的父接口
   C：Collections是java.util下的接口，它是各种集合结构的父接口
   D：Collections是java.util下的类，它包含有各种有关集合操作的静态方法
   答：BD
   解析：
   ·java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
   ·java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

9. Java7特性中,abstract class和interface有什么区别。？
   A：抽象类可以有构造方法，接口中不能有构造方法
   B：抽象类中可以有普通成员变量，接口中没有普通成员变量
   C：抽象类中不可以包含静态方法，接口中可以包含静态方法
   D：一个类可以实现多个接口，但只能继承一个抽象类。
   答：ABD
   解析：
   待总结

10. java中 String str = "hello world"下列语句错误的是？
    A：str+=’ a’
    B：int strlen = str.length
    C：str=100
    D：str=str+100
    答：ABC
    解析：
    str += ‘a’ 和 str +="a"都是对的，但是如果a前面加一个空格，那么只能用双引号了。代表字符串。

编程题

leetcode 26
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明: 为什么返回数值是整数，但输出的答案是数组呢? 请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

示例：
输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

分析：
该题可以采用双指针的解法，这里以示例给出的数组 nums 为例。
首先，我们分析特殊情况，如果数组长度为零，则直接返回0
然后，我们要判断指针的起始位置，由于给定的数组是有序的，如果数组长度大于0的话，删除重复元素后数组至少还剩余一个元素，即数组 nums 的第一个元素 nums[0] ，所以指针的起始位置可以从下标1开始。

然后，建立循环进行遍历删除重复元素，当指针 f 没有发生越界，也就是 f < nums.length 时，进行循环操作。当指针 f 指向的元素不等于它的前一个元素的时候我们将指针 f 指向的元素赋值给指针 s 指向的位置，然后让指针 s 和指针 f 分别指向下一个位置；若指针 f 指向的元素等于它的前一个元素的时候，我们让指针 f 指向下一个位置，指针 s 保持不动，直到指针 f 找到下一个不重复的数字来替换。最后返回指针 s 指向的位置即可。如下图：

代码：

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int f = 1, s = 1;
        while (f < nums.length) {
            if (nums[f] != nums[f - 1]) {
                nums[s] = nums[f];
                ++s;
            }
            ++f;
        }
        return s;
    }
}

DAY 04

害，我太拉了，好几天没更新了，最近期末事情太多。算了，还是不要找借口了，加油！

选择题

1. 代码String str=”123456a”；int i=Integer.parseInt(str);会报异常的是？
   A：java.lang.NullPoninterException
   B：java.lang.NumberFormatException
   C：java.lang.RuntimeException
   D：java.lang.ArrayindexOutOfBoundsException
   答：B
   解析：
   由于 “123456a” 为非纯数字的字符串，所以转化的时候会报数字格式异常。
   A 选项是变量未被初始化、对象未赋值、对象为空，也就是我们常说的空指针异常。
   B 选项是数据格式转换失败。
   C 选项是运行时异常
   D 选项是数组下标越界

2. 类 Test1 定义如下，将以下哪种方法插入行3是不合法的？
   A：public int aMethod(int a,int b){}
   B：private float aMethod(int a,int b,int c){}
   C：public float aMethod(float a,float b){}
   D：public float aMethod(float a,float b,float c){}

public class Test1{//1
    public float aMethod(float a,float b){}//2 
    //3
}//4

答：C
解析：
该题考查方法的重载，方法重载的具体规范如下：方法名一定相同；方法参数列表必须不同，包括参数的类型或者个数，以此区分不同的方法体；方法的返回类型、修饰符可以相同，也可不同。

3. 下列代码的执行结果是？
   A：1和1
   B：1和1.0
   C：1.0和1
   D：1.0和1.0

public class Test3{
 public static void main(String args[]){
    System.out.println(100%3);
    System.out.println(100%3.0);
 }
}

答：B
解析：
多种混合计算时，基本数据类型会自动向上转型，小数默认为 double 类型。

4. 事务隔离级别是由谁实现的？
   A：Java 应用程序
   B：Hibernate
   C：数据库系统
   D：JDBC 驱动程序
   答：C
   解析：
   事务隔离级别是由数据库系统实现的，它是数据库系统本身的一个功能。

5. 下面代码运行的结果是？
   A：ABDCBDCB
   B：ABCDABCD
   C：Compilation fails.
   D：An exception is thrown at runtime.

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

答：A
解析：
这道题说白了考察 for 循环的执行顺序，如下：

for (表达式1; 表达式2; 表达式4) {
	表达式3;
}

①首次循环，即参数初始化循环：首先，执行表达式1，一般为定义并且初始化一个循环变量；然后执行表达式2，一般为条件判断语句，判断表达式1定义的循环变量是否符合表达式2的条件，如果符合，则执行表达式3，否则终止循环；最后，执行表达式4，更新循环变量。
②再次循环：首先判断表达式2是否为真，如果为真，继续执行表达式3；否则，跳出循环体；最后执行表达式4，再次更新循环变量。如此往复，直到表达式2为假。

6. ArrayList list = new ArrayList(20);中的list扩充几次？
   A：0
   B：1
   C：2
   D：3
   答：A
   解析：
   Arraylist默认数组大小是10，扩容后的大小是扩容前的1.5倍，最大值小于Integer 的最大值减8，如果新创建的集合有带初始值，默认就是传入的大小，也就不会扩容。

7. 以下哪项不属于 Java 类加载的过程？
   A：生成java.lang.Class对象
   B：int类型对象成员变量赋予默认值
   C：执行static块代码
   D：类方法解析
   答：B
   解析：
   类的加载过程应该包括：加载，验证，准备，解析，初始化。对象成员在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。

8. 以下程序的输出结果为？
   A：BD
   B：DB
   C：C
   D：编译错误

class Base{
    public Base(String s){
        System.out.print("B");
    }
}
public class Derived extends Base{
    public Derived (String s) {
        System.out.print("D");
    }
    public static void main(String[] args){
        new Derived("C");
    }
}

答：D
解析：
在调用子类构造器之前，会先调用父类构造器，当子类构造器中没有使用 “super(参数或无参数)” 指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，则在子类构造器中一定要使用“super(参数)”指定调用父类的有参构造器，不然就会报错。

9. 下面属于 JSP 内置对象的是？
   A：out对象
   B：response对象
   C：application对象
   D：page对象
   答：ABCD
   解析：
   JSP 有九大内置对象：
   · pageContext 表示页容器 EL表达式、 标签 、上传
   · request 服务器端取得客户端的信息：头信息 、Cookie 、请求参数 ，最大用处在MVC设计模式上
   · response 服务器端回应客户端信息：Cookie、重定向
   · session 表示每一个用户，用于登录验证上
   · application 表示整个服务器
   · config 取得初始化参数，初始化参数在web.xml文件中配置
   · exception 表示的是错误页的处理操作
   · page 如同this一样，代表整个jsp页面自身
   · out 输出 ，但是尽量使用表达式输出

10. 下面的 switch 语句中，x可以是哪些类型的数据？
    A：long
    B：char
    C：float
    D：byte
    E：double
    F：object

switch(x)
{
default:
System.out.println("Hello");
}

答：BD
解析：
在Java7之前，switch 只能支持 byte、short、char、int或者其对应的封装类以及 Enum 类型。在Java7中，也支持了 String 类型 String byte short int char Enum 类型。

编程题

leetcode 58
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

示例：
输入：s = " fly me to the moon "
输出：4

分析：
该题可以用逆向思维，题目要求返回最后一个单词的长度，我们可以从字符串的末尾开始，进行判断。
首先，我们要判断字符串的末尾是否存在 ’ ’ ，如果存在则依次往前进行判断，直到找到字母为止。
然后，在满足条件 n >= 0 && s.charAt(n) != ’ ’ （n为当前位置，该表达式的意思为：n所在位置在字符串内，并且没有遇到 ’ ‘），也就是从后往前遇到字母开始，到遇见第一个 ‘ ’ 结束，并且在字符串范围内，我们让 count++ （count 记录字母个数，也就是最后一个单词长度），然后更新 n 。
最后，返回 n 的值。

代码：

class Solution {
    public int lengthOfLastWord(String s) {
        int n = s.length() - 1;
        while (s.charAt(n) == ' ') {
            n--;
        }
        int count = 0;
        while (n >= 0 && s.charAt(n) != ' ') {
            count++;
            n--;
        }
        return count;
    }
}

DAY 05

选择题

1. 下列修饰符中与访问控制权限无关的是？
   A：private
   B：public
   C：protected
   D：final
   答：D
   解析：
   权限修饰符：
   · private 私有
   · 默认（不写）
   · protected 受保护的
   · public 共有的
   状态修饰符：
   · final 最终，修饰类，则该类不能被继承；修饰方法，则该方法不能被重写；修饰变量，则该变量不能被重新赋值，相当于常量。
   · static 静态变量，随着类的加载而加载，优先于对象存在，被所有对象所共享，可通过类名调用。

2. 不考虑反射机制，一个子类显式调用父类的构造器必须使用 super 关键字。
   答：正确
   解析：
   子类显示调用父类中的构造方法必须使用super关键字，如果子类没有显示调用父类中的构造方法，则系统默认会调用父类中的无参构造方法；若此时父类中没有定义无参构造方法则会报错。

3. 以下关于构造方法的说法，正确的是？
   A：一个类的构造方法可以有多个
   B：构造方法在类定义时被调用
   C：构造方法只能由对象中的其他方法调用
   D：构造方法可以和类同名，也可以和类名不同
   答：A
   解析：
   A 选项：一个类可以有多个构造方法是因为构造方法可以重载。
   B 选项：构造方法在类实例化对象时调用来初始化对象，自动调用。
   C 选项：同 B 选项。
   D 选项：构造方法名必须和类名相同。

4. 下列程序的运行结果？
   A：pingpong
   B：pongping
   C：pingpong 和 pongping 都有可能
   D：都不输出

public static void main(String args[]) {
    Thread t = new Thread() {
        public void run() {
            pong();
        }
    };
    t.run();
    System.out.print("ping");
}
static void pong() {
    System.out.print("pong");
}

答：B
解析：
该题考查线程的 start() 和 run() 方法：
用 start 方法才是真正启动线程，此时线程会处于就绪状态，一旦得到时间片，则会调用线程的 run 方法进入运行状态。
而 run 方法只是普通的方法，如果直接调用，程序只会按照顺序执行主线程。

5. 检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
   A：test okandabc
   B：test okandgbc
   C：goodandabc
   D：goodandgbc

public class Example { 
  String str = new String("good"); 
  char[] ch = {'a','b','c'}; 
  public static void main(String[] args) { 
     Example ex = new Example(); 
     ex.change(ex.str, ex.ch); 
     System.out.print(ex.str +"and"); 
     System.out.print(ex.ch);  
  } 
    
  public void change(String str, char ch[]){ 
     str= "test ok"; 
     ch[0]= 'g'; 
  } 
} 

答：D
解析：
在 Java 中 String 时不可变的，一旦初始化后，其引用指向的内容是不可变的。

6. 下面代码的输出是什么？
   A：null
   B：sub
   C：base

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }
 
    public void callName()
    {
        System. out. println(baseName);
    }
 
    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

答：A
解析：
new Sub(); 在创造派生类的过程中首先创建基类对象，然后才能创建派生类。
创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null (牛客大佬的解析)

7. Given the following code:Which statement at line 10 constructs an instance of the inner class?
   A：InsideOne ei=eo.new InsideOne();
   B：eo.InsideOne ei=eo.new InsideOne();
   C：InsideOne ei=EnclosingOne.new InsideOne();
   D：EnclosingOne.InsideOne ei=eo.new InsideOne();

package cn.com.test;

public class EnclosingOne {
    public class InsideOne {}
}

package cn.com.cow;

import cn.com.test.EnclosingOne;
import cn.com.test.EnclosingOne.InsideOne;

public class InerTest
{
    public static void main(String[]args)
    {
        EnclosingOne eo = new EnclosingOne();
        //insert code here 
    }
}

答：AD
解析：
以以下示例：

public class Enclosingone {
    //非静态内部类
    public class InsideOne {}
    //静态内部类
    public static class InsideTwo{}
}
 
class Mytest02{
    public static void main(String args []){
        Enclosingone.InsideOne obj1 = new Enclosingone().new InsideOne();//非静态内部类对象
        Enclosingone.InsideTwo obj2 = new Enclosingone.InsideTwo();//静态内部类对象
    }
}

8. 在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（）；当N=9时呢？
   A：11
   B：144
   C：55
   D：89
   答：BC
   解析：
   这道题其实符合斐波那契数列的规律，我么可以想象以下，当你呆在 n 楼时，后退一步就只能到 n - 1 楼或者 n - 2 楼，说白了就是到达第 n 楼的方法数就等于到达第 n - 1 楼的方法数加上到达第 n - 2 楼的方法数。
   代码验证：

public class Test {
	public static void main(String[] args) {
		System.out.println(test(11) + " " + test(9));
	}

	private static int test(int n) {
		if(n==1) {
			return 1;
		}else if(n==2) {
			return 2;
		}else {
			return test(n-1) + test(n-2);
		}
	}
}

输出：144 55

9. 关于java中的数组，下面的一些描述，哪些描述是准确的？
   A：数组是一个对象，不同类型的数组具有不同的类
   B：数组长度是可以动态调整的
   C：数组是一个连续的存储结构
   D：一个固定长度的数组可类似这样定义：int array[100]
   E：两个数组用Object 里equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
   F： java中不存在 int *a这样的东西做数组的形参
   答：ACF
   解析：
   关于 E 选项，这里不能混淆 Object 里的 equals 方法和 Arrays.equals 方法，数组1.equals(数组2)，调用的是 Object 类的，比较的是地址（==），Arrays 的 equals 方法是逐个元素比较，但也只是对基本数据类型进行逐个比较，其他的类型需要重写。

10. 局部内部类可以用哪些修饰符修饰？
    A：public
    B：private
    C：abstract
    D：final
    答：CD
    解析：
    局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰。
    关于内部类，可以参考这位大佬的文章：Java 内部类总结

编程题

由于本次选择题中出现了爬楼梯的题目，所以本次的编程题也找了爬楼梯的题目，统一进行总结分析。
leetcode 70
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？注意：给定 n 是一个正整数。

示例：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。1 阶 + 1 阶 + 1 阶；1 阶 + 2 阶；2 阶 + 1 阶

分析：
方法一：可以使用滚动数组的思想，你呆在 n 层时，后退一步就只能到 n - 1 层或者 n - 2 层，说白了就是到达第 n 层的方法数就等于到达第 n - 1 层的方法数加上到达第 n - 2 层的方法数。如下图，以此类推，r 表示爬到该层的方法数。

代码：

class Solution {
    public int climbStairs(int n) {
        int p = 0, q = 0, r = 1;
        for (int i = 1; i <= n; ++i) {
            p = q; 
            q = r; 
            r = p + q;
        }
        return r;
    }
}

力扣官方还给出了，矩阵快速幂、通项公式两种方法，暂不做总结。

DAY 06

选择题

1. 默认RMI采用的是什么通信协议？
   A：HTTP
   B：UDP/IP
   C：TCP/IP
   D：Multicast
   答：C
   解析：
   RMI(Remote Method Invocation)远程方法调用是一种计算机之间利用远程对象互相调用实现双方通讯的一种通讯机制。TCP/IP套接字通讯是远程通讯的主要手段。

2. 关于下列程序段的输出结果，说法正确的是？
   A：有错误，变量ｉ没有初始化
   B：null
   C：1
   D：0

public class MyClass{
    static int i;
    public static void main(String argv[]){
        System.out.println(i);
    }
}

答：D
解析：
这道题考查类变量在未初始化的时候，会默认进行赋值，而局部变量必须进行初始化后才能使用，它不会进行默认赋值。

3. 以下代码将打印出？
   A：编译错误
   B：true true
   C：true false
   D：false false

public static void main(String args[]) {
      List  Listlist1 = new ArrayList();
      Listlist1.add(0);
      List Listlist2 = Listlist1;
      System.out.println(Listlist1.get(0) instanceof Integer);
      System.out.println(Listlist2.get(0) instanceof Integer);
}

答：B
解析：
该题考查集合相关的知识，关于 ArrayList 只能装入对象类型的数据，本题向 ArrayList 中添加了一个基本数据类型 0 ，但是 JDK 5 以后提供了自动装箱与自动拆箱，将基本数据类型自动装箱为对应的包装类型。
instanceof 关键字是用来判断一个对象是否属于某个特定的类的实例，并且返回 boolean 类型的值。题目中我们可以看出 Listlist1 和 Listlist2 指向同一堆内存空间。显然 Listlist1.get(0) 和 Listlist2.get(0) 都属于 Integer 的实例，所以输出 true true 。

4. 对下面Spring声明式事务的配置含义的说明错误的是？
   A：定义了声明式事务的配置模板
   B：对get方法采用只读事务
   C：缺少sessionFactory属性的注入
   D：配置需要事务管理的bean的代理时，通过parent引用这个配置模板，代码如下：

<bean id="petBiz" parent="txProxyTemplate">
         <property name="target" ref="petTarget"/>
</bean>

<bean id="txProxyTemplate" abstract="true"
class=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager" ref="myTransactionManager" />
<property name="transactionAttributes">      
 <props>
        <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
         <prop key="*">PROPAGATION_REQUIRED</prop>
     </props>
</property> 
</bean>

答：C
解析：
暂无，框架还未学习。

5. 对于如下代码段，可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是？
   A：public void foo(){}
   B：public int foo(){return 1;}
   C：public A foo(B b){return b;}
   D：public A foo(){return A;}

class A{
    public A foo() {
        return this;
    }
}
class B extends A {
    public A foo(){
        return this;
    }
}
class C extends B {
    _______
 
}

答：C
解析：
对于方法的重写：两同两小一大原则 - 方法名、参数类型相同（两同）；子类返回类型小于等于父类返回类型、子类抛出异常大小小于等于父类抛出异常（两小）；子类访问权限大于等于父类访问权限（一大）。
对于方法的重载：方法名必须相同，参数类型必须不同，包括但不限于一项，参数数目，参数类型，参数顺序，修饰符和返回值类型可以相同也可不同。
对于本题 A B 选项，方法名和参数相同，但是返回类型和父类返回类型没有继承关系，故错误。C 选项参数类型和父类不同，所以不是重写。D 选项返回 A 是有问题的。

6. jre 判断程序是否执行结束的标准是？
   A：所有的前台线程执行完毕
   B：所有的后台线程执行完毕
   C：所有的线程执行完毕
   D：和以上都无关
   答：A
   解析：
   来源百度： 后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。 前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

7. Java关于异常处理机制的叙述哪些正确？
   A：catch部分捕捉到异常情况时，才会执行finally部分
   B：当try区段的程序发生异常时，才会执行catch区段的程序
   C：在try区段不论程序是否发生异常及捕获到异常，都会执行finally部分
   D：以上都是
   答：BC
   解析：
   该题考查 try - catch - finally 语句，在该语句中，将要处理的代码放入 try 块中，然后建立相应的 catch 块的列表。如果生成的异常与 catch 中提到的相匹配，那么 catch 条件中的块语句就被执行。
   try 块后可能有许多 catch 块，每个都处理不同的异常。finally 语句定义一个总是执行的代码，而不考虑异常是否被捕获。

8. 面向对象的程序设计语言具有哪些共同特性？
   A：封装性
   B：多态性
   C：简单性
   D：复杂性
   E：继承性
   答：ABE
   解析：
   这题没有什么多说的，我选错了，多选了一个简单性。

9. Java 中 Hashtable，Vector，TreeSet，LinkedList 哪些线程是安全的？
   A：Hashtable
   B：Vector
   C：TreeSet
   D： LinkedList
   答：AB
   解析：
   LinkedList 和 ArrayList 都不是同步的，线程不安全；Vector 和 Stack 都是同步的，线程安全；Set 是线程不安全的；Hashtable 的方法是同步的，线程安全；HashMap 的方法不是同步的，线程不安全。

10. 根据下面这个程序的内容，判断哪些描述是正确的？
    A：这段程序有编译错误
    B：语句1输出为:Hello, tommy
    C：语句2输出为:Hello, tommy
    D：语句1输出为:Welcome, tommy
    E：语句2输出为:Welcome, tommy
    F：根据选用的Java编译器不同，这段程序的输出可能不同

public class Test {
    public static void main(String args[]) {
        String s = "tommy";
        Object o = s;
        sayHello(o); //语句1
        sayHello(s); //语句2
    }
    public static void sayHello(String to) {
        System.out.println(String.format("Hello, %s", to));
    }
    public static void sayHello(Object to) {
        System.out.println(String.format("Welcome, %s", to));
    }
}

答：CD
解析：
这道题我解释不到位。

编程题

leetcode 88
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

分析：
方法一：直接合并后排序，简单地说就是将 nums2 直接放入 nums1 中，然后对 nums1 进行排序即可。

代码：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i != n; ++i) {
            nums1[m + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }
}

方法二：双指针（从前往后），方法一中，我们并没有利用到 nums1 和 nums2 已经排序的特点，所以方法二使用双指针是一种优化，将题目给的条件都应用进去。我们让两个指针分别指向 nums1 和 nums2 的初始位置，比较两个位置元素的大小，哪个元素小，我们将其按顺序放入数组中；若两个数组任意一个中元素取完了，则将另一个按顺序放入数组即可，最后将另外开辟出的数组元素一一赋值给 nums1 。

代码：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p = 0; //nums1 指针
        int q = 0; //nums2 指针
        int x; //记录要存入数组的元素
        int[] arr = new int[m + n];  //开辟新数组来存储符合要求的元素
        while (p < m || q < n) {
            if (p == m) {
                x = nums2[q++];
            } else if (q == n) {
                x = nums1[p++];
            } else if (nums1[p] < nums2[q]) {
                x = nums1[p++];
            } else {
                x = nums2[q++];
            }
            arr[p + q - 1] = x;
        }
        //将结果重新赋给 nums1
        for (int i = 0; i < m + n; ++i) {
            nums1[i] = arr[i];
        }
    }
}

方法三：双指针（从后往前），该方法是对方法二的一种优化，方法二中需要开辟新的数组空间，而方法三从后往前使用双指针优化了空间问题。我们将两个指针分别指向 nums1 和 nums2 有效元素的末尾，比较两个元素的大小，哪个元素大，我们将哪个元素放在 nums1 数组的末尾，若两个数组有任意一个中元素取完，则将另一个中的元素按顺序依次放入 nums1 中。

代码：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p = m - 1, q = n - 1;
        int t = m + n - 1;
        int x;
        while (p >= 0 || q >= 0) {
            if (p == -1) {
                x = nums2[q--];
            } else if (q == -1) {
                x = nums1[p--];
            } else if (nums1[p] > nums2[q]) {
                x = nums1[p--];
            } else {
                x = nums2[q--];
            }
            nums1[t--] = x;
        }
    }
}

DAY 07

选择题

1. 设Tree为已定义的类名，下列语句能正确创建 Tree 对象的是？
   A：Tree t=new Tree;
   B：Tree t=new Tree();
   C：Tree t=Tree();
   D：Tree t[ ]=new Tree[10];
   答：B
   解析：
   A 选项错误，调用构造方法的写法错误，Tree()；
   B 选项正确，调用的是 Tree 类的无参构造方法；
   C 选项错误，实例化对象时缺少 new 关键字；
   D 选项错误，该选项声明了一个 Tree 类型的数组，并没有创建新的 Tree 类型对象。

2. 关于异常处理机制的叙述正确的时？
   A：catch部分捕捉到异常情况时，才会执行finally部分
   B：当try区段的程序发生异常时，才会执行finally部分
   C：当try区段不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
   D：以上都是
   答：C
   解析：
   该题考查 try - catch - finally 语句，在该语句中，将要处理的代码放入 try 块中，然后建立相应的 catch 块的列表。如果生成的异常与 catch 中提到的相匹配，那么 catch 条件中的块语句就被执行。
   try 块后可能有许多 catch 块，每个都处理不同的异常。finally 语句定义一个总是执行的代码，而不考虑异常是否被捕获。

3. 若所用变量都已正确定义，以下选项中，非法的表达式是？
   A：a!= 4||b==1
   B：’a’ % 3
   C：’a’ = 1/3
   D：’A’ + 32
   答：C
   解析：
   C 选项非法，‘a’ 是 char 类型的一个值（常数），不能对其进行赋值。其他选项没什么多说的。

4. 将类的成员的访问权限设置为默认的，则该成员能被什么访问？
   A：同一包中的类访问
   B：其他包中的类访问
   C：所有的类访问
   D：所有的类的子类访问
   答：A
   解析：
   该题考查的是访问权限的范围，如下：
   · public 共有的，可以被所有其他类所访问
   · protected 受保护的，可以被自身、同包的类、子类所访问
   · default 默认的（不写），可以被自身、同包的类所访问
   · private 私有的，只能被自身访问和修改。

5. try块后必须有catch块。
   答：错误
   解析：
   该题考查 try - catch - finally 语句，其形式可以有三种：try - catch 、try - finally 、try - catch - finally 即 catch 和 finally 语句不能同时省略。

6. off-heap是指那种内存？
   A：JVM GC能管理的内存
   B：JVM进程管理的内存
   C：在JVM老年代内存区
   D：在JVM新生代内存
   答：B
   解析：
   暂未学习

7. 当编译并运行下面程序时会发生什么结果？
   A：编译错误，指明run方法没有定义
   B：运行错误，只鞥呢run方法没有定义
   C：编译通过并输出0到9
   D：编译通过，但无输出

public class Bground extends Thread{
    public static void main(String argv[]){
        Bground b = new Bground();
        b.run();
    }
    public void start(){
        for(int i=0;i<10;i++){
            System.out.println("Value of i = "+i);
        }
    }
}

答：D
解析：
在线程中 start() 方法是线程的启动方法，让线程处于就绪状态，并没有运行，一旦得到 cpu 时间片，就开始执行相应线程的 run() 方法。在这里 Bground 类继承了 Thread 类，但是并没有重写 run() 方法，所以调用的是其父类 Thread 的 run() 方法，该方法并没有输出结果，源码如下：

@Override
public void run() {
	if (target != null) {
    target.run();
    }
}

8. 在创建派生类对象，构造函数的执行顺序为？
   A：基类构造函数，派生类对象成员构造函数，派生类本身的构造函数
   B：派生类本身的构造函数，基类构造函数，对象成员构造函数
   C：基类构造函数，派生类本身的构造函数，派生类对象成员构造函数
   D：对象成员构造函数，基类构造函数，派生类本身的构造函数
   答：A
   解析：
   顺序如下：
   父类静态域→子类静态域→父类成员初始化→父类构造块→父类构造方法→子类成员初始化→子类构造块→子类构造方法
   其中，静态域包含静态代码块与静态方法，谁在前先执行谁，非静态同理。

9. 局部内部类可以用哪些修饰符修饰？
   A：public
   B：private
   C：abstract
   D：final
   答：CD
   解析：
   局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰。
   关于内部类，可以参考这位大佬的文章：Java 内部类总结

10. 下面哪些赋值语句是正确的？
    A：long test=012
    B：float f=-412
    C：int other =(int)true
    D：double d=0x12345678
    E：byte b=128
    答：ABD
    解析：
    A 选项和 B 选项中 long 和 float 类型，正常定义需要加上 l 和 f ，但是基本数据类型会进行转换，所以并不会报错；
    C 选项，boolean 类型不能和任何类型进行转换；
    D 选项，0x 开头的为十六进制数，可以赋值；
    E 选项，byte 类型的取值范围是 -128 - 127 。

编程题

leetcode 27
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

分析：
方法一：双指针（从左到右）
首先，我们让两个指针都指向数组的起始位置，l 指针指向下一个将要赋值的位置，r 指针指向当前将要处理的元素。
然后进行判断，如果 nums[r] != val，说明该位置的元素不需要删除，我们把它赋值给 l 指针指向的位置，然后 l、r 同时右移；如果 nums[r] == val，说明该位置的元素需要删除，此时 l 指针不动，r 指针右移。
该方法在最坏的情况下，两个指针各遍历了一次数组。

代码：

class Solution {
    public int removeElement(int[] nums, int val) {
        int l = 0;
        for (int r = 0; r < nums.length; r++) {
            if (nums[r] != val) {
                nums[l] = nums[r];
                l++;
            }
        }
        return l;
    }
}

方法二：双指针（两边到中）
该方法是对方法一的一种优化，我们设置两个指针，从两边向中间进行遍历，避免了需要保留的元素的重复赋值操作，这样在最坏的情况下，两个指针加起来只遍历一次数组。
首先，我们定义指针 l ，指向数组的初始位置，然后定义指针 r ，指向数组的末尾位置；
然后进行判断，如果 nums[l] == val 则将 nums[r] 位置的元素赋值给 nums[l] ，然后 r 指针左移，如果赋值过来的的元素恰好也等于 val ，可以继续将 r 指针指向的元素赋值过来覆盖 l 指针指向的位置的元素，直到 l 指针指向的位置的值不等于 val 为止；nums[l] != val 时让 l 指针右移。
当 l 指针和 r 指针重合的时候，已经遍历完数组中所有的元素。

代码：

class Solution {
    public int removeElement(int[] nums, int val) {
        int l = 0;
        int r = nums.length;
        while (l < r) {
            if (nums[l] == val) {
                nums[l] = nums[r - 1];
                r--;
            } else {
                l++;
            }
        }
        return l;
    }
}

DAY 08

选择题

1. 哪个关键字表明一个对象或变量的引用在初始化后不能被修改？
   A：private
   B：final
   C：static
   D：没有这种关键字
   答：B
   解析：
   final 修饰的变量内容是不能修改的，如果 final 修饰一个对象的引用，那么指的是这个对象的地址值是无法改变的，对象的内容还是可以修改的。

2. javac 的作用是？
   A：将源程序编译成字节码
   B：将字节码编译成源程序
   C：解释执行 Java 字节码
   D：调试 Java 字节码
   答：A
   解析：
   javac 是将 Java 源程序编译成 .class 文件（字节码），Java 将字节码转为机器码（.exe程序）。

3. Java 表达式 “13 & 17” 的结果是？
   A：30
   B：13
   C：17
   D：1
   答：D
   解析：
   & 是位与运算符，将两个数字化成二进制数进行位运算，全为1则为1，否则为0；
   13：00000000 00000000 00000000 00001101
   17：00000000 00000000 00000000 00010001
   得: 00000000 00000000 00000000 00000001
   即为1

4. 下面程序的运行结果？
   A：dazhongdianping
   B：dianpingdazhong
   C：a和b都有可能
   D：dianping循环输出，dazhong夹杂在中间

public static void main(String args[]) {
        Thread t=new Thread(){
        public void  run(){
            dianping();      
        }
    };
    t.run();
    System.out.print("dazhong");
}
static void dianping(){
    System.out.print("dianping");
}

答：B
解析：
在该题的 main() 方法中，并没有开启一个新的线程，因为调用的是 run() 方法，等价于简单的方法调用，因此还是只有主线程一个线程，所以按顺序执行结果为 B 选项；如果要开启新线程，需要调用 t.start(); 开启线程，等待 CPU 时间片，一旦获取到，则调用 run() 方法，这种情况是 A B 选项都有可能。

5. Java 数据库连接库 JDBC 用到哪种设计模式？
   A：生成器
   B：桥接模式
   C：抽象工厂
   D：单例模式
   答：B
   解析：
   用到了桥接模式，具体还没学习，暂不总结。

6. 在 Java 中，以下数据类型中，需要内存最多的是？
   A：byte
   B：long
   C：Object
   D：int
   答：B
   解析：
   Object 是引用数据类型，只申明而不创建实例，只会在栈内存中开辟空间，默认为空，站 1 bit ；
   long 的最大数据存储量为 2 的 64 次方减 1 。

7. 以下代码的输出结果是？
   A：静态块 构造块 构造块 构造块
   B：构造块 静态块 构造块 构造块
   C：构造块 构造块 静态块 构造块
   D：构造块 构造块 构造块 静态块

public class B
{
    public static B t1 = new B();
    public static B t2 = new B();
    {
        System.out.println("构造块");
    }
    static
    {
        System.out.println("静态块");
    }
    public static void main(String[] args)
    {
        B t = new B();
    }
}

答：C
解析：
（借用牛客大佬的解析！！！）
开始时 JVM 加载 B.class ，对所有的静态成员进行声明，t1 t2 被初始化为默认值，为 null ，又因为 t1 t2 需要被显式初始化，所以对 t1 进行显式初始化，初始化代码块→构造函数（没有就是调用默认的构造函数），咦！静态代码块咋不初始化？因为在开始时已经对 static 部分进行了初始化，虽然只对 static 变量进行了初始化，但在初始化 t1 时也不会再执行 static 块了，因为 JVM 认为这是第二次加载类 B 了，所以 static 会在 t1 初始化时被忽略掉，所以直接初始化非 static 部分，也就是构造块部分（输出’‘构造块’’）接着构造函数（无输出）。接着对 t2 进行初始化过程同 t1 相同（输出’构造块’），此时就对所有的 static 变量都完成了初始化，接着就执行 static 块部分（输出’静态块’），接着执行，main 方法，同样也，new 了对象，调用构造函数输出（‘构造块’）。

8. 下面哪些类实现或继承了 Collection 接口？
   A：HashMap
   B：ArrayList
   C：Vector
   D：Iterator
   答：BC
   解析：
   （借用牛客大佬的图）
   

9. Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法是Collection接口所定义的？
   A：int size()
   B：boolean containsAll(Collection c)
   C：compareTo(Object obj)
   D：boolean remove(Object obj)
   答：ABD
   解析：
   compareTo是接口Comparable中的方法

10. 下面描述属于java虚拟机功能的是？
    A：通过 ClassLoader 寻找和装载 class 文件
    B：解释字节码成为指令并执行，提供 class 文件的运行环境
    C：进行运行期间垃圾回收
    D：提供与硬件交互的平台
    答：ABCD
    解析：
    暂无

编程题

leetcode 263
给你一个整数 n ，请你判断 n 是否为 丑数 。如果是，返回 true ；否则，返回 false 。丑数 就是只包含质因数 2、3 和/或 5 的正整数。

分析：
根据题目定义，0 和负数一定不是丑数。然后判断 n 是否是丑数，我们可以对 n 反复除以 2，3，5 直到 n 不包含其他质因数，n 就是丑数，否则不是。

代码：

class Solution {
    public boolean isUgly(int n) {
        if (n <= 0) {
            return false;
        }
        int[] factors = {2, 3, 5};
        for (int factor : factors) {
            while (n % factor == 0) {
                n /= factor;
            }
        }
        return n == 1;
    }
}

DAY 09

选择题

1. 访问权限控制从最大权限到最小权限依次为：public、包访问权限、protected 和 private。
   答：错误
   解析：
   从大到小依次是：
   · public 共有的，可以被所有其他类所访问
   · protected 受保护的，可以被自身、同包的类、子类所访问
   · default 默认的（不写），可以被自身、同包的类所访问
   · private 私有的，只能被自身访问和修改。

2. 有如下代码：请写出程序的输出结果。
   A：432
   B：531
   C：421
   D：523

public class Test
{
    public static void main(String[] args)
    {
        int x = 0;
        int y = 0;
        int k = 0;
        for (int z = 0; z < 5; z++) {
            if ((++x > 2) && (++y > 2) && (k++ > 2))
            {
                x++;
                ++y;
                k++;
            }
        }
        System.out.println(x + ”” +y + ”” +k);
    }
}

答：B
解析：
这题我们要注意 && 运算符，它有短路的效果，如果左边的表达式结果为 false 则不会对右边的表达式进行判断。对于该题 z、x、y、k的情况如下：
z x y k
0 1 0 0
1 2 0 0
2 3 1 0
3 4 2 0
4 5 3 1
执行完后，z++ 为 5，不满足条件，跳出循环，最后结果为 531

3. Java 的跨平台特性是指它的源代码可以在多个平台运行。
   答：错误
   解析：
   Java 的跨平台特性是因为 JVM（Java 虚拟机）的存在，它可以执行 .class 字节码文件。而 JVM 可以存在于不同的系统平台中。

4. BufferedReader 的父类是以下哪个？
   A：FilterReader
   B：InputStreamReader
   C：PopedReader
   D：Reader
   答：D
   解析：
   （借用牛客大佬的图）
   

5. 如果一个list初始化为{5，3，1}，执行以下代码后，其结果为？
   A：[5, 3, 1, 6]
   B：[4, 3, 1, 6]
   C：[4, 3, 6]
   D：[5, 3, 6]

nums.add(6);
nums.add(0,4);
nums.remove(1);

答：B
解析：
第一行代码，往后边加一个元素 6，结果 {5, 3, 1, 6}
第二行代码，在第 0 位置添加一个新元素 4，注意并不覆盖原本的元素，俗话说就是向后挤，结果 {4, 5, 3, 1, 6}
第三行代码，移除第 1 位置的元素，结果 {4, 3, 1, 6}

6. 建立 Statement 对象的作用是？
   A：连接数据库
   B：声明数据库
   C：执行 SQL 语句
   D：保存查询结果
   答：C
   解析：
   Statement 对象用于执行不带参数的简单 SQL 语句。

7. 关于抽象类与最终类，下列说法错误的是？
   A：抽象类能被继承，最终类只能被实例化
   B：抽象类和最终类都可以被声明使用
   C：抽象类中可以没有抽象方法，最终类中可以没有最终方法。
   D：抽象类和最终类被继承时，方法可以被子类覆盖
   答：D
   解析：
   最终类就是被 final 修饰的类，则该类不可以被继承；最终方法就是被 final 修饰的方法，则该方法不能被重写。

8. 默认类型等价表示是哪一项？
   A：public String NAME=“default”;
   B：public static String NAME=“default”;
   C：public static final String NAME=“default”;
   D：private String NAME=“default”;

public interface IService {String NAME="default";}

答：C
解析：
接口中的变量默认是 public static final 的，方法默认是 public abstract 的。

9. transient 变量和下面哪一项有关？
   A：Cloneable
   B：Serializable
   C：Runnable
   D： Comparable
   答： B
   解析：
   和序列化有关，这是一个空接口，起标记作用，具体的序列化由ObjectOutputStream和ObjectInputStream完成。transient 修饰的变量不能被序列化，static变量不管加没加transient都不可以被序列化。

10. Java 创建对象的说法正确的有？
    A：用 new 语句创建对象，是最常见的创建对象方法。
    B：运用反射手段，调用 java.lang.Class 或者 java.lang.reflect.Constructor 类的 newInstance() 实力方法。
    C：调用对象的 clone() 方法。
    D：运用反序列化手段，调用 java.io.ObjectInputStream 对象的 readObject() 方法。
    答：ABCD
    解析：
    Java 中创建对象的方法一共有五种，如下：
    · 使用 new 关键字，例：ObjectName obj = new ObjectName();
    · 使用反射的 Class 类的 newInstance() 方法，例：ObjectName obj = ObjectName.class.newInstance();
    · 使用反射的 Constructor 类的 newInstance() 方法，例：ObjectName obj = ObjectName.class.getConstructor.newInstance();
    · 使用对象克隆 clone() 方法，例：ObjectName obj = obj.clone();
    · 使用反序列化的 readObject() 方法，例：try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }

编程题

leetcode 1078
给出第一个词 first 和第二个词 second，考虑在某些文本 text 中可能以 “first second third” 形式出现的情况，其中 second 紧随 first 出现，third 紧随 second 出现。对于每种这样的情况，将第三个词 “third” 添加到答案中，并返回答案。

示例：
输入：text = “we will we will rock you”, first = “we”, second = “will”
输出：[“we”,“rock”]

分析：
首先，我们将 text 按空格分割成一个单词数组，然后遍历该数组并进行判断，如果一个单词的前两个单词按顺序分别与 first、second 相同，则将其加入结果中。这里使用了 ArrayList 进行存储结果，最后将其中的元素重新存入一个 String 类型的数组中进行返回即可。

代码：

class Solution {
    public String[] findOcurrences(String text, String first, String second) {
    	//将text按空格分割后放入如下数组
        String[] strs1 = text.split(" ");
        //创建一个 ArrayList 存放符合要求的结果
        List<String> list = new ArrayList<String>();
        for (int i = 2; i < strs1.length; i++) {
            if (strs1[i - 2].equals(first) && strs1[i - 1].equals(second)) {
                list.add(strs1[i]);
            }
        }
        //新建一个数组，将 ArrayList 中的结果赋值过来，并返回
        String[] strs2 = new String[list.size()];
        for (int i = 0; i < strs2.length; i++) {
            strs2[i] = list.get(i);
        }
        return strs2;
    }
}

DAY 10

选择题

1. 有关线程的叙述正确的是？
   A：可以获得对任何对象的互斥锁定。
   B：通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定。
   C：线程通过使用synchronized关键字可获得对象的互斥锁定。
   D：线程的创建只能通过继承Thread类来实现。
   答：C
   解析：
   采用 synchronized 修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。每个对象都有一个 monitor (锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

2. 假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？
   A：System.out.println(a.i);
   B：a.method1();
   C：A.method1();
   D：A.method2();

public class A
{
    public int i;
    static String s;
    void method1(){}
    static void method2(){}
}

答：C
解析：
静态成员和静态方法可以直接用 类名. 进行调用；其他的成员和方法需要进行实例化成为对象之后，由对象调用。

3. Java表达式"13 & 17"的结果是什么?
   A：30
   B：13
   C：17
   D：1
   答：D
   解析：
   & 是位与运算符，将两个数字化成二进制数进行位运算，全为1则为1，否则为0；
   13：00000000 00000000 00000000 00001101
   17：00000000 00000000 00000000 00010001
   得: 00000000 00000000 00000000 00000001
   即为1

4. 以下是java concurrent包下的4个类，选出差别最大的一个？
   A：Semaphore
   B：ReentrantLock
   C：Future
   D：CountDownLatch
   答：C
   解析：
   暂无

5. 下列说法正确的是？
   A：volatile,synchronized 都可以修改变量，方法以及代码块
   B：volatile,synchronized 都可以修改变量，方法以及代码块
   C：volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性
   D：volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性
   答：C
   解析：
   暂无

6. JavaWEB中有一个类，当会话种绑定了属性或者删除了属性时，他会得到通知，这个类是？
   A：HttpSessionAttributeListener
   B：HttpSessionBindingListener
   C：HttpSessionObjectListener
   D：HttpSessionListener
   E：HttpSession
   F：HttpSessionActivationListener
   答：A
   解析：
   暂无

7. 以下代码可以使用的修饰符是？
   A：final
   B：static
   C：abstract
   D：public

public interface Status {
 /*INSERT CODE HERE*/  int MY_VALUE=10;
}

答：ABD
解析：
接口中的变量默认是 public static final 的，方法默认是 public abstract 的。

8. 以下 json 格式数据，错误的是？
   A：{company：4399}
   B：{“company”:{“name”:[4399,4399,4399]}}
   C：{[4399,4399,4399]}
   D：{“company”:[4399,4399,4399]}
   E：{“company”:{“name”:4399}}
   答：AC
   解析：
   暂无

9. 关于抽象类与接口，下列说法正确的有？
   A：优先选用接口，尽量少用抽象类
   B：抽象类可以被声明使用，接口不可以被声明使用
   C：抽象类和接口都不能被实例化。
   D：以上说法都不对
   答：AC
   解析：
   暂无

10. 以下哪几种方式可用来实现线程间通知和唤醒？
    A：Object.wait/notify/notifyAll
    B：ReentrantLock.wait/notify/notifyAll
    C：Condition.await/signal/signalAll
    D：Thread.wait/notify/notifyAll
    答：AC
    解析：
    暂无

编程题

leetcode 217
给定一个整数数组，判断是否存在重复元素。如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

示例：
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

分析：
方法一：
首先，我们对数组进行排序，这样的话如果存在重复的元素，它们是相邻的；
然后，遍历数组，让当前元素和它的前一个元素进行比较，如果存在两个相邻元素相同的，则存在重复元素，返回 true，反之返回 false 。

代码：

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        for (int i = 1; i < nums.length; i++) {
            if (nums[i - 1] == nums[i]) {
                return true;
            }
        }
        return false;
    }
}

方法二：
首先，我们创建一个哈希表，利用哈希表的特性；
然后，将数组里面的元素插入到哈希表中，如果插入某个元素时发现该元素已经存在于哈希表之中，则说明存在重复元素。

代码：

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        for (int num : nums) {
            if (!set.add(num)) {
                return true;
            }
        }
        return false;
    }
}