NC101 缺失数字

发表于 2021-10-27 更新于 2021-10-31 分类于牛客网，编程题，在线编程 Waline：本文字数： 261 阅读时长 ≈ 1 分钟

NC101 缺失数字

知识点

位运算
数组
数学
二分

描述

从 0,1,2,…,n 这 n+1 个数中选择 n 个数，选择出的数字依然保持有序，找出这 n 个数中缺失的那个数，要求$O(n)$或 $O(log(n))$ 并尽可能小。

数据范围： $0\leq n \leq 10000$
要求：空间复杂度 $O(1)$ ，时间复杂度 $O(n)$
进阶：空间复杂度 $O(1)$ ，时间复杂度 $O(logn)$

示例1

输入：

1	[0,1,2,3,4,5,7]

返回值：

示例2

输入：

[0,2,3]

返回值：

示例3

输入：

1	[0,1,2,3,4]

返回值：

关联企业:

字节跳动
华为
百度

NC151 最大公约数

发表于 2021-10-26 更新于 2021-10-31 分类于牛客网，编程题，在线编程 Waline：本文字数： 2k 阅读时长 ≈ 2 分钟

NC151 最大公约数

描述

如果有一个自然数 a 能被自然数 b 整除，则称 a 为 b 的倍数， b 为 a 的约数。几个自然数公有的约数，叫做这几个自然数的公约数。公约数中最大的一个公约数，称为这几个自然数的最大公约数。

输入 a 和 b , 请返回 a 和 b 的最大公约数。

数据范围：$1\leq a,b\leq10^9$

进阶：空间复杂度 $O(1)$，时间复杂度$O(logn)$

示例1

输入：

3,6

返回值：

示例2

输入：

8,12

返回值：

备注：

a和b的范围是[1-109]

关联企业

我的解析

使用辗转相除法

import java.util.*;

public class Solution {
    /**
    * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
    *
    * 求出a、b的最大公约数。
    * @param a int 
    * @param b int 
    * @return int
    */
    public int gcd (int a, int b) {
        // 辗转相除法求最大公约数
        // 保证a>=b
        if(a<b){
            a^=b;
            b^=a;
            a^=b;
        }
        // 求余数
        int yushu=a%b;
        // 如果余数为0,那么商就是最大公约数
        if(yushu==0){
            return b;
        }
        else {
            // 转换成求商和余数的最大公约数
            return gcd(b,yushu);
        }
    }
}

使用辗转相减法

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 求出a、b的最大公约数。
     * @param a int 
     * @param b int 
     * @return int
     */
    public int gcd (int a, int b) {
        // 辗转相减法求最大公约数
        while (a != b) {
            if (a > b)
                a = a - b;
            else
                b = b - a;
        }
        return a;
    }
}

精华题解

更相减损法

这个思想起源于我国古代的《九章算术》，它原本是为约分而设计的，但它适用于任何需要求最大公约数的场合。原文是这么描述的：“可半者半之，不可半者，副置分母、子之数，以少减多，更相减损，求其等也。以等数约之。”

翻译成白话将就是：

第一步：对于任意给定的两个正整数a、b，要求出他们的最大公约数，首先判断他们俩是否都是偶数（能被2整除），如果都是偶数则一直除以2约简，直至不能再被2整除:

while(a%2==0 && b%2==0){
    a = a/2;
    b = b/2;
}

第二步：如果不是，那么就执行下一步，即用较大的数减去较小的数，然后将所得的差值赋值给原先拥有较大值的那个变量，再拿这个变量与较小值的那个变量进行比较，继续用二者中较大的减去较小的，直到两个变量相等；

public int gcd (int a, int b) {
    // write code here
    if (a % b == 0 || b % a == 0){
        return a % b == 0 ? b : a;
    }
 
    while(a != b){
        if(a > b){
            a = a - b;
        } else {
            b = b - a;
        }
    }
    return a;
}

辗转相除法

import java.util.*;
public class Solution {
    public int gcd (int a, int b) {
        if(a%b==0)
            return b;
        else
            return gcd(b,a%b);
    }
}

网络题解

https://www.cnblogs.com/HuangWj/p/11261870.html

大数减小数，直到两数相等时，即为最大公约数。

递归实现

// 辗转相减法，递归实现
int GCD(int a, int b)
{
    if (a == b)
        return a;
    else if (a > b)
        return GCD(a,b);
    else
        return GCD(b,a);
}

迭代实现

// 辗转相减法，迭代实现
int GCD(int a, int b)
{
    while(a == b)
    {
        if (a > b) a -= b;
        else b -= a;
    }
    return a;
}

文章2

https://blog.csdn.net/Holmofy/article/details/76401074

NC141 判断回文

发表于 2021-10-25 更新于 2021-10-31 分类于牛客网，编程题，在线编程 Waline：本文字数： 1.3k 阅读时长 ≈ 1 分钟

NC141 判断回文_入门

描述

给定一个长度为 n 的字符串，请编写一个函数判断该字符串是否回文。如果是回文请返回true，否则返回false。

字符串回文指该字符串正序与其逆序逐字符一致。

数据范围：$0<n \leq 1000000$

要求：空间复杂度 $O(1)$，时间复杂度 $O(n)$

示例1

输入：”absba”
返回值：true

示例2

输入：”ranko”
返回值：false

示例3

输入：”yamatomaya”
返回值：false

示例4

输入：”a”
返回值：true

备注：

字符串长度不大于1000000，且仅由小写字母组成

关联企业

腾讯
阿里巴巴
字节跳动

关联职位

算法
研发
测试
前端

我的解析

翻转还相等，则是回文

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param str string字符串 待判断的字符串
     * @return bool布尔型
     */
    public boolean judge (String str) {
        // write code here
        // 如果翻转字符串之后，还是和原来的字符串相等，则是回文数
        return str.equals(new StringBuilder(str).reverse().toString());
    }
}

遍历判断是否对称：使用单指针

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param str string字符串 待判断的字符串
     * @return bool布尔型
     */
    public boolean judge (String str) {
        // write code here
        for(int i=0,length=str.length();i<=length/2;i++){
            if(str.charAt(i)!=str.charAt(length-1-i)){
                return false;
            }
        }
        return true;
    }
}

遍历判断是否对称：使用双指针

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param str string字符串 待判断的字符串
     * @return bool布尔型
     */
    public boolean judge (String str) {
        // write code here
        for(int i=0,j=str.length()-1;i<=j;i++,j--){
            if(str.charAt(i)!=str.charAt(j)){
                return false;
            }
        }
        return true;
    }
}

NC65 斐波那契数列_入门

发表于 2021-10-25 更新于 2021-10-31 分类于牛客网，编程题，在线编程 Waline：本文字数： 2.5k 阅读时长 ≈ 2 分钟

NC65 斐波那契数列_入门

知识点:数组

描述

大家都知道斐波那契数列，现在要求输入一个正整数 n ，请你输出斐波那契数列的第 n 项。

斐波那契数列是一个满足

$$fib(x)=\begin{cases}
&1\text{ } &x=1,2 \\
&fib(x-1)+fib(x-2)\text{ } &x>2
\end{cases}$$

的数列

数据范围：$1 \leq n \leq 39$

要求：空间复杂度 $O(1)$，时间复杂度 $O(n)$ ，本题也有时间复杂度 $O(logn)$ 的解法

输入描述：

一个正整数n

返回值描述：

输出一个正整数。

示例1

输入：4
返回值：3
说明：根据斐波那契数列的定义可知，fib(1)=1,fib(2)=1,fib(3)=fib(3-1)+fib(3-2)=2,fib(4)=fib(4-1)+fib(4-2)=3，所以答案为4。

示例2

输入：1
返回值：1

示例3

输入：2
返回值：1

关联企业

作业帮瓜子二手车小米美团字节跳动

关联职位

前端研发算法测试

官方解析

描述

此题是非常经典的入门题了。我记得第一次遇到此题是在课堂上，老师拿来讲“递归”的（哈哈哈）。同样的类型的题还有兔子繁殖的问题。大同小异。此题将用三个方法来解决，从入门到会做。
考察知识：递归，记忆化搜索，动态规划和动态规划的空间优化。
难度：一星

题解

方法一：递归

题目分析，斐波那契数列公式为：f[n] = f[n-1] + f[n-2], 初始值f[0]=0, f[1]=1，目标求f[n]
看到公式很亲切，代码秒秒钟写完。

int Fibonacci(int n) {
    if (n==0 || n==1) return n;
    return Fibonacci(n-1) + Fibonacci(n-2);
}

优点，代码简单好写，缺点：慢，会超时
时间复杂度：O(2^n)
空间复杂度：递归栈的空间

方法二：记忆化搜索

拿求f[5] 举例

通过图会发现，方法一中，存在很多重复计算，因为为了改进，就把计算过的保存下来。
那么用什么保存呢？一般会想到map，但是此处不用牛刀，此处用数组就好了。

int Fib(int n, vector<int>& dp) {
    if (n==0 || n==1) return n;
    if (dp[n] != -1) return dp[n];
    return dp[n] = Fib(n-1) + Fib(n-2);
}
int Fibonacci(int n) {
    vector<int> dp(45, -1); // 因为答案都是>=0 的， 所以初始为-1，表示没计算过
    return Fib(n, dp);
}

时间复杂度：$O(n)$，没有重复的计算
空间复杂度：$O(n)$ 和递归栈的空间

方法三：动态规划

虽然方法二可以解决此题了，但是如果想让空间继续优化，那就用动态规划，优化掉递归栈空间。
方法二是从上往下递归的然后再从下往上回溯的，最后回溯的时候来合并子树从而求得答案。
那么动态规划不同的是，不用递归的过程，直接从子树求得答案。过程是从下往上。

int Fibonacci(int n) {
    vector<int> dp(n+1, 0);
        dp[1] = 1;
        for (int i=2; i<=n; ++i) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
}

时间复杂度：$O(n)$
空间复杂度：$O(n)$

继续优化

发现计算f[5]的时候只用到了f[4]和f[3], 没有用到f[2]…f[0],所以保存f[2]..f[0]是浪费了空间。
只需要用3个变量即可。

int Fibonacci(int n) {
    if (n == 0 || n == 1) return n;
    int a = 0, b = 1, c;
    for (int i=2; i<=n; ++i) {
        c = a + b;
        a = b;
        b = c;
    }
    return c;
}

时间复杂度：$O(n)$
空间复杂度：$O(1)$
完美！

我的解析

递归实现：

public class Solution {
    public int Fibonacci(int n) {
        if (n==0 || n==1) return n;
        return Fibonacci(n-1) + Fibonacci(n-2);
    }
}

记忆化搜索

public class Solution {
    public int Fibonacci(int n) {
        int[] dp=new int[45];
        for(int i=0;i<dp.length;i++)
        {
            dp[i]=-1;
        }
        return fib(n,dp);
    }
    public int fib(int n,int[] dp){
        if(n==0||n==1) return n;
        if(dp[n]!=-1) return dp[n];
        return dp[n]=fib(n-1,dp)+fib(n-2,dp);
    }
}

动态规划法：

// 动态规划法
public class Solution {
    public int Fibonacci(int n) {
        int[] dp=new int[n+1];
        dp[1]=1;
        int i=2;
        for(;i<=n;++i){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

进一步优化

public class Solution {
    public int Fibonacci(int n) {
        if (n == 0 || n == 1) return n;
        int a = 0, b = 1, c=0;
        for (int i=2; i<=n; ++i) {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
}

NC103 反转字符串_入门

发表于 2021-10-25 更新于 2021-10-31 分类于牛客网，编程题，在线编程 Waline：本文字数： 2.5k 阅读时长 ≈ 2 分钟

NC103 反转字符串

描述

写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

数据范围： $0 \le n \le 10000≤n≤1000$
要求：空间复杂度 $O(n)$，时间复杂度 $O(n)$

示例1

1 2	输入："abcd" 返回值："dcba"

示例2

1 2	输入："" 返回值：""

关联企业

百度
微盟
携程
腾讯

关联职位

测试
研发
前端
算法

我的题解

import java.util.*;

public class Solution {
    /**
     * 反转字符串
     * @param str string字符串 
     * @return string字符串
     */
    public String solve (String str) {
        StringBuilder sb=new StringBuilder(str.length());
        for(int i=str.length()-1;i>=0;i--){
            sb.append(str.charAt(i));
        }
        return sb.toString();
    }
}

// 方式2
char[] arr=str.toCharArray();
char temp;
for(int i=0;i<arr.length/2;i++){
    temp=arr[i];
    arr[i]=arr[arr.length-1-i];
    arr[arr.length-1-i]=temp;
}
return new String(arr);

// 方式3：使用亦或进行交换
// a^=b;
// b^=a;
// a^=b;
char[] arr=str.toCharArray();
for(int i=0;i<arr.length/2;i++){
    arr[i]^=arr[arr.length-1-i];
    arr[arr.length-1-i]^=arr[i];
    arr[i]^=arr[arr.length-1-i];
}
return new String(arr);

// 方式4：使用valueOf(char[])方法返回字符串
char[] arr=str.toCharArray();
for(int i=0;i<arr.length/2;i++){
    arr[i]^=arr[arr.length-1-i];
    arr[arr.length-1-i]^=arr[i];
    arr[i]^=arr[arr.length-1-i];
}
return String.valueOf(arr);

// 方式5：库函数实现
StringBuilder sb=new StringBuilder(str.length());
sb.append(str);
return sb.reverse().toString();

方式5：库函数实现2：

1	return new StringBuilder(str).reverse().toString();

官方精华题解

视频

https://www.nowcoder.com/practice/c3a6afee325e472386a1c4eb1ef987f3?tab=note

文字题解

解法一:

开辟一个和str长度大小相同的一个字符串ans，把传入的str倒序赋值到ans字符串上，时间复杂度$O(n)$,额外空间复杂度$O(n)$。

import java.util.*;
public class Solution {
    public String solve (String str) {
        char[] ans = str.toCharArray();
        int len = str.length();
        for(int i = 0 ; i < len ;i++)
        {
                ans[i] = str.charAt(len-1-i);
        }
        return new String(ans);
    }
}

解法二:

原地交换，,注意：交换进行的次数是次

时间复杂度,额外空间复杂度

import java.util.*;
public class Solution {
    public String solve (String str) {
        char[] cstr = str.toCharArray();
        int len = str.length();
        for(int i = 0 ;i < len/2 ;i++){
            char t = cstr[i];
            cstr[i] = cstr[len-1-i];
            cstr[len-1-i]=t;
        }
        return new String(cstr);
    }
}

解法三:

直接调用库函数

import java.util.*;
public class Solution {
    public String solve (String str) {
        StringBuffer sb =new StringBuffer(str);//此方法针对的是io流，不能针对字符串。
        return sb.reverse().toString();
    }
}

2021年10月13日 java3

发表于 2021-10-13 更新于 2021-11-09 分类于牛客网，专项练习， Java ， 2021年10月 Waline：本文字数： 3.9k 阅读时长 ≈ 4 分钟

考点1:int除法

下列语句序列执行后，输出结果是（）

public class ex{
public static void main(String[]args){
int a=13;
a=a/5；
System.out.println(a);
}
}

A 1
B 2
C 3
D 4

显示答案/隐藏答案

正确答案: B

a是int类型,13/5得到一个浮点类型,浮点类型转成整数类型的原则是,不四舍五入,直接截断小数点后的部分.

整数相除之后还是整数，会丢失掉小数部分的数值。

13/5取商为2，然后再赋值给a,所有输出a=2。

考点2:继承

设有下面一段代码：

class  Student  extends  Person {
long    id;     // 身份证号
int  score;  // 入学总分
String  name;   // 姓名
int  getScore(){
return  score;
}
}

问：类 Person 和类 Student 的关系是（）。

A 包含关系
B 继承关系
C 关联关系
D 无关系，上述类定义有语法错误

显示答案/隐藏答案

正确答案: B

考点3:访问控制符

下列不属于类及类成员的访问控制符是：（）

A public
B private
C static
D protected

显示答案/隐藏答案

正确答案: C

作用域	当前类	同包	子类	其他
Public	√	√	√	√
Protected	√	√	√	×
Default	√	√	×	×
Private	√	×	×	×

考点4:自增，自减运算符

以下程序会输出什么

int a =100,b=50,c=a---b,d=a---b;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);

A 100 48 48 49
B 100 49 48 52
C 98 50 50 49
D 98 50 50 48

显示答案/隐藏答案

正确答案: C

1 2	c=a---b 等于c=a-- -b 等于c=100-50=50,a=99 b=a---b 等于c=a-- -b 等于d=99-50=49,a=98

综上得到：

1	a=98,b=50,c=50,d=49

https://www.cnblogs.com/antineutrino/p/3301843.html

Java运算符优先级

优先级	运算符	结合性
1	`()`、`[]`、`{}`	从左向右
2	`!`、`+`、`-`、`~`、`++`、`--`	从右向左
3	`*`、`/`、`%`	从左向右
4	`+`、`-`	从左向右
5	`<<`、`>>`、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	`^`	从左向右
10	\|	从左向右
11	&&	从左向右
12	\|\|	从左向右
13	`?:`	从右向左
14	`=`、`+=`、`-=`、`*=`、`/=`、&=、\|=、^=、`~=`、`<<=`、`>>=`、>>>=	从右向左

http://c.biancheng.net/view/794.html

运算符的结合性

许多操作符的优先级都是相同的。这时，操作符的结合性就开始发挥作用了。在表达式中如果有几个优先级相同的操作符，结合性就起仲裁的作用，由它决定哪个操作符先执行。先执行，可以看做是加上括号。

比如，右结合（从右到左），那就是，把右边的运算用括号先括起来，再与左边的进行计算，这样自然是先执行右边的了。比如

1 2	int a,b=1,c=2; a=b=c;

这里’=’的结合性是从右到左。故a=b=c; 可变为a=(b=c); 即a=2。

考点5:Servlet

通过HttpServletRequest. getParameter获取的参数.

A 总是采用UTF-8编码
B 总是采用lS08859-1编码
C 由客户端浏览器和Web容器配置共同决定编码
D 由服务器所在的操作系统决定编码

显示答案/隐藏答案

正确答案: C

选C
1、浏览器根据jsp页面开头声明的编码方式对request中参数编码；
2、tomcat默认解码是ISO-8859-1，
但是我们可以显示指定解码格式

通过调用request.setCharacterEncoding(“UTF-8”)，
或者修改tomcat的配置文件server.xml中的编码，添加uriEncoding属性。

考点6:比较运算符赋值运算符

public class IfTest{
    public static void main(String[]args){
        int x=3;
        int y=1;
        if(x=y)
            System.out.println("Not equal");
        else
            System.out.println("Equal");
     }
}

下面结果输出是？

A The output is “Equal”
B The output in “Not Equal”
C An error at line 5 causes compilation to fall.
D The program executes but does not print a message.

显示答案/隐藏答案

正确答案: C

这个题考查两个知识点。
1、Java中，赋值是有返回值的，赋什么值，就返回什么值。比如这题，x=y，返回y的值，所以括号里的值是1。
2、Java跟C的区别，C中赋值后会与0进行比较，如果大于0，就认为是true；而Java不会与0比较，而是直接把赋值后的结果放入括号。

这题，我忽略了第二点。

考点8:==运算符

下面的输出结果是什么？

public class Demo {
  public static void main(String args[])
  {
    String str=new String("hello");
    if(str=="hello")
    {
      System.out.println("true");
    }      
    else     {
      System.out.println("false");
    }
  }
}

A true
B false

显示答案/隐藏答案

正确答案: B

==判断的是对象引用地址是否相同，

1	String str1 = new String("hello");

这种方式创建的字符串，和正常创建对象一样，保存在堆区。

1	String str3 = "hello";

这种方式创建的字符串，保存在字符串常量区。

考点9:负数求余运算

以下代码段执行后的输出结果为

public class Test {
    public static void main(String args[]) {
        int x = -5;
        int y = -12;
        System.out.println(y % x);
    }
}

A -1
B 2
C 1
D -2

显示答案/隐藏答案

正确答案: D

无论是正数还是负数，在取余运算时都有：

1	被除数=商×除数+余数

，所以-12=2×(-5)+(-2)，-12是被除数，-5是除数，2是商，余数是-2。

%是取余运算最后符号和第1个值一样，
Math.floorMod()是取模，最后符号和第2个值一样

System.out.println(-12 % -5);
System.out.println(-12 % 5);
System.out.println(12 % -5);
System.out.println(12 % 5);
System.out.println("===============================");
System.out.println(Math.floorMod(-12, -5));
System.out.println(Math.floorMod(-12, 5));
System.out.println(Math.floorMod(12, -5));
System.out.println(Math.floorMod(12, 5));

运行结果：

-2
-2
2
2
===============================
-2
3
-3
2

%是取余数，结果的符号要看被除数，也就是与第一个数同符号。

考点10:多线程安全支持的Map

下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：( )

A java.util.ConcurrentHashMap
B java.util.Map
C java.util.TreeMap
D java.util.SortMap
E java.util.Hashtable
F java.util.HashMap

显示答案/隐藏答案

正确答案: AE

考点11:

character流和byte流的区别不包括（）

A 每次读入的字节数不同
B 前者带有缓冲，后者没有。
C 前者是字符读入，后者是字节读入。
D 二者没有区别，可以互换。

显示答案/隐藏答案

正确答案: ABD

做错两次了，这个不包括，有点绕，题目改成 character流和byte流的说法错误的是，这样简单点

2021年10月13日 java2

发表于 2021-10-13 分类于牛客网，专项练习， Java ， 2021年10月 Waline：本文字数： 4k 阅读时长 ≈ 4 分钟

考点1:

在java中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是（）

A interface A extends B，C
B interface A eimplements B，C
C class A implements B，C
D class A implements B，implements C

显示答案/隐藏答案

正确答案: C

类实现多个接口的时候，只需要一个implements，多个接口通过逗号进行隔开，先继承类再实现接口

考点2:

在socket编程中，可以使用方法（）获取本机的ip地址

A getInetAddress()
B getLocalAddress()
C getReuseAddress()
D getLocalPort()

显示答案/隐藏答案

正确答案: B

getInetAddress获取主机名和IP地址
getLocalAddress()顾名思义，获取本地IP地址
getReuseAddress()返回布尔类型，表示复用地址
getLocalPort()API 的说明：“Returns the Internet Protocol (IP) port number of the interface on which the request was received. ”

考点3:

下面有关servlet中init,service,destroy方法描述错误的是？

A init()方法是servlet生命的起点。一旦加载了某个servlet，服务器将立即调用它的init()方法
B service()方法处理客户机发出的所有请求
C destroy()方法标志servlet生命周期的结束
D servlet在多线程下使用了同步机制，因此，在并发编程下servlet是线程安全的

显示答案/隐藏答案

正确答案: D

答案为D。

servlet在多线程下其本身并不是线程安全的。

如果在类中定义成员变量，而在service中根据不同的线程对该成员变量进行更改，那么在并发的时候就会引起错误。最好是在方法中，定义局部变量，而不是类变量或者对象的成员变量。由于方法中的局部变量是在栈中，彼此各自都拥有独立的运行空间而不会互相干扰，因此才做到线程安全。

考点4:

下面代码运行结果是（）

public class Test{    
    public int add(int a,int b){    
         try {    
             return a+b;        
         } 
        catch (Exception e) {    
            System.out.println("catch语句块");    
         }    
         finally{    
             System.out.println("finally语句块");    
         }    
         return 0;    
    } 
     public static void main(String argv[]){ 
         Test test =new Test(); 
         System.out.println("和是："+test.add(9, 34)); 
     }
}

A catch语句块和是：43
B 编译异常
C finally语句块和是：43
D 和是：43 finally语句块

显示答案/隐藏答案

正确答案: C

为什么不是先输出：和是 finally块 43的原因。

1	System.out.println("和是："+test.add(9, 34));

这是进行字符串拼接是一个整体，所以首先是进入add方法中，进去之后先把先不运算result，而是输出finally块。
注意：此时finally块输出结果是：finally语句块，这句话首先打印到控制台中。打印完后返回来执行try中的return得到43，所以此时再将结果与”和是：”进行拼接，得到：和是43。
所以此时控制台又多了一句话：和是43。加上之前finally先在控制台上的输出，所以结果为：
finally语句块和是：43

考点5:

容器panel缺省使用的布局编辑策略是( )

A Border Layout
B Flow Layout
C GridLayout
D Card Layout

显示答案/隐藏答案

正确答案: B

考点6:

下面有关servlet和cgi的描述，说法错误的是？

A servlet处于服务器进程中，它通过多线程方式运行其service方法
B CGI对每个请求都产生新的进程，服务完成后就销毁
C servlet在易用性上强于cgi，它提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等
D cgi在移植性上高于servlet，几乎所有的主流服务器都直接或通过插件支持cgi

显示答案/隐藏答案

正确答案: D

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

概括来讲，Servlet可以完成和CGI相同的功能。

CGI 通用网管接口

CGI（Common Gateway Interface通用网关接口）程序来实现数据在Web上的传输，使用的是如Perl这样的语言编写的，它对于客户端作出的每个请求，必须创建CGI程序的一个新实例，这样占用大量的内存资源。由此才引入了Servlet技术。

Servlet是一个用java编写的应用程序，在服务器上运行，处理请求信息并将其发送到客户端。对于客户端的请求，只需要创建Servlet的实例一次，因此节省了大量的内存资源。Servlet在初始化后就保留在内存中，因此每次作出请求时无需加载。

CGI应用开发比较困难，因为它要求程序员有处理参数传递的知识，这不是一种通用的技能。CGI不可移植，为某一特定平台编写的CGI应用只能运行于这一环境中。每一个CGI应用存在于一个由客户端请求激活的进程中，并且在请求被服务后被卸载。这种模式将引起很高的内存、CPU开销，而且在同一进程中不能服务多个客户。

Servlet提供了Java应用程序的所有优势——可移植、稳健、易开发。使用Servlet Tag技术，Servlet能够生成嵌于静态HTML页面中的动态内容。

Servlet对CGI的最主要优势在于一个Servlet被客户端发送的第一个请求激活，然后它将继续运行于后台，等待以后的请求。每个请求将生成一个新的线程，而不是一个完整的进程。多个客户能够在同一个进程中同时得到服务。一般来说，Servlet进程只是在Web Server卸载时被卸载。

原文：https://blog.csdn.net/zdwzzu2006/article/details/5945635

考点7:

关于匿名内部类叙述正确的是？ ( )

A 匿名内部类可以继承一个基类，不可以实现一个接口
B 匿名内部类不可以定义构造器
C 匿名内部类不能用于形参
D 以上说法都不正确

显示答案/隐藏答案

正确答案: B

在使用匿名内部类的过程中，我们需要注意如下几点：
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

考点8:

下面的对象创建方法中哪些会调用构造方法（）？

A new语句创建对象
B 调用Java.io.ObjectInputStream的readObject方法
C java反射机制使用java.lang.Class或java.lang.reflect.Constructor的newInstance()方法
D 调用对象的clone()方法

显示答案/隐藏答案

正确答案: AC

readObject （）对象反序列化
clone（）只是拷贝而已
也就是说会绕过任何构造函数（有参和无参），因为clone方法的原理是从堆内存中以二进制流的方式进行拷贝，直接分配一块新内存。

考点9:

以下说法中正确的有？

A StringBuilder是线程不安全的
B Java类可以同时用 abstract和final声明
C HashMap中，使用 get(key)==null可以判断这个Hasmap是否包含这个key
D volatile关键字不保证对变量操作的原子性

显示答案/隐藏答案

正确答案: AD

StringBuffer线程安全，StringBuilder线程不安全
get(key)只是获取 key 对应的 value，无法判断是否 key 存在；

volatile轻量级的同步机制，能保证数据的可见性，但不能保证数据的原子性；

考点10:待学习：并发编程

JDK提供的用于并发编程的同步器有哪些？

A Semaphore
B CyclicBarrier
C CountDownLatch
D Counter

显示答案/隐藏答案

正确答案: ABC

答案：ABC
A，Java 并发库的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过
acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
B，CyclicBarrier 主要的方法就是一个：await()。await()
方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。
C，直译过来就是倒计数(CountDown)门闩(Latch)。倒计数不用说，门闩的意思顾名思义就是阻止前进。在这里就是指
CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程。
D，Counter不是并发编程的同步器

2021年10月13日 java1

发表于 2021-10-13 分类于牛客网，专项练习， Java ， 2021年10月 Waline：本文字数： 4.8k 阅读时长 ≈ 4 分钟

考点1:变量初始化话

下列程序test 类中的变量c 的最后结果为

public class Test {
    public static void main(String args[]) {
        int a = 10;
        int b;
        int c;
        if (a > 50) {
             b = 9;
        }
        c = b + a;
    }
}

A 10
B 0
C 19
D 编译出错

显示答案/隐藏答案

正确答案: D

方法中定义的变量一定要初始化，类中定义的变量可不用初始化，会有默认值
报错如下：

1	The local variable b may not have been initialized

考点2:快速排序

下面程序的输出结果是什么。

public class A2{ 
    public static void main(String[] args){
        int[] a={2,4,6,8,3,6,9,12};
        doSomething(a,0,a.length-1);
        for(int i=0;i<=a.length-1;i++)
        System.out.print(a[i]+" ");
    } 
    private static void doSomething(int[] a,int start,int end){
        if(start<end){
            int p=core(a,start,end);
            doSomething(a,start,p-1);
            doSomething(a,p+1,end);
        }
    }
    private static int core(int[] a,int start,int end)
    {
        int x=a[end];
        int i=start;
        for(int j=start;j<=end-1;j++){
            if(a[j]>=x){
                swap(a,i,j);
                i++;
            }
        }
        swap(a,i,end);
        return i;
    } 
    
    private static void swap(int[] a,int i,int j) 
    {
        int tmp=a[i];
        a[i]=a[j];
        a[j]=tmp;
    }
}

A 找到最大值
B 找到最小值
C 从大到小的排序
D 从小到大的排序

显示答案/隐藏答案

正确答案: C

考点3:maven和ant

下面有关maven和ant的描述，描述错误的是？

A Ant 没有正式的约定如一个一般项目的目录结构，你必须明确的告诉 Ant 哪里去找源代码
B Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里
C maven和ant都有“生命周期”的概念，当你输入一个命令后，maven或者ant会执行一系列的有序的步骤，直到到达你指定的生命周期
D Ant构建文件默认命名为build.xml，Maven默认构建文件为pom.xml

显示答案/隐藏答案

正确答案: C

Ant的作用：是一种基于Java的build工具

能够用ant编译java类。生成class文件
ant能够自己定义标签、配置文件，用于构建。
ant能够把相关层构建成jar包。
ant把整个项目生成web包。并公布到Tomcat

Ant的长处：

跨平台性：Ant是纯Java语言编写的，因此具有非常好的跨平台性。
操作简单：Ant是由一个内置任务和可选任务组成的。Ant执行时须要一个XML文件(构建文件)。
Ant通过调用target树，就能够运行各种task：每一个task实现了特定接口对象。因为Ant构建文件时XML格式的文件。所以非常easy维护和书写，并且结构非常清晰。
Ant能够集成到开发环境中：因为Ant的跨平台性和操作简单的特点。它非常easy集成到一些开发环境中去。

Maven的作用：除了以程序构建能力为特色之外，还提供高级项目管理工具。

Maven除了具备Ant的功能外。还添加了下面基本的功能：

使用Project Object Model来对软件项目管理。
内置了很多其它的隐式规则，使得构建文件更加简单。
内置依赖管理和Repository来实现依赖的管理和统一存储；
内置了软件构建的生命周期；

Maven的长处：

拥有约定，知道你的代码在哪里，放到哪里去
拥有一个生命周期，比如运行 mvn install就能够自己主动运行编译，測试。打包等构建过程
仅仅须要定义一个pom.xml,然后把源代码放到默认的文件夹，Maven帮你处理其它事情
拥有依赖管理。仓库管理

总体的比較：

Ant将提供了非常多能够重用的task，比如copy, move, delete以及junit单元测试
Maven则提供了非常多能够重用的过程。

考点4:java8中使用开放地址法的类

java8中，下面哪个类用到了解决哈希冲突的开放定址法

A LinkedHashSet
B HashMap
C ThreadLocal
D TreeMap

显示答案/隐藏答案

正确答案: C

HashMap采用了链地址法，ThreadLocalMap则是开放地址法。

开放定址法：当冲突发生时，使用某种探查(亦称探测)技术在散列表中形成一个探查(测)序列。沿此序列逐个单元地查找，直到找到给定
的关键字，或者碰到一个开放的地址(即该地址单元为空)为止（若要插入，在探查到开放的地址，则可将待插入的新结点存人该地址单元）。查找时探查到开放的地址则表明表中无待查的关键字，即查找失败。
链地址法：将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点，均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。

考点5:

下列关于while循环、do-while循环和for循环说法错误的是

A while循环先执行条件判断，do-while循环执行循环体
B do-while循环结束的条件是关键字while后的条件表达式成立
C for循环结构中的3个表达式缺一不可
D while循环能够实现的操作，for循环也能实现

显示答案/隐藏答案

正确答案: BC

考点6:

以下类型为Final类型的为（）

A HashMap
B StringBuffer
C String
D Hashtable

显示答案/隐藏答案

正确答案: BC

Class HashMap<K,V>
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashMap.html
1
2
3
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
Direct Known Subclasses:
LinkedHashMap, PrinterStateReasons

Class Hashtable<K,V>
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html
All Implemented Interfaces:
Serializable, Cloneable, Map<K,V>
Direct Known Subclasses:
Properties, UIDefaults
1
2
3
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, Serializable

String StringBuffer StringBuilder都是final类

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html
1
2
3
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StringBuffer.html
1
2
3
public final class StringBuffer
extends Object
implements Serializable, Comparable<StringBuffer>, CharSequence
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StringBuilder.html
1
2
3
public final class StringBuilder
extends Object
implements Serializable, Comparable<StringBuilder>, CharSequence

通过阅读源码可以知道，string与stringbuffer都是通过字符数组实现的。
其中string的字符数组是final修饰的，所以字符数组不可以修改。
stringbuffer的字符数组没有final修饰，所以字符数组可以修改。
string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改。
至于地址所指内容能不能修改，则需要看字符数组可不可以修改。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    ......
}

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{......}

 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{......}

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;
    ......
}

考点7:

在使用super和this关键字时，以下描述错误的是（）

A 在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B super()和this()不一定要放在构造方法内第一行
C this()和super()可以同时出现在一个构造函数中
D this()和super()可以在static环境中使用，包括static方法和static语句块

显示答案/隐藏答案

正确答案: BCD

2021年10月12日 java2

发表于 2021-10-12 分类于牛客网，专项练习， Java ， 2021年10月 Waline：本文字数： 2.7k 阅读时长 ≈ 2 分钟

考点2:

public boolean returnTest()
{
    try
    {
        return true;
    }
    catch (Exception e)
    {

    }
    finally
    {
        return false;
    }
}

以上代码返回值是什么？

A true
B false

显示答案/隐藏答案

正确答案: B

一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效

考点3:

检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

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

A static A I’m A class static B I’m B class
B I’m A class I’m B class static A static B
C static A static B I’m A class I’m B class
D I’m A class static A I’m B class static B

显示答案/隐藏答案

正确答案: C

子由父生，执行顺序为：
父类的静态代码块>子类的静态代码块>父类的构造代码块>父类的构造函数>子类的构造代码块>子类的构造函数

考点4:

面向对象方法的多态性是指（）

A 一个类可以派生出多个特殊类
B 一个对象在不同的运行环境中可以有不同的变体
C 针对一消息，不同的对象可以以适合自身的方式加以响应
D 一个对象可以是由多个其他对象组合而成的

显示答案/隐藏答案

正确答案: C

C听起来好别扭，我觉得是：对于同一个父类方法，不同的子类会有不同的实现方式

考点5:

以下代码运行输出的是

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);
    }
}

A 输出：Person
B 没有输出
C 编译出错
D 运行出错

显示答案/隐藏答案

正确答案: C

2.关于多态。子类继承了父类的所有成员，包括private权限的成员变量，但是继承的子类具有私有变量的拥有权但是没有使用权。
3.private的成员变量，根据权限修饰符的访问控制范围，只有在类内部才能被访问，就算是他的子类，也不能访问。

考点6:

在java中，下列对继承的说法，正确的是（）

A 子类能继承父类的所有成员
B 子类继承父类的非私有方法和状态
C 子类只能继承父类的public方法和状态
D 子类只能继承父类的方法

显示答案/隐藏答案

正确答案: A

子类和继承父类的所有成员

我们有时候会分不清继承和访问权限的问题。子类可以继承父类所有的成员，但是对private这样的，没有访问权。

考点7:

如果希望监听TCP端口9000，服务器端应该怎样创建socket?

A new Socket(“localhost”,9000);
B new ServerSocket(9000);
C new Socket(9000);
D new ServerSocket(“localhost”,9000);

显示答案/隐藏答案

正确答案: B

考点8:

下列关于容器集合类的说法正确的是？

A LinkedList继承自List
B AbstractSet继承自Set
C HashSet继承自AbstractSet
D WeakMap继承自HashMap

显示答案/隐藏答案

正确答案: C

a选项LinkedList类是实现了List接口，而不是继承

1
2
3

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

b选项AbstractSet类实现Set接口

1	public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E>

c选项HashSet继承AbstractSet类，同时也实现Set

1	public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable

D选项，java没有WeakMap，有WeakHashMap:

1
2
3

public class WeakHashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>

考点9:

下列关于异常的说法，正确的是（）

A RuntimeException及其子类的异常可以不做处理
B Catch段中的语句，不允许再次出现异常
C 在方法定义中以throws标识出的异常，在调用该方法中的方法必须处理
D 程序中所有的可能出现的异常必须在catch中捕获，否则将引起编译错误

显示答案/隐藏答案

正确答案: A

2021年10月12日 java1

发表于 2021-10-12 分类于牛客网，专项练习， Java ， 2021年10月 Waline：本文字数： 4k 阅读时长 ≈ 4 分钟

考点1:

下列语句序列执行后，输出结果是（）

public class ex{
public static void main(String[]args){
int a=13;
a=a/5；
System.out.println(a);
}
}

A 1
B 2
C 3
D 4

显示答案/隐藏答案

正确答案: B

a是int类型,13/5得到一个浮点类型,浮点类型转成整数类型的原则是,不四舍五入,直接截断小数点后的部分.

整数相除之后还是整数，会丢失掉小数部分的数值。

13/5取商为2，然后再赋值给a,所有输出a=2。

考点2:

设有下面一段代码：

class  Student  extends  Person {
long    id;     // 身份证号
int  score;  // 入学总分
String  name;   // 姓名
int  getScore(){
return  score;
}
}

问：类 Person 和类 Student 的关系是（）。

A 包含关系
B 继承关系
C 关联关系
D 无关系，上述类定义有语法错误

显示答案/隐藏答案

正确答案: B

考点3:

下列不属于类及类成员的访问控制符是：（）

A public
B private
C static
D protected

显示答案/隐藏答案

正确答案: C

作用域	当前类	同包	子类	其他
Public	√	√	√	√
Protected	√	√	√	×
Default	√	√	×	×
Private	√	×	×	×

考点4:

以下程序会输出什么

int a =100,b=50,c=a---b,d=a---b;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);

A 100 48 48 49
B 100 49 48 52
C 98 50 50 49
D 98 50 50 48

显示答案/隐藏答案

正确答案: C

1 2	c=a---b 等于c=a-- -b 等于c=100-50=50,a=99 b=a---b 等于c=a-- -b 等于d=99-50=49,a=98

综上得到：

1	a=98,b=50,c=50,d=49

https://www.cnblogs.com/antineutrino/p/3301843.html

Java运算符优先级

优先级	运算符	结合性
1	`()`、`[]`、`{}`	从左向右
2	`!`、`+`、`-`、`~`、`++`、`--`	从右向左
3	`*`、`/`、`%`	从左向右
4	`+`、`-`	从左向右
5	`<<`、`>>`、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	`^`	从左向右
10	\|	从左向右
11	&&	从左向右
12	\|\|	从左向右
13	`?:`	从右向左
14	`=`、`+=`、`-=`、`*=`、`/=`、&=、\|=、^=、`~=`、`<<=`、`>>=`、>>>=	从右向左

http://c.biancheng.net/view/794.html

运算符的结合性

许多操作符的优先级都是相同的。这时，操作符的结合性就开始发挥作用了。在表达式中如果有几个优先级相同的操作符，结合性就起仲裁的作用，由它决定哪个操作符先执行。先执行，可以看做是加上括号。

比如，右结合（从右到左），那就是，把右边的运算用括号先括起来，再与左边的进行计算，这样自然是先执行右边的了。比如

int a,b=1,c=2;
a=b=c;
```  
这里'='的结合性是从右到左。 故a=b=c; 可变为a=(b=c);  即a=2。

# 考点5:
通过HttpServletRequest. getParameter获取的参数.
- A 总是采用UTF-8编码
- B 总是采用lS08859-1编码
- C 由客户端浏览器和Web容器配置共同决定编码
- D 由服务器所在的操作系统决定编码

<details><summary>显示答案/隐藏答案</summary>正确答案: C</details>



选C
1、浏览器根据jsp页面开头声明的编码方式对request中参数编码；
2、tomcat默认解码是ISO-8859-1，
但是我们可以显示指定解码格式
- 通过调用request.setCharacterEncoding("UTF-8")，
- 或者修改tomcat的配置文件server.xml中的编码，添加uriEncoding属性。

# 考点6:
```java
public class IfTest{
    public static void main(String[]args){
        int x=3;
        int y=1;
        if(x=y)
            System.out.println("Not equal");
        else
            System.out.println("Equal");
     }
}

下面结果输出是？

A The output is “Equal”
B The output in “Not Equal”
C An error at line 5 causes compilation to fall.
D The program executes but does not print a message.

显示答案/隐藏答案

正确答案: C

这个题考查两个知识点。
1、Java中，赋值是有返回值的，赋什么值，就返回什么值。比如这题，x=y，返回y的值，所以括号里的值是1。
2、Java跟C的区别，C中赋值后会与0进行比较，如果大于0，就认为是true；而Java不会与0比较，而是直接把赋值后的结果放入括号。

这题，我忽略了第二点。

考点8:

下面的输出结果是什么？

public class Demo {
  public static void main(String args[])
  {
    String str=new String("hello");
    if(str=="hello")
    {
      System.out.println("true");
    }      
    else     {
      System.out.println("false");
    }
  }
}

A true
B false

显示答案/隐藏答案

正确答案: B

==判断的是对象引用地址是否相同，

1	String str1 = new String("hello");

这种方式创建的字符串，和正常创建对象一样，保存在堆区。

1	String str3 = "hello";

这种方式创建的字符串，保存在字符串常量区。

考点9:

以下代码段执行后的输出结果为

public class Test {
    public static void main(String args[]) {
        int x = -5;
        int y = -12;
        System.out.println(y % x);
    }
}

A -1
B 2
C 1
D -2

显示答案/隐藏答案

正确答案: D

无论是正数还是负数，在取余运算时都有：

1	被除数=商×除数+余数

，所以-12=2×(-5)+(-2)，-12是被除数，-5是除数，2是商，余数是-2。

%是取余运算最后符号和第1个值一样，
Math.floorMod()是取模，最后符号和第2个值一样

System.out.println(-12 % -5);
System.out.println(-12 % 5);
System.out.println(12 % -5);
System.out.println(12 % 5);
System.out.println("===============================");
System.out.println(Math.floorMod(-12, -5));
System.out.println(Math.floorMod(-12, 5));
System.out.println(Math.floorMod(12, -5));
System.out.println(Math.floorMod(12, 5));

运行结果：

-2
-2
2
2
===============================
-2
3
-3
2

%是取余数，结果的符号要看被除数，也就是与第一个数同符号。

考点10:

下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：( )

A java.util.ConcurrentHashMap
B java.util.Map
C java.util.TreeMap
D java.util.SortMap
E java.util.Hashtable
F java.util.HashMap

显示答案/隐藏答案

正确答案: AE

考点11:

character流和byte流的区别不包括（）

A 每次读入的字节数不同
B 前者带有缓冲，后者没有。
C 前者是字符读入，后者是字节读入。
D 二者没有区别，可以互换。

显示答案/隐藏答案

正确答案: ABD

做错两次了，这个不包括，有点绕，题目改成 character流和byte流的说法错误的是，这样简单点

NC101 缺失数字

知识点

描述

示例1

示例2

示例3

NC151 最大公约数

描述

示例1

示例2

备注：

我的解析

使用辗转相除法

使用辗转相减法

精华题解

更相减损法

辗转相除法

网络题解

递归实现

迭代实现

文章2

NC141 判断回文_入门

描述

示例1

示例2

示例3

示例4

备注：

关联企业

关联职位

我的解析

翻转还相等，则是回文

遍历判断是否对称：使用单指针

遍历判断是否对称：使用双指针

NC65 斐波那契数列_入门

描述

输入描述：

返回值描述：

示例1

示例2

示例3

关联企业

关联职位

官方解析

描述

题解

方法一：递归

方法二：记忆化搜索

方法三：动态规划

继续优化

我的解析

递归实现：

记忆化搜索

动态规划法：

进一步优化

NC103 反转字符串

描述

示例1

示例2

关联企业

关联职位

我的题解

官方 精华题解

视频

文字题解

解法一:

解法二:

解法三:

考点1:int除法

考点2:继承

考点3:访问控制符

考点4:自增，自减运算符

Java运算符优先级

运算符的结合性

考点5:Servlet

考点6:比较运算符 赋值运算符

考点8:==运算符

考点9:负数求余运算

考点10:多线程安全支持的Map

考点11:

官方精华题解

考点6:比较运算符赋值运算符

Maven的作用：除了以程序构建能力为特色之外，还提供高级项目管理工具。