每日一练（2）

最新推荐文章于 2022-04-16 21:04:29 发布

~JORDAN~

最新推荐文章于 2022-04-16 21:04:29 发布

阅读量1.1k

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/JORDANHCH/article/details/122200843

版权

DAY 11

选择题

假设 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
解析：
静态成员和静态方法可以直接用类名. 进行调用；其他的成员和方法需要进行实例化成为对象之后，由对象调用。

下面哪个选项没有实现 java.util.Map 接口?
A：Hashtable
B：HashMap
C：Vector
D：IdentityHashMap
答：C
解析：
Hashtable、HashMap、IdentityHashMap 都实现了 Map 接口，其中 Hashtable 和 HashMap 的区别是一个是线程安全的，一个是线程不安全的。Vector 是实现了 List 接口，是一个线程安全的 List 。
有如下 4 条语句，以下输出结果为 false 的是？
A：System.out.println(i01== i02);
B：System.out.println(i01== i03);
C：System.out.println(i03== i04);
D：System.out.println(i02== i04);

Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);

答：C
解析：
行一：由于 59 在 -128 ~ 127 内，所以在自动装箱的时候，会返回IntegerCache[59 - (-128)];
行三：同行一
行四：因为有 new 关键字，所以开辟了一块新内存放置值为 59 的 Integer 对象。

如下代码的结果是什么？
A：Base
B：BaseBase
C：编译失败
D：代码运行但没有输出
E：代码运行但没有输出

class Base {
    Base() {
    System.out.print("Base");
    }
}
public class Alpha extends Base {
    public static void main( String[] args ) {
        new Alpha();
        //调用父类无参的构造方法
        new Base();
    }
}

答：B
解析：
在执行 new Alpha(); 时，会先执行父类的构造方法，再执行相应子类的构造方法，所以此处会先打印 Base ，在执行 new Base(); 时，会直接调用无参构造打印 Base，结果为 BaseBase 。

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
以下代码执行后输出的结果是？
A：blockAblockBblockA
B：blockAblockAblockB
C：blockBblockBblockA
D：blockBblockAblockB

public class Test
{
    public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB");
    }
    public static void main(String[] args)
    {
        Test t2 = new Test();
    }
}

答：A
解析：
执行先后顺序：
静态域：首先执行静态变量 public static Test t1 = new Test(); 创建了 Test 对象，执行构造块输出 blockA ；然后执行静态代码块，输出 blockB 。
主函数：Test t2 = new Test(); 创建 Test 对象，执行构造块，输出 blockA 。

下面哪些选项是正确的？
A：>>是算术右移操作符
B：>>是逻辑右移操作符
C：>>>是算术右移操作符
D：>>>是逻辑右移操作符
答：AD
解析：
前者右移，高位补符号位；后者右移，高位补 0
jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？
A：抽象类可以有构造方法，接口中不能有构造方法
B：抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法
C：一个类可以实现多个接口，但只能继承一个抽象类
D：接口中可以有普通成员变量，抽象类中没有普通成员变量
答：BD
解析：
· 抽象类：抽象类中可以有构造方法，可以存在普通属性、方法、静态属性和方法，也可以存在抽象方法。如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
· 接口：在接口中只有方法的声明，没有方法体；接口中只有常量，因为变量默认会加上 public static final 。接口中的方法，被 public 来修饰，并且没有构造方法，也不能实例化接口的对象。接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法，则实现类定义为抽象类。
有关线程的叙述正确的是？
A：可以获得对任何对象的互斥锁定
B：通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定
C：线程通过使用synchronized关键字可获得对象的互斥锁定
D：线程调度算法是平台独立的
答：CD
解析：
暂无
以下语句返回值为 true 的是？

A：a1== a2
B：d1== d2
C：b1== b2
D：c1== c2
答：AB
解析：
17 在 -128 ~ 127 之间，故执行的是 valueOf() 方法，所以 a1 和 a2 指向的是同一个对象。其他的都是 new 出来的对象，显然地址都不同。另外，int 类型与 Integer 类型比较时，先将 Integer 拆箱，再比较值，所以 d1 == d2 也为 true 。

编程题

leetcode 242
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例：
输入: s = “anagram”, t = “nagaram”
输出: true
输入: s = “anagram”, t = “nagaram”
输出: true

分析：
特殊情况：如果给的两个字符串长度不等，则一定不是字母异位词。
方法一：
首先，我们将给定的两个字符串转换成字符数组；
然后，给两个字符数组进行排序，排序完后比较两个数组内容是否相同，如果相同则返回 true ，反之返回 false 。

代码：

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        char[] arr1 = s.toCharArray();
        char[] arr2 = t.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        return Arrays.equals(arr1, arr2);
    }
}

方法二：
首先，维护一个长度为 26 的频次数组 table ，先遍历记录字符串 s 中字符出现的频次，然后遍历字符串 t ，减去 table 中对应的频次，如果出现 table[i] < 0 ，则说明 t 中包含一个不在 s 中的额外字符，返回 false 。

代码：

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        int[] table = new int[26];
        for (int i = 0; i < s.length(); i++) {
            table[s.charAt(i) - 'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            table[t.charAt(i) - 'a']--;
            if (table[t.charAt(i) - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
}

DAY 12

选择题

现有一变量声明为 boolean aa; 下面赋值语句中正确的是？
A：aa=false;
B：aa=False;
C：aa=“true”;
D：aa=0;
答：A
解析：
Java 中 boolean 类型的值只有 false 和 true，关键字都是小写。
下列说法哪个正确？
A：不需要定义类，就能创建对象
B：对象中必须有数据域和方法
C：数据域可以是基本类型变量，也可以是一个对象
D：数据域必须是基本类型变量
答：C
解析：
必须定义类后，才能创建对象；对象中有无数据域和方法，取决于它所属的类；数据域不一定是基本类型，也可以是引用类型。
已知如下类定义，如下哪句可以正确地加入子类中？
A：private void fun( int n ){ //…}
B：void fun ( int n ){ //… }
C：protected void fun ( int n ) { //… }
D：public void fun ( int n ) { //… }

class Base {  
	public Base (){ 
 	//... 
 	}  
 	public Base ( int m ){ 
 	//... 
 	}  
 	public void fun( int n ){ 
 	//... 
 	} 
}  
public class Child extends Base{  
 	// member methods  
}

答：D
解析：
该题考查方法的重写，遵循两同两小一大原则：
子类方法名、参数类型与父类相同；
子类方法返回值类型小于等于父类方法返回类型；
子类方法抛出异常范围小于父类方法抛出异常范围；
子类方法访问权限大于父类方法访问权限。

下面这三条语句的输出结果分别是？
A：is 1005, 1005 is, is 1005
B：is 105, 105 is, is 105
C：is 1005, 1005 is, is 105
D：is 1005, 105 is, is 105

System.out.println(“is ”+ 100 + 5);
System.out.println(100 + 5 +“ is”);
System.out.println(“is ”+ (100 + 5));

答：D
解析：
行一：先是 "is " 则后面的内容会以字符串的形式进行拼接。
行二：先对 100 + 5 进行运算，然后与 “ is” 拼接。
行三：先算括号内，然后进行字符串拼接。

以下代码的输出的正确结果是？
A：24
B：16
C：15
D：8

public class Test {
    public static void main(String args[]) {
        String s = "祝你考出好成绩！";
        System.out.println(s.length());
    }
}

答：D
解析：
length() 方法是获取字符串长度，显然为 8 。

下列哪一个方法你认为是新线程开始执行的点，也就是从该点开始线程n被执行？
A：public void start()
B：public void run()
C：public void int()
D：public static void main(String args[])
E：public void runnable()
答：B
解析：
start() 方法是启动一个线程，此时线程处于就绪状态，还未执行；run() 方法才是线程开始执行的点。
下面哪一项不是加载驱动程序的方法？
A：通过DriverManager.getConnection方法加载
B：调用方法 Class.forName
C：通过添加系统的jdbc.drivers属性
D：通过registerDriver方法注册
答：A
解析：
DriverManager.getConnection() 方法返回一个 Connection 对象，是用来获取连接的。
String s=null; 下面哪个代码片段可能会抛出NullPointerException？
A：if((s!=null)&(s.length()>0))
B：if((s!=null)&&(s.length()>0))
C：if((s==null)|(s.length()0))
D：if((snull)||(s.length()==0))
答：AC
解析：
首先，s = null; 因此只要调用了 s.length() 都会抛出空指针异常。
&& 和 || 运算符具有短路效果，前者如果运算符左边为 false ，右边的直接不执行了；后者如果运算符左边为 true，右边的直接不执行了。
& 和 | 运算符则不具备短路功能，会检查每一个条件。
下列可作为java语言标识符的是？
A：a1
B：$1
C：_ 1
D：11
答：ABC
解析：
Java标识符由数字，字母和下划线，美元符号组成。在Java中是区分大小写的，而且还要求首位不能是数字。最重要的是，Java关键字不能当作Java标识符。
下面有关 JAVA 异常类的描述,说法正确的有？
A：异常的继承结构:基类为 Throwable,Error 和 Exception 。实现 Throwable, RuntimeException 和 IOException 等继承 Exception
B：非 RuntimeException 一般是外部错误(不考虑Error的情况下),其可以在当前类被 try{}catch 语句块所捕获
C：Error 类体系描述了 Java 运行系统中的内部错误以及资源耗尽的情形,Error 不需要捕捉
D：RuntimeException 体系包括错误的类型转换、数组越界访问和试图访问空指针等等,必须被 try{}catch 语句块所捕获
答：ABC
解析：
（借用牛客大佬的解析和图片）

· Exception（异常） :是程序本身可以处理的异常。
· Error（错误）: 是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。
· 检查异常（编译器要求必须处置的异常）：除了Error，RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
· 非检查异常(编译器不要求处置的异常): 包括运行时异常（RuntimeException与其子类）和错误（Error）。

编程题

leetcode 268
给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数。

示例：
输入：nums = [3,0,1]
输出：2
解释：n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2 是丢失的数字，因为它没有出现在 nums 中。

输入：nums = [0,1]
输出：2
解释：n = 2，因为有 2 个数字，所以所有的数字都在范围 [0,2] 内。2 是丢失的数字，因为它没有出现在 nums 中。

分析：
方法一：
首先，我们先对给定的数组进行排序；
然后，让排好序的数组中的元素与其对应的下标进行比较，如果存在不同的，则返回该处的下标值，即为缺失的元素。如果全都相同，则返回数组的长度，也就是 0 ~ n 缺少第 n 个数组。

代码：

class Solution {
    public int missingNumber(int[] nums) {
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (i != nums[i]) {
                return i;
            }
        }
        return nums.length;
    }
}

方法二：
首先，创建一个哈希表，利用哈希表的特点；
然后，将给定的数组里的元素全部放入哈希表中，然后从 0 ~ n（n 为数组长度）进行判断是否存在于哈希表当中，不存在的元素即为缺失的数字。

代码：

class Solution {
    public int missingNumber(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < nums.length; i++) {
            set.add(nums[i]);
        }
        for (int i = 0; i <= nums.length; i++) {
            if (!set.contains(i)) {
                return i;
            }
        }
        return -1;
    }
}

DAY 13

选择题

Java 中所有类的父级是？
A：Father
B：Dang
C：Exception
D：Object
答：D
解析：
Java 中 Object 是所有类的父类，所有类的对象都是 Class 的实例。
下面关于依赖注入(DI)的说法不正确的是？
A：只有通过Spring才能实现依赖注入(DI)
B：依赖注入的主要目的是解耦合
C：常见的依赖注入方式有Setter和构造方法
答：A
解析：
依赖注入是一种思想，或者说是一种设计模式，在java中是通过反射机制实现，与具体框架无关。
对于子类的构造函数说明，下列叙述中错误的是？
A：子类不能继承父类的无参构造函数。
B：子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。
C：在创建子类的对象时，若不含带参构造函数，将先执行父类的无参构造函数，然后再执行自己的无参构造函数。
D：子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。
答：D
解析：
构造函数不能被继承，构造方法只能被显式或隐式调用。
以下哪个式子有可能在某个进制下成立？
A：1314=204
B：1234=568
C：14*14=140
D：1+1=3
答：A
解析：
若需要定义一个类，下列哪些修饰符是允许被使用的？
A：static
B：package
C：private
D：public
答：ACD
解析：
该题说要定义一个类，并没有说是普通类或者内部类等。package 是包关键字。
下面有关Java的说法正确的是？
A：一个类可以实现多个接口
B：抽象类必须有抽象方法
C：protected成员在子类可见性可以修改
D：通过super可以调用父类构造函数
E：final的成员方法实现中只能读取类的成员变量
F：String是不可修改的，且java运行环境中对string对象有一个常量池保存
答：ACDF
解析：
抽象类可以没有抽象方法，但抽象方法一定存在于抽象类当中。
以下 json 格式数据，错误的是？
A：{company：4399}
B：{“company”:{“name”:[4399,4399,4399]}}
C：{[4399,4399,4399]}
D：{“company”:[4399,4399,4399]}
E：{“company”:{“name”:4399}}
答：AC
解析：
属性必须加双引号；必须由一组有序的键值对组成。
实现或继承了Collection接口的是？
A：Map
B：List
C：Vector
D：Iterator
E：Set
答：BCE
解析：
这个题说一下 Vector 它实现了 List 接口，而 List 接口继承 Collection 接口。
Java7特性中,abstract class和interface有什么区别？
A：抽象类可以有构造方法，接口中不能有构造方法
B：抽象类中可以有普通成员变量，接口中没有普通成员变量
C：抽象类中不可以包含静态方法，接口中可以包含静态方法
D：一个类可以实现多个接口，但只能继承一个抽象类。
答：ABD
解析：
· 抽象类：抽象类中可以有构造方法，可以存在普通属性、方法、静态属性和方法，也可以存在抽象方法。如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
· 接口：在接口中只有方法的声明，没有方法体；接口中只有常量，因为变量默认会加上 public static final 。接口中的方法，被 public 来修饰，并且没有构造方法，也不能实例化接口的对象。接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法，则实现类定义为抽象类。
JDK提供的用于并发编程的同步器有哪些？
A：Semaphore
B：CyclicBarrier
C：CountDownLatch
D：Counter
答：ABC
解析：
同步器是一些使线程能够等待另一个线程的对象，允许它们协调动作。最常用的同步器是 CountDownLatch 和 Semaphore ，不常用的是 Barrier 和 Exchanger 。

编程题

leetcode 268
给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标从 0 开始计数，对于所有 0 <= i < n 的 i ，满足下述所有要求：
ans[i] = = nums[i]
ans[i + n] == nums[i]
具体而言，ans 由两个 nums 数组串联形成。返回数组 ans 。

示例：
输入：nums = [1,2,1]
输出：[1,2,1,1,2,1]

分析：
首先，我们创建一个长度为 2n 的数组 ans，
然后，把 nums 中的值依次赋值给 ans[0] ~ ans[n - 1] 和 ans[n] ~ ans[2n - 1] ，返回 ans。

代码：

class Solution {
    public int[] getConcatenation(int[] nums) {
        int[] ans = new int[2 * nums.length];
        for (int i = 0; i < nums.length; i++) {
            ans[i + nums.length] = ans[i] = nums[i];
        }
        return ans;
    }
}

DAY 14

选择题

关于容器下面说法正确的是？
A：列表(List)和集合(Set)存放的元素都是可重复的。
B：列表(List)和集合(Set)存放的元素都是不可重复的。
C：映射(Map)<key,value>中key是可以重复的。
D：映射(Map)<key,value>中value是可以重复的。
答：D
解析：
List 的元素是有序、可重复的；Set 的元素是无序、不可重复的。map 使用的是键值对存放，可一对多，key 不重复，value 可重复。
以下程序的运行结果是？
A：666
B：667
C：677
D：676
答：B

public class Increment
{
    public static void main(String args[])
    {
        int a;
        a = 6;
        System.out.print(a);
        System.out.print(a++);
        System.out.print(a);
    }
}

解析：
该题中，a++ 可以理解为访问 a 之后在对 a 进行加一操作。

在Java中，以下关于方法重载和方法重写描述正确的是？
A：方法重载和方法的重写实现的功能相同
B：方法重载出现在父子关系中，方法重写是在同一类中
C：方法重载的返回值类型必须一致，参数项必须不同
D：方法重写的返回值类型必须相同或相容。（或是其子类）
答：D
解析：
· 重载：必须是同一个类；方法名一样；参数列表不同（可以是类型不同，也可以是参数数量不同）。
· 重写：遵循两同两小一大原则，方法名相同，参数类型相同；子类方法返回类型小于等于父类方法返回类型；子类方法抛出异常范围小于等于父类方法抛出异常范围；子类访问权限大于等于父类方法访问权限。
以下选项中，合法的赋值语句是？
A：a > 1;
B：i++;
C：a = a + 1 = 5;
D：y = int (i);
答：B
解析：
D 选项应写成 y = (int) i;
设int x=1,float y=2,则表达式x/y的值是？
A：0
B：1
C：2
D：以上都不是
答：D
解析：
不同类型运算时以高精度的为准。
关于ASCII码和ANSI码，以下说法不正确的是？
A：标准ASCII只使用7个bit
B：在简体中文的Windows系统中，ANSI就是GB2312
C：ASCII码是ANSI码的子集
D：ASCII码都是可打印字符
答：D
解析：
假定Base b = new Derived(); 调用执行b.methodOne() 后，输出结果是什么？
A：ABDC
B：AB
C：ABCD
D：ABC

public class Base
{
   public void methodOne()
   {
      System.out.print("A");
      methodTwo();
   }
 
   public void methodTwo()
   {
      System.out.print("B");
   }
}
 
public class Derived extends Base
{
   public void methodOne()
   {
      super.methodOne();
      System.out.print("C");
   }
 
   public void methodTwo()
   {
      super.methodTwo();
      System.out.print("D");
   }
}

答：A
解析：
被子类重写的方法，不被 super 关键字调用都是调用子类方法。

以下哪些继承自 Collection 接口？
A：List
B：Set
C：Map
D：Array
答：AB
解析：
（借用牛客大佬的图）
以下关于JAVA语言异常处理描述正确的有？
A：throw关键字可以在方法上声明该方法要抛出的异常。
B：throws用于抛出异常对象。
C：try是用于检测被包住的语句块是否出现异常，如果有异常，则捕获异常，并执行catch语句。
D： finally语句块是不管有没有出现异常都要执行的内容。
E：在try块中不可以抛出异常
答：CD
解析：
Java语言中的异常处理包括声明异常、抛出异常、捕获异常和处理异常四个环节。throw 用于抛出异常；throws 关键字可以在方法上声明该方法要抛出的异常，然后在方法内部通过 throw 抛出异常对象。
try 是用于检测被包住的语句块是否出现异常，如果有异常，则抛出异常，并执行catch语句。cacth 用于捕获从try中抛出的异常并作出处理。finally 语句块是不管有没有出现异常都要执行的内容。
下面的Java赋值语句哪些是有错误的？
A：int i =1000;
B：float f = 45.0;
C：char s = ‘\u0639’;
D：Object o = ‘f’;
E：String s = “hello,world\0”;
F：Double d = 100;
答：BF
解析：
B 选项，小数后如果不加 f 后缀，默认是 double 类型。要强制转换类型，不然报错。
F 选项，100 默认是 int 型，而 b 是引用数据类型包装类，但是只有对应类型的数据类型和包装类才能自动装箱拆箱。

编程题

leetcode 2114
一个句子由一些单词以及它们之间的单个空格组成，句子的开头和结尾不会有多余空格。给你一个字符串数组 sentences ，其中 sentences[i] 表示单个句子。请你返回单个句子里单词的最多数目。

示例：
输入：sentences = [“alice and bob love leetcode”, “i think so too”, “this is great thanks very much”]
输出：6
输入：sentences = [“please wait”, “continue to fight”, “continue to win”]
输出：3

分析：
我们分析该题，单词之间由单个空格组成，句子的开头和结尾不会有多余空格，那么单词的数量就等于空格数加一。

代码：

class Solution {
    public int mostWordsFound(String[] sentences) {
        int count = 0;
        int temp = 1;
        for (int i = 0; i < sentences.length; i++) {
            for (int j = 0; j < sentences[i].length(); j++) {
                if (sentences[i].charAt(j) == ' ') {
                    temp++;
                }
            }
            if (count < temp) {
                count = temp;
            }
            temp = 1;
        }
        return count;
    }
}

DAY 15

选择题

下列哪个语句语法正确？
A：byte y = 11; byte x = y +y;
B：String x = new Object();
C：Object x = new String(“Hellow”);
D：int a [11] = new int [11];
答：C
解析：
A 选项，前半句没有问题，但是后半句中，byte 会转换成 int 类型进行运算，结果也是 int 类型，因此应该这样写：byte x = (int) (y + y);
B 选项，Object 是 String 的父类，不能这样写。
C 选项，向上转型。
D 选项，在声明数组变量的时候不需要指定容量。
一个类可以有多个不同名的构造函数（不考虑内部类的情况）。
答：错误
解析：
构造函数名必须和类名相同。
BufferedReader的父类是以下哪个？
A：FilterReader
B：InputStreamReader
C：PipedReader
D：Reader
答：D
解析：
（借用牛客大佬的图）
根据下面的程序代码，哪些选项的值返回 true？
A：a = = b
B：s == a
C：b = = c
D：a.equals(s)

public class Square {  
    long width;  
    public Square(long l) {   
        width = l;  
    }  
    public static void main(String arg[]) {   
        Square a, b, c;  
        a = new Square(42L);   
        b = new Square(42L);   
        c = b;   
        long s = 42L;  
    } 
}

答：C
解析：
a b 分别是 new 出来的对象，a s 不是同一种类型，b c 是同一个对象的引用，该类并没有重写 equals 方法，其实本质也是 == 。

当你编译和运行下面的代码时，会出现下面选项中的哪种情况？
A：编译时错误
B：编译通过并输出结果false
C：编译通过并输出结果true
D：编译通过并输出结果null

public class Pvf{
    static boolean Paddy;
    public static void main(String args[]){
        System.out.println(Paddy);
    }
}

答：B
解析：
boolean 类型的默认值是 false 。

下列语句哪一个是不正确的？
A：Log4j支持按分钟为间隔生成新的日志文件
B：Log4j是一个打印日志用的组件
C：Log4j支持按年为间隔生成新的日志文件
D：Log4j的日志打印级别可以在运行时重新设置
答：D
解析：
暂无
以下哪个事件会导致线程销毁？
A：调用方法sleep()
B：调用方法wait()
C：start()方法的执行结束
D：run()方法的执行结束
答：D
解析：
run() 方法是线程的具体逻辑方法，执行完，线程就结束。
以下程序执行的结果是？
A：ZYXX
B：ZYXY
C：YXYZ
D：XYZX

class X{
    Y y=new Y();
    public X(){
        System.out.print("X");
    }
}
class Y{
    public Y(){
        System.out.print("Y");
    }
}
public class Z extends X{
    Y y=new Y();
    public Z(){
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

答：C
解析：
· 初始化父类中的静态成员变量和静态代码块
· 初始化子类中的静态成员变量和静态代码块
· 初始化父类的普通成员变量和构造代码块(按次序)，再执行父类的构造方法
· 初始化子类的普通成员变量和构造代码块(按次序)，再执行子类的构造方法

下面为true的是？
A：(i = = l)
B：(i == d)
C：(l = = d)
D： i.equals(d)
E：d.equals(l)
F：i.equals(l)
G：l.equals(42L)

Integer i = 42;
Long l = 42l;
Double d = 42.0;

答：G
解析：
包装类的 “==” 运算在不遇到算术运算的情况下不会自动拆箱
包装类的equals()方法不处理数据转型

下面关于Applet的说法是正确的是？
A：Applet可以在带有Java解释器的浏览器中运行
B：Applet类必须继承java.applet.Applet
C：Applet可以访问本地文件
D：Applet是Object类的子类
答：ABCD
解析：
暂无

编程题

leetcode 1480
给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。
请返回 nums 的动态和。

示例：
输入：nums = [1,2,3,4]
输出：[1,3,6,10]
输入：nums = [1,1,1,1,1]
输出：[1,2,3,4,5]

分析：
原地修改，让当前位置对应的值等于原本当前位置对应的值加上前一个位置对应的值。

代码：

class Solution {
    public int[] runningSum(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            nums[i] += nums[i - 1];
        }
        return nums;
    }
}

DAY 16

选择题

执行下列程序的输出结果为？
A：s1 = = s2
s1 not equals s2
B：s1 == s2
s1 equals s2
C：s1 != s2
s1 not equals s2
D：s1 != s2
s1 equals s2

public class Test {
    public static void main(String[] args) {
         String s1 = "HelloWorld";
         String s2 = new String("HelloWorld");
         if (s1 == s2) {
             System.out.println("s1 == s2");
         } else {
             System.out.println("s1 != s2");
         }
         if (s1.equals(s2)) {
             System.out.println("s1 equals s2");
         } else {
             System.out.println("s1 not equals s2");
         }
     }
 }

答：D
解析：
“==” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
Object 中的equals() 与 “= =” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。

以下定义一维数组的语句中，正确的是？
A：int a [10];
B：int a []=new [10];
C：int a []=new int [5]{1,2,3,4,5};
D：int a []={1,2,3,4,5};
答：D
解析：
Java 一维数组有两种初始化方法

//静态初始化
int array[] = new int[] {1,2,3,4,5};
//或者
int array[] = {1,2,3,4,5};

//动态初始化
int array[] = new int[5];
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 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
解析：
行一：在 list 最后添加元素 6，结果 [5,3,1,6]
行二：在下标为 0 的位置加一个元素 4，结果 [4,5,3,1,6]
行三：移除下标为 1 的位置的元素，结果 [4,3,1,6]

在 Java 中，属于整数类型变量的是?
A：single
B：double
C：byte
D：char
答：C
解析：
这题不说了。
默认类型等价表示是哪一项？
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 的。

关于继承和实现说法正确的是？
A：类可以实现多个接口，接口可以继承（或扩展）多个接口
B：类可以实现多个接口，接口不能继承（或扩展）多个接口
C：类和接口都可以实现多个接口
D：类和接口都不可以实现多个接口
答：A
解析：
· 类与类：单继承，可以多层继承；
· 类与接口：可单实现，可多实现；
· 接口与接口：可单继承，可多继承
顺序执行下列程序语句后，则b的值是？
A：Hello
B：Hel
C：He
D：null

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

答：C
解析：
substring() 方法返回一个从包含开始到结尾(不含结尾，左闭右开)的子字符串。

下列哪个说法是正确的？
A：ConcurrentHashMap使用synchronized关键字保证线程安全
B：HashMap实现了Collction接口
C：Array.asList方法返回java.util.ArrayList对象
D：SimpleDateFormat是线程不安全的
答：D
解析：
暂无
关于 Socket 通信编程，以下描述正确的是？
A：客户端通过new ServerSocket()创建TCP连接对象
B：客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
C：客户端通过new Socket()方法创建通信的Socket对象
D：服务器端通过new ServerSocket()创建通信的Socket对象
答：C
解析：
暂无
关于equals和hashCode描述正确的是？
A：两个obj，如果equals()相等，hashCode()一定相等（符合代码规范的情况下）
B：两个obj，如果hashCode()相等，equals()不一定相等
C：两个不同的obj， hashCode()可能相等
D：其他都不对
答：ABC
解析：
“==”：作用是判断两个对象的地址是否相等，即，判断两个对象是不是同一个对象，如果是基本数据类型，则比较的是值是否相等。
“equal”：作用是判断两个对象是否相等，但一般有两种使用情况
· 类没有覆盖 equals() 方法,则相当于通过 “= =” 比较
· 类覆盖 equals() 方法，一般，我们都通过 equals() 方法来比较两个对象的内容是否相等，相等则返回 true，如 String 类。
地址比较是通过计算对象的哈希值来比较的，hashcode 属于 Object 的本地方法，对象相等（地址相等），hashcode 相等，对象不相等，hashcode() 可能相等，哈希冲突。

编程题

leetcode 78
给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。你可以按任意顺序返回解集。

示例：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
输入：nums = [0]
输出：[[],[0]]

分析：
由题可知，若数组的长度为 n 则它的子集数有 2 的 n 次方个。所以，结果集的大小可以用 1 << n(n 为数组程度) 来表示。
首先，创建结果集，然后创建外层 for 循环，用来给结果集添加子集，然后创建子集集合，创建内层 for 循环，如果满足 (i & (1 << j)) != 0 （对应位置位与出来若不为零则该位置的元素应该存在于该子集中）则把对应 j 位置的元素加入该子集中；然后将该子集添入结果集中，最后返回结果集。

代码：

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        int len = nums.length; //用来记录数组的长度
    	int size = 1 << len;  //用来记录结果集的长度
    	List<List<Integer>> res = new ArrayList<>(size);
    	
    	for (int i = 0; i < size; i++) {
    		List<Integer> subset = new ArrayList<>(len);
    		for (int j = 0; j < len; j++) {
    			if ((i & (1 << j)) != 0) {
    				subset.add(nums[j]);
    			}
    		}
    		res.add(subset);
    	}
    	return res;
    }
}

DAY 17

选择题

在JAVA中，下列标识符合法的是？
A：3kyou
B：@163
C：name
D：while
答：C
解析：
Java 中合法的标识符，由数字、字母、下划线以及 $ 组成，不能以数字开头，不能是关键字，严格区分大小写。
下列哪个类的声明是正确的？
A：abstract final class HI{}
B：abstract private move(){}
C：protected private number;
D：public abstract class Car{}
答：D
解析：
A 选项，因为 final 是最终类，不能被继承；而 abstract 是抽象类，只能被继承。二者冲突了，同时只能存在一个。
B 选项，private 修饰符定义的属性及方法不能被子类实现，而抽象类的子类必须实现所有的抽象方法，冲突了。
C 选项，权限修饰符只能有一个，而且没有数据类型。
D 选项，正确。
在异常处理中，以下描述不正确的有？
A：try块不可以省略
B：可以使用多重catch块
C：finally块可以省略
D：catch块和finally块可以同时省略
答：D
解析：
try-catch 捕获异常；try-finally 清除异常；try-catch-finally 处理所有异常。三者选一即可。
针对下面的代码块,哪个equal为true？
A：s1 == s2
B：s1 = s2
C：s2 = = s3
D：都不正确

String s1 = "xiaopeng" ;
String s2 = "xiaopeng" ;
String s3 =new String (s1);

答：A
解析：
s1 创建的字符串已经放入常量池中，s2 直接引用常量池中的，s3 使用了 new 关键字，重新产生一个新的字符串。所以 s1 == s2，和 s3 不一样。

多重继承的概念在Java中实现是通过如下哪些？
I. 扩展两个或多个类
II. 扩展一个类并实现一个或多个接口。
III. 实现两个或更多接口。
A：只有I &II
B：只有II & III
C：只有III
D：都是
答：B
解析：
Java 只支持单继承，实现多重继承的方式有三种：直接实现多接口；扩展一个类后实现一个或多个接口；通过内部类去继承其他类。
关于Java以下描述正确的有？
A：native关键字表名修饰的方法是由其它非Java语言编写的
B：能够出现在import语句前的只有注释语句
C：接口中定义的方法只能是public
D：构造方法只能被修饰为public或者default
答：A
解析：
A 选项，native 是由调用本地方法库（如操作系统底层函数），可以由 C，C++ 实现。
B 选项，import 是用于导包语句，其前面可以出现声明包的语句 package
C 选项，接口方法的修饰符可以是：public，abstract，default，static（后两者需要{}）。
D 选项，构造方法可以用 private，protected，default，private。
jre 判断程序是否执行结束的标准是？
A：所有的前台线程执行完毕
B：所有的后台线程执行完毕
C：所有的线程执行完毕
D：和以上都无关
答：A
解析：
后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。
下列代码输出结果为？
A：动物可以移动
狗可以跑和走
狗可以吠叫
B：动物可以移动
动物可以移动
狗可以吠叫
C：运行错误
D：编译错误

class Animal{
    public void move(){
        System.out.println("动物可以移动");
    }
}
class Dog extends Animal{
    public void move(){
        System.out.println("狗可以跑和走");
    }
    public void bark(){
        System.out.println("狗可以吠叫");
    }
}
public class TestDog{
    public static void main(String args[]){
        Animal a = new Animal();
        Animal b = new Dog(); 
        a.move();
        b.move();
        b.bark();
    }
}

答：D
解析：
编译看左边，运行看右边。父类型引用指向子类型对象，无法调用只在子类型里定义的方法。

问这个程序的输出结果？
A：Base SonB
B：Son SonB
C：Base Son SonB
D：编译不通过

class Base
{
    public void method()
    {
        System.out.println("Base");
    } 
}
class Son extends Base
{
    public void method()
    {
        System.out.println("Son");
    }
     
    public void methodB()
    {
        System.out.println("SonB");
    }
}
public class Test01
{
    public static void main(String[] args)
    {
        Base base = new Son();
        base.method();
        base.methodB();
    }
}

答：D
解析：
这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的
Base类中不存在methodB()方法，所以编译不通过。

java中下面哪些是Object类的方法？
A：notify()
B：notifyAll()
C：sleep()
D：wait()
答：ABD
解析：
Object 包含以下方法：

编程题

leetcode 13
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如，罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。

分析：
首先，我们创建一个方法，用来获取罗马数字对应的整数值，我们用 switch 语句进行获取。
然后，进行转换，循环遍历字符串的每一位，拿出每一位对应的整数值，由罗马数特点可知，如果 i 位置的值小于 i + 1 位置的值，则对应的值为右边的减去左边的，否则就是加上右边的值。
最后，返回结果。

代码：

class Solution {
    public int roman(char n) {
        switch(n) {
            case 'I': return 1;
            case 'V': return 5;
            case 'X': return 10;
            case 'L': return 50;
            case 'C': return 100;
            case 'D': return 500;
            case 'M': return 1000;
            default: return 0;
        }
    }
    public int romanToInt(String s) {
        int num = 0;
        int len = s.length();
        for (int i = 0; i <len; i++) {
            int val = roman(s.charAt(i));
            if (i < len - 1 && val < roman(s.charAt(i + 1))) {
                num -= val;
            } else {
                num += val;
            }
        }
        return num;
    }
}

DAY 18

选择题

面哪个描述正确?
A：程序中的注释越多，程序运行得越快。
B：int是java.lang包中可用的类的名称
C：类总是有一个构造函数（可能由java编译器自动提供）
D：实例变量名称只能包含字母和数字
答：C
解析：
A 选项，不说了，没意思！
B 选项，int 是 Java 的基本数据类型，并不是类。
D 选项，还可以有下划线、美元符。
假设 A 类有如下定义，设 a 是 A 类同一个包下的一个实例，下列语句调用哪个是错误的？
A：System.out.println(a.i)；
B：a.method1();
C：A.method1();
D：A.method2()

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

答：C
解析：
非静态方法只能通过实例对象来调用，不能直接通过类名调用。静态方法（static 修饰的）才能通过类名直接调用。

接口不能扩展（继承）多个接口。
答：错误
解析：
Java 中类是单继承、接口可以多继承。
假设num已经被创建为一个ArrayList对象，并且最初包含以下整数值：[0，0，4，2，5，0，3，0]。执行下面的方法numQuest(),最终的输出结果是什么？
A：[3, 5, 2, 4, 0, 0, 0, 0]
B：[0, 0, 0, 0, 4, 2, 5, 3]
C：[0, 0, 4, 2, 5, 0, 3, 0]
D：[0, 4, 2, 5, 3]

private List<Integer> nums;
 
//precondition: nums.size() > 0
//nums contains Integer objects
public void numQuest() {
    int k = 0;
    Integer zero = new Integer(0);
    while (k < nums.size()) {
        if (nums.get(k).equals(zero))
            nums.remove(k);
        k++;
    }
}

答：D
解析：
size = 8; k = 0 时：[0, 4, 2, 5, 0, 3, 0]
size = 7; k = 1 时：[0, 4, 2, 5, 0, 3, 0]
size = 7; k = 2 时：[0, 4, 2, 5, 0, 3, 0]
size = 7; k = 3 时：[0, 4, 2, 5, 0, 3, 0]
size = 7; k = 4 时：[0, 4, 2, 5, 3, 0]
size = 6; k = 5 时：[0, 4, 2, 5, 3]
size = 5; k = 6时：结束。

下面关于静态方法说明正确的是？
A：在静态方法中可用this来调用本类的类方法
B：在静态方法中调用本类的静态方法时可直接调用
C：在静态方法中只能调用本类中的静态方法
D：在静态方法中绝对不能调用实例方法
答：B
解析：
静态成员随着类的加载而加载，this 表示当前对象，所以 this 不能用于静态方法中；静态方法可以调用本类中的静态方法和静态变量。D 选项，可以通过对象调用。
下列说法正确的是？
A：在类方法中可用this来调用本类的类方法
B：在类方法中调用本类的类方法可直接调用
C：在类方法中只能调用本类的类方法
D：在类方法中绝对不能调用实例方法
答：B
解析：
同上题
对下面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
解析：
暂无

在java7中，下列不能做switch()的参数类型是？
A：int 型
B：枚举类型
C：字符串
D：浮点型
答：D
解析：
switch 语句后的控制表达式只能是 short、char、int、long 整数类型和枚举类型，不能是float，double 和 boolean 类型。String类型是java7开始支持。
下面哪个不属于HttpServletResponse接口完成的功能？
A：设置HTTP头标
B：设置cookie
C：读取路径信息
D：输出返回数据
答：C
解析：
request 读取路径信息。
Which lines of the following will produce an error?
A：Line 3 and Line 4
B：Line 1 only
C：Line 3 only
D：Line 4 only

byte a1 = 2, a2 = 4, a3;
short s = 16;
a2 = s;
a3 = a1 * a2;

答：A
解析：
short 类型转为 byte 类型出错
a1 * a2 结果为 int 类型，转为 byte 类型出错

编程题

leetcode 28
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。
说明：当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例：
输入：haystack = “hello”, needle = “ll”
输出：2
输入：haystack = “aaaaa”, needle = “bba”
输出：-1

分析：
暴力破解，我们可以让 needle 和 haystack 所有和 needle 同长度的字串进行匹配。

代码：

class Solution {
    public int strStr(String haystack, String needle) {
        int n = haystack.length(), m = needle.length();
        for (int i = 0; i + m <= n; i++) {
            boolean flag = true;
            for (int j = 0; j < m; j++) {
                if (haystack.charAt(i + j) != needle.charAt(j)) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                return i;
            }
        }
        return -1;
    }
}

DAY 19

选择题

以下关于Integer与int的区别错误的是？
A：int是java提供的8种原始数据类型之一
B：Integer是java为int提供的封装类
C：int的默认值为0
D：Integer的默认值为1
答：D
解析：
Integer 包装类属于引用数据类型，所以未赋值时默认为 null 。
关于下面代码 int[] x=new int[25]; 描述正确的是？
A：x[25]存放了数据“\0”。
B：x[24] 存放了数据“\0”。
C：若访问x[25]，程序将抛出异常。
D：x[1]访问此数组的第一个元素。
答：C
解析：
A 选项，数组长度为 25，下标从 0 ~ 24
B 选项，默认值为 0
D 选项，下标 1 访问的是第二个元素。
执行下面的程序段，语句3的执行次数为？
A：n(n+2)/2
B：(n-1)(n+2)/2
C：n(n+1)/2
D：(n-1)(n+2)

for (i = 0; i <= n-1; i++)   // (1)
    for (j = n; j > i; j--） // (2)
        state;               // (3)

答：C
解析：
该题仔细观察，是等差数列，求前 n 项和。

下面的程序将来打印什么?
A：I = 1
B：I = 2
C：I = 3
D：编译出错

public class TestIncr {
    public static void main(String args[]) {
        int i = 0;
        i = i++ + i;
        System.out.println("I =" +i);
    }
}

答：A
解析：
很简单，由于 i = 0 所以 i++ 的值为零，但是执行完 i++ 后 i 已经自增为 1 。所以 i = 0 + 1 = 1 咯。

在Java中，以下数据类型中,需要内存最多的是？
A：byte
B：long
C：Object
D：int
答：B
解析：
Object 是引用数据类型，只申明而不创建实例，只会在栈内存中开辟空间，默认为空，空占1 bit 。
下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？
A：private
B：无修饰符
C：public
D：protected
答：B
解析：
关于以下application,说法正确是什么？
A：4行与9行不能通过编译，因为缺少方法名和返回类型
B：编译通过，执行结果是：x=5
C：编译通过，执行结果是：x=3
D：9行不能通过编译，因为只能有一个静态初始化器

public class Test {
    static int x=10;
    static {x+=5;}
    public static void main(String[] args) //4
        {
        System.out.println("x="+x);
    }
    static{x/=3;};
}//9

答：B
解析：
静态域执行顺序：先初始化静态变量 x = 10; 然后执行第一个静态代码块，x = 15; 然后执行第二个静态代码块，x = 5; 然后执行 main 方法 x = 5 。

下面哪个选项正确创建socket连接？
A：Socket s = new Socket(8080);
B：Socket s = new Socket(“192.168.1.1”,8080)
C：SocketServer s = new Socket(8080);
D：Socket s = new SocketServer(“192.168.1.1”,8080)
答：B
解析：
服务器端：ServerSocket提供的实例 ServerSocket server = new ServerSocket(端口号)
客户端：Socket提供的实例 Socket client = new Socket(IP地址，端口号)
下面有关 JAVA 异常类的描述,说法正确的有？
A：异常的继承结构:基类为 Throwable,Error 和 Exception 。实现 Throwable, RuntimeException 和 IOException 等继承 Exception
B：非 RuntimeException 一般是外部错误(不考虑Error的情况下),其可以在当前类被 try{}catch 语句块所捕获
C：Error 类体系描述了 Java 运行系统中的内部错误以及资源耗尽的情形,Error 不需要捕捉
D：RuntimeException 体系包括错误的类型转换、数组越界访问和试图访问空指针等等,必须被 try{}catch 语句块所捕获
答：ABC
解析：
· Exception（异常） :是程序本身可以处理的异常。
· Error（错误）: 是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。
· 检查异常（编译器要求必须处置的异常）：除了Error，RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
· 非检查异常(编译器不要求处置的异常): 包括运行时异常（RuntimeException与其子类）和错误（Error）。
以下哪种方式实现的单例是线程安全的？
A：枚举
B：静态内部类
C：双检索模式
D：饿汉式
答：ABCD
解析：
暂无

编程题

leetcode 53
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。

示例：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
输入：nums = [1]
输出：1

分析：
这题可以使用动态规划的思想，遍历数组，让 sum + x 和当前元素 x 进行比较，取出大的赋值给 sum，直到 sum + x 比当前元素 x 小时，讲子数组的第一个元素更新为 x。然后寻找最大的结果 max 并返回。

代码：

class Solution {
    public int maxSubArray(int[] nums) {
        int sum = 0, max = nums[0];
        for (int x : nums) {
            sum = Math.max(sum + x, x);
            max = Math.max(max, sum);
        }
        return max;
    }
}

DAY 20

选择题

枚举（enum）属于原始数据类型（primitive type）
答：错误
解析：
原始数据类型：char、boolean、byte、short、int、long、float、double。
下列代码编译和运行的结果是？
A：编译错误
B：抛出运行时异常
C：输出：foo
D：代码正常运行，但是无输出

public class Threads4{
     public static void main(String[] args){
         new Threads4().go();
     }
     public void go(){
         Runnable r=new Runnable(){
             public void run(){
                 System.out.print("foo");
             }
         };
     Thread t=new Thread(r);
     t.start();
     }
 }

答：C
解析：
暂无

下面属于java合法变量名定义的是？
A：final
B：1var1
C：_var2
D：var3&
答：C
解析：
final 是关键字；不能以数字开头；可以以字母、下划线、美元符开头；不能有 &。
下面字段声明中哪一个在interface主体内是合法的?
A：private final static int answer = 42;
B：public static int answer = 42;
C：final static answer = 42;
D：int answer;
答：B
解析：
在接口中，属性默认都是 public static final 修饰的，且可以省略。
以下代码执行的结果显示是多少？
A：num * count = 505000
B：num *count = 0
C：运行时错误
D：num *count = 5050
答：B
解析：
没什么说的，count 一直是 0 。
DBMS 中实现事务持久性的子系统是?
A：安全性管理子系统
B：完整性管理子系统
C：并发控制子系统
D：恢复管理子系统
答：D
解析：
原子性（A）：安全性管理子系统；
一致性（C）：完整性管理子系统；
隔离性（I）：并发控制子系统；
持久性（D）：恢复管理子系统；
下列哪个选项是合法的标识符？
A：123
B：_name
C：class
D：first
答：BD
解析：
Java 标识符由数字、字母、下划线、美元符号组成，首位不能是数字。并且 Java关键字不能作为标识符。
对于构造方法，下列叙述正确的是？
A：构造方法的优先级一般比代码块低。
B：构造方法的返回类型只能是 void 型。
C：构造方法的主要作用是完成对类的对象的初始化工作。
D：一般在创建新对象时，系统会自动调用构造方法。
答：ACD
解析：
A 选项，静态域 > main 方法 > 非静态域 > 构造方法
B 选项，没有返回值。
C 选项，说的没毛病。
D 选项，也没毛病。
以下哪几种方式可用来实现线程间通知和唤醒？
A：Object.wait/notify/notifyAll
B：ReentrantLock.wait/notify/notifyAll
C：Condition.await/signal/signalAll
D：Thread.wait/notify/notifyAll
答：AC
解析：
暂无
以下哪种JAVA得变量声明方式可以避免程序在多线程竞争情况下读到不正确的值？
A：volatile
B：static volatile
C：synchronized
D：static
答：AB
解析：
synchronized 是用来修饰方法或代码块或对象。

编程题

leetcode 83
存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素只出现一次。返回同样按升序排列的结果链表。

示例：
输入：head = [1,1,2,3,3]
输出：[1,2,3]

分析：
因为链表是排好序的，所以让当前元素和下一个元素比较，如果相等，则删除后面的元素（让下一个节点指向下下一个节点），如果不相等，则让节点继续向后进行判断。

代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) {
            return head;
        }
        ListNode x = head;
        while (x.next != null) {
            if (x.val == x.next.val) {
                x.next = x.next.next;
            } else {
                x = x.next;
            }
        }
        return head;
    }
}

~JORDAN~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
每日一练（2）

目录DAY 11选择题编程题DAY 11选择题假设 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解析：
复制链接

扫一扫