【Java每日一题】Java笔试100题（1）

【Java每日一题】

1. 末尾0的个数——滴滴笔试编程题

题目描述：输入一个正整数n,求n!(即阶乘)末尾有多少个0？ 比如: n = 10; n! = 3628800,所以答案为2
原题链接：https://www.nowcoder.com/questionTerminal/6ffdd7e4197c403e88c6a8aa3e7a332a

/*

算法思想：最简单的就是**分解质因数**

n! = n * (n-1) * (n-2) * (n-3) ... * 3 *  2  * 1

对其中的每一个数进行分解因数

末尾的0是由5和2形成的，2、6、8都可以分解出2，所以2的个数肯定远远大于5的个数，所以解题关键就在于看每一个数的因数中有多少个5

*/
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        for(int i = n ; i>=5 ; i--){
            int tmp = i;
            //只要该数是5的倍数，就一直进行分解
            while(tmp % 5 == 0){
                count++;
                //这个数可能不止一个因数5
                tmp = tmp / 5;
            }
        }
        System.out.println(count);
    } 
}

2. 在jdk1.5之后，下列 java 程序输出结果为______。

(2016阿里巴巴笔试题)

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

A. true,false
B. true,true
C. false,true
D. false,false
E. 对于不同的环境结果不同
F. 程序无法执行

解析： JDK1.5以上支持自动拆装箱
装包/装箱：将简单类型包装成包装类型

//自动装包/装箱
Integer a=10;
//手动装包/装箱：
Integer b = Integer.valueOf(10);

拆包/拆箱：将包装类型折成简单类型

//自动拆包/拆箱
Integer a=10;
int b=a;
//手动拆包/拆箱
Integer a=10;
double b = a.doubleValue();
//int b = a.intValue();

Integer值在-128-127之间，每次缓存去取就行，不在这个范围的话，每次都会new一个新的对象

//a == b比较的是a、b的地址

Integer a=100;//在范围里
Integer b=100;
System.out.println(a==b);//返回true

Integer a=150;//不在范围
Integer b=150;
System.out.println(a==b);//返回false

1. 基本类型和基本类型封装型进行 “ == ” 比较的时候，基本类型封装型会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较；
2. 两个Integer类型进行 “==” 比较时，如果其值在-128~127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关。
3. 两个基本类型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4. 本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

3.

代码片段

byte b1 = 1,b2 = 2,b3,b6;
final byte b4 = 4,b5 = 6;
b6 = b4 + b5;
b3 = (b1 + b2);
System.out.println(b3 + b6);

关于上面代码片段叙述正确的是（）
A. 输出结果：13
B. 语句：b6=b4+b5编译出错
C. 语句：b3=b1+b2编译出错
D. 运行期抛出异常

解析： 被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了
b1和b2是byte类型，java中进行计算时候将他们 自动提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。
Java中的byte，short，char进行计算时都会提升为int类型。

4.下面代码运行结果是（）

(360笔试题2016)

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语句块

解析：1.try-catch-finally语句中，finally是一定会执行的
2.一个方法有多个return语句的时候，遇到第一个return语句后，后面的就不会再执行了
3.当程序执行到try{}语句中的return方法时，它会将要返回的结果存储到一个临时栈中，然后程序不会立即返回，而是去执行finally{}中的程序
4.执行完之后，就会通知主程序“finally的程序执行完毕，可以请求返回了”，这时，就会将临时栈中的值取出来返回。这下应该清楚了，要返回的值是保存至临时栈中的。

5.对文件名为Test.java的java代码描述正确的是( )

(腾讯笔试题2016)

class Person {
    String name = "No name";
    public Person(String nm) {
        name = nm;
    }
}
class Employee extends Person {
    String empID = "0000";
    public Employee(String id) {
        empID = id;
    }
}
public class Test {
    public static void main(String args[]) {
        Employee e = new Employee("123");
        System.out.println(e.empID);
    }
}

A. 输出：0000
B. 输出：123
C.编译报错
D.输出：No name

解析： 1. 子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。
2. 而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。
3. 解决办法是在构造函数第一行使用super关键字

6.执行以下程序后的输出结果是（）

(360笔试题2016)

public class Test {
    public static void main(String[] args) {
        StringBuffer a = new StringBuffer("A"); 
        StringBuffer b = new StringBuffer("B"); 
        operator(a, b); 
        System.out.println(a + "," + b); 
    } 
    public static void operator(StringBuffer x, StringBuffer y) { 
        x.append(y); y = x; 
    }
}

A. A,A
B. A,B
C. B,B
D. AB,B

解析：

7.ArrayList list = new ArrayList(20);中的list扩充几次

A. 0
B. 1
C. 2
D. 3

解析： ArrayList的构造函数总共有三个：
（1）ArrayList()构造一个初始容量为 10 的空列表。
（2）ArrayList(Collection c)构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
（3）ArrayList(int initialCapacity)构造一个具有指定初始容量的空列表。
调用的是第三个构造函数，直接初始化为大小为20的list，没有扩容，所以选择A

8. 无缓存交换

题目描述：请编写一个函数，函数内不使用任何临时变量，直接交换两个数的值。
给定一个int数组AB，其第零个元素和第一个元素为待交换的值，请返回交换后的数组。
测试样例：[1,2]
返回：[2,1]

import java.util.*;

public class Exchange {
    public int[] exchangeAB(int[] AB) {
        // write code here
        AB[0] = AB[0] + AB[1];
        AB[1] = AB[0] - AB[1];
        AB[0] = AB[0] - AB[1];
        return AB;
    }
}

8.error && Exception

9.默认类型等价表示是哪一项:

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

A. public String NAME=“default”;
B. public static String NAME=“default”;
C. public static final String NAME=“default”;
D. private String NAME=“default”;

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

10.下面有关JVM内存，说法错误的是？

(阿里巴巴笔试题)

A. 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B. 虚拟机栈描述的是Java方法执行的内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C. 方法区用于存储JVM加载的类信息、常量、静态变量、以及编译器编译后的代码等数据，是线程隔离的
D. 原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的

解析：
Java 运行时数据区可以分成 方法区、 堆、 栈、 程序计数器、 本地方法栈
堆：Java 对象， 线程之间共享的
栈：方法运行，每一个方法对应一个栈帧，每一个线程对应一个栈，
每个栈帧包括 操作数、局部变量表、指向运行时常量池的引用，方法返回地址、附加位区 所以是线程不共享
方法区（静态区）：被虚拟机加载的类信息、静态（static）变量，常量（final），即时编译器编译后的代码等数据。运行常量池是方法区的一部分，class文件除了有类的版本、字段、接口、方法等描述信息之外，还有一项信息常量池保存编译期生成的字面量和符号引用。 线程之间共享的
程序计数器：指出某一个时候执行某一个指令、执行完毕之后要返回的位置，当执行的Java方法的时候，这里保存的当前执行的地址，如果执行的是本地方法的时候，那么程序计数器为空。线程不共享。

11.下列程序的运行结果是()

(大众点评笔试题2016)

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

A. dazhongdianping
B. dianpingdazhong
C. a和b都有可能
D. dianping循环输出，dazhong夹杂在中间

解析： 这里的t.run()就是一个简单的方法调用，没有t.start(),所以并没有启动线程,所以就按代码顺序进行
要是t.run()改为t.start()的话，理论上选C，但是我试了很多次并没有复现B的情况，应该是因为主线程抢占CPU比较有优势

12.有以下类定义：

(爱奇艺笔试题2016)

abstract class Animal{
    abstract void say();
}
public class Cat extends Animal{
    public Cat(){
        System.out.printf("I am a cat");
    }
    public static void main(String[] args) {
        Cat cat=new Cat();
    }
}

运行后：
A. I am a cat
B. Animal能编译，Cat不能编译
C Animal不能编译，Cat能编译
D. 编译能通过，但是没有输出结果

解析： 这里子类未实现父类的的方法，则不能被实例化，编译不通过

包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法，抽象类也可以不包含抽象方法。抽象方法没有方法体。

注意，抽象类和普通类的主要有三点区别：
1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
2）抽象类不能用来创建对象，就是不能实例化。
3）如果一个类继承于一个抽象类，则子类必须实现（重写）父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。
在其他方面，抽象类和普通的类并没有区别。

13.超长正整数相加

题目描述：请设计一个算法完成两个超长正整数的加法。

(1)

//使用java提供的大数直接相加
import java.util.*;
import java.math.*;//导入包
public class Main {
public static void main(String[] args) {

    Scanner in=new Scanner(System.in);
    while(in.hasNext()){
        String a=in.next();
        String b=in.next();
        BigInteger sum=new BigInteger(a);
        BigInteger sum1=new BigInteger(b);
        BigInteger res=sum.add(sum1);
        System.out.println(res);
        }
    }
}

(2)

/*1. 将两个字符串如
5412365768
214125
补成
05412365768
00000214125  //注意这里前面要再多加一个0，用做进位用
2. 设置一个进位标志int t
从后往前逐个往前判断
每一个对应位的整数相加看标志位t是否大于10
大于10的话 ，减10后加到一个字符串后，把标志位置为1
小于10的话     直接加到一个字符串后，把标志位设为0
3. string倒过来，减去开头（为0的话）后输出*/
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String s1 = sc.next();
            String s2 = sc.next();
            while (s1.length() != s2.length()) {//补齐
                if (s1.length() < s2.length()) {
                    s1 = "0" + s1;
                } else {
                    s2 = "0" + s2;
                }
            }
            s1 = "0" + s1;
            s2 = "0" + s2;//加零
            int len1 = s1.length() - 1;
            int len2 = s2.length() - 1;
            String res = "";
            int t = 0;
            
            while (len1 >= 0 && len2 > 0) {
            //两个字符相减得到的是ASCII码，这里我绕了半天
            //这里减 '0' 就得到了这个字符本身的值
                int x = (s1.charAt(len1) - '0') + (s2.charAt(len2) - '0') + t;
                if (x > 9) {
                    res = res + (x - 10);
                    t = 1;
                } else {
                    res = res + x;
                    t = 0;
                }
                len1--;
                len2--;
            }
            StringBuilder sb = new StringBuilder(res);
            res = sb.reverse().toString();
            
            if (res.charAt(0) == '0') {
                System.out.println(res.substring(1));//将首位的0省略
            } else {
                System.out.println(res);
            }
        }
    }
}

14.跟奥巴马一起编程

题目描述
?* 输入描述:
输入在一行中给出正方形边长N（3<=N<=20）和组成正方形边的某种字符C，间隔一个空格。

• 输出描述:
  输出由给定字符C画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的 行数实际上是列数的50%（四舍五入取整）。
• 输入例子:
  10 a
• 输出例子:
  

import java.util.Scanner; 
public class Main {

    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int size=input.nextInt();
        char c=input.next().charAt(0);
        char[][] arr=new char[size/2+size%2][size];
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
            //将二维数组的每个元素都初始化为指定字符
                arr[i][j]=c;
            }
        }
        for(int i=1;i<arr.length-1;i++){
            for(int j=1;j<arr[i].length-1;j++){
            //将中间的部分用 ' '代替即可 
                arr[i][j]=' ';
            }
        }
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }
}

15. 在java7中,下列哪个说法是正确的:

(网易笔试练习卷)

A. ConcurrentHashMap使用synchronized关键字保证线程安全
B. HashMap实现了Collection接口
C. Arrays.asList方法返回java.util.ArrayList对象
D. SimpleDateFormat对象是线程不安全的

解析：
hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。
hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。
concurrentHashMap采用分段加锁的机制来确保安全

16.下列语句正确的是（ ）

(腾讯笔试题2014)

A. 形式参数可被视为local variable
B. 形式参数可被所有的字段修饰符修饰
C. 形式参数为方法被调用时，是真正被传递的参数
D. 形式参数不可以是对象

解析：
local variable, 局部变量:在方法体中声明的变量。
形参可以看成方法中的局部变量。 传递的是对象引用

17.下列哪些语句关于内存回收的说明是正确的? ( )

A. 程序员必须创建一个线程来释放内存
B. 内存回收程序负责释放无用内存
C. 内存回收程序允许程序员直接释放内存
D. 内存回收程序可以在指定的时间释放内存对象

解析：
A、JVM一旦启动，就会创建一个守护线程来监测是否需要有对象内存被释放。JVM会自己创建垃圾回收线程
C、程序员无法释放内存，程序员最多是使用System.gc()和Runtime.getRuntime().gc()通知系统释放内存；
D、不可以指定时间，System.gc()，只是提醒JVM可以进行一次Full GC，但是什么时候真正执行，还是不知道的。系统释放内存时间是不确定的，会根据当前程序的内存使用情况而定。

18. 若有定义语句： int a=10 ; double b=3.14 ; 则表达式 ‘A’+a+b 值的类型是（）

A. char
B. int
C. double
D. float

解析： 类型大的与类型小的运算，强制转换类型小的
char < short < int < float < double 不同类型运算结果类型向右边靠齐

19.以下哪项不属于java类加载过程？

(大众点评笔试题2016)

A. 生成java.lang.Class对象
B. int类型对象成员变量赋予默认值
C. 执行static块代码
D. 类方法解析

解析：
类的加载包括：加载，验证，准备，解析，初始化。
选项A：生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口。
选项B：既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。
选项C：这个会调用。可以用反射试验。
选项D：类方法解析发生在解析过程。

20.另类加法

t题目描述：请编写一个函数，将两个数字相加。不得使用+或其他算数运算符。
给定两个int A和B。请返回A＋B的值
测试样例：1,2
返回：3

public int addAB(int A, int B) {
    int xor,and;
    while(B!=0){
        xor = A^B;
        and = (A&B)<<1;
        A=xor;
        B=and;
    }
    return A;
}

21. instanceof运算符能够用来判断一个对象是否为

(爱奇艺笔试题2016)

A. 一个类的实例
B. 一个实现指定接口的类的实例
C. 全部正确
D. 一个子类的实例

解析： instance：二元运算符
用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例

22. jre判断程序是否执行结束的标准是（）

(斐讯笔试题2017秋招)

A. 所有的前台线程执行完毕
B. 所有的后台线程执行完毕
C. 所有的线程执行完毕
D. 和以上都无关

解析： main()函数即主函数，是一个前台线程，前台进程是程序中必须执行完成的，而后台线程不管有没有完成都是j在ava中所有前台结束后结束。

23. 下列哪个类的声明是正确的？

A. abstract final class HI{}
B. abstract private move(){}
C. protected private number;
D. public abstract class Car{}

解析：
A只能有final和abstract的一个，因为final是最终类，不能继承，必须可以创建实例，而abstract是抽象类，只能继承。
B抽象方法没有方法体。
C访问修饰符只能有一个，而且对象没有类型。
D正确，抽象类。

24. 二叉树的镜像

题目描述：
操作给定的二叉树，将其变换为源二叉树的镜像

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
	//递归
    public void Mirror(TreeNode root) {
        if(root == null) return;
        if(root.left == null && root.right == null) return;
        if(root.left != null){
            Mirror(root.left);
        }
        if(root.right != null){
            Mirror(root.right);
        }
        TreeNode tmp = null;
        tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

25.HashSet子类依靠()方法区分重复元素。

(大众点评笔试题2016)

A. toString(),equals()
B. clone(),equals()
C. hashCode(),equals()
D. getClass(),clone()

解析：
HashSet内部使用Map保存数据，即将HashSet的数据作为Map的key值保存，这也是HashSet中元素不能重复的原因。而Map中保存key值前，会去判断当前Map中是否含有该key对象，内部是先通过key的hashCode，确定有相同的hashCode之后，再通过equals方法判断是否相同。

26. 有这么一段程序：

(新浪微博校招笔试题2015)

public class Test{ 
    public String name="abc"; 
    public static void main(String[] args){ 
        Test test=new Test(); 
        Test testB=new Test(); 
        System.out.println(test.equals(testB)+","+test.name.equals(testB.name)); 
    } 
}

请问以上程序执行的结果是（）
A. true,true
B. true,false
C. false,true
D. false,false

解析:
equals没重写时候和==一样，比较的是对象的地址
string类型中的equals方法Java默认重写了，可以比较对象里的值

27.以下程序执行的结果是：

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

A. ZYXX
B. ZYXY
C. YXYZ
D. XYZX

解析：
初始化顺序：

1. 父类中的静态成员变量和静态代码块 ；
2. 子类中的静态成员变量和静态代码块 ；
3. 父类的普通成员变量和代码块，再执行父类的构造方法；
4. 子类的普通成员变量和代码块，再执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y
（2）再执行父类的构造方法；输出X
（3） 初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y
（4）再执行子类的构造方法；输出Z

28.以下代码在编译和运行过程中会出现什么情况

(爱奇艺2016笔试题)

public class TestDemo{
    private int count;
    public static void main(String[] args) {
        TestDemo test=new TestDemo(88);
        System.out.println(test.count);
    }
     TestDemo(int a) {
         count=a;
    }
}

A. 编译运行通过，输出结果是88
B. 编译时错误，count变量定义的是私有变量
C. 编译时错误，System.out.println方法被调用时test没有被初始化
D. 编译和执行时没有输出结果

**解析：

1. 实例化一个类的时候，首先会调用他的构造方法，所以构造方法写在main函数之后也是不影响的
2. private是私有变量，只能用于当前类中，题目中的main方法也位于当前类，所以可以正确输出

29.以下叙述正确的是

(斐讯2017秋招)

A. 实例方法可直接调用超类的实例方法
B. 实例方法可直接调用超类的类方法、
C. 实例方法可直接调用子类的实例方法
D. 实例方法可直接调用本类的实例方法

解析：
java中超类也叫做子类，直接调用的意思是直接填写方法名就能调用的意思。

如果父类里被private修饰，则子类是无法继承和访问的，而父类访问子类，需要new一个对象才能访问

A错误，类的实例方法是与该类的实例对象相关联的，不能直接调用，只能通过创建超类的一个实例对象，再进行调用
B错误，当父类的类方法定义为private时，对子类是不可见的，所以子类无法调用
C错误，子类具体的实例方法对父类是不可见的，所以无法直接调用， 只能通过创建子类的一个实例对象，再进行调用

30.以下代码输出的是：

(爱奇艺笔试题2016)

public class SendValue{
    public String str="6";
    public static void main(String[] args) {
        SendValue sv=new SendValue();
        sv.change(sv.str);
        System.out.println(sv.str);
    }
    public void change(String str) {
        str="10";
    }
}

A. 6
B. 10
C. 都不对
D. 16

解析：
change里的str="10"是为参数传入的str ，而不是对象本身成员变量，是值传递。如果change中，this.str = “10”，则输出结果又不一样了。

31.在jdk1.5的环境下，有如下4条语句：

(人人网笔试题)

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

以下输出结果为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);

解析：
JVM中一个字节以下的整型数据会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象
所有只有i04是一个新对象，其他都是同一个对象。所有A，B选项为true
C选项i03和i04是两个不同的对象，返回false
D选项i02是基本数据类型，比较的时候比较的是数值，返回true

32.关于以下程序代码的说明正确的是?

(人人网笔试题)

1.     public class HasStatic{
2.     private static int x=100;
3.     public static void main(String args[]){
4.          HasStatic hs1=new HasStatic();
5.          hs1.x++;
6.          HasStatic  hs2=new HasStatic();
7.          hs2.x++;
8.          hs1=new HasStatic();
9.          hs1.x++;
10.        HasStatic.x--;
11.        System.out.println("x="+x);
12.     }
13.   } 

A. 程序通过编译，输出结果为：x=103
B. 10行不能通过编译，因为x是私有静态变量
C. 5行不能通过编译，因为引用了私有静态变量
D. 程序通过编译，输出结果为：x=102

解析：
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块
static变量在第一次使用的时候初始化，但只会有一份成员对象。

33.微信红包

(腾讯2016编程题)

题目描述：
春节期间小明使用微信收到很多个红包，非常开心。在查看领取红包记录时发现，某个红包金额出现的次数超过了红包总数的一半。请帮小明找到该红包金额。写出具体算法思路和代码实现，要求算法尽可能高效。
给定一个红包的金额数组gifts及它的大小n，请返回所求红包的金额。
若没有金额超过总数的一半，返回0。
测试样例：
[1,2,3,2,2],5
返回：2

/*
1.将数组排序
2.若存在个数大于 总数/2 的红包，那么这个红包必定在排序后数组的2/n处
3.也可能不存在这样的红包
*/
import java.util.*;

public class Gift {
    public int getValue(int[] gifts, int n) {
        Arrays.sort(gifts);
        int res = gifts[n/2];
        int flag = 0;//排序后数组中间那个金额的红包出现的次数
        for(int i = 0 ;i < n ;i++){
            if(gifts[i] == res){
                flag++;
            }
        }
        if(flag > n/2) return res;
        else return 0;
    }
}

34. 链表分割

题目描述：编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前
给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。

/*

1.需要用到两个链表，一个存放比x小的值(small)，一个存放比x大的值(big)
2.设置一个ListNode指向小的头(res)，再设置一个指向大的头(tmp)
  res就是两个链表合并后的头结点
3.分好后，tmp.next和small.next连接

*/

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        ListNode small = new ListNode(-1);//存放比x小的值
        ListNode big = new ListNode(-1);//存放比x大的值
        ListNode res = small;//要返回的头节点
        ListNode tmp = big;//大链表的头，要连接小链表的尾
        ListNode cur = pHead;//指向当前指向的结点
        ListNode curNext = null;//当前节点的下一个结点
        
        while (cur != null){
            curNext = cur.next;
            if (cur.val < x){
                small.next = cur;
                cur.next = null;
                small = small.next;
            }else {
                big.next = cur;
                cur.next = null;
                big = big.next;
            }
            cur = curNext;
        }
        small.next = tmp.next;
        return res.next;
        
    }
}

35. 对递归程序的优化的一般的手段为（）

(顺丰2017校招)

A. 尾递归优化
B. 循环优化
C. 堆栈优化
D. 停止值优化

解析：（PS：这题我是没太懂）
递归的优化手段有：尾递归，迭代，循环
尾递归：在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。

36.以下数据结构说法，错误的是___?

(阿里巴巴笔试题)

A. 红黑树插入操作的平均时间复杂度为O(logn)，最坏时间复杂度为O(logn)
B. B+树插入操作的平均时间复杂度为O(logn)，最坏时间复杂度为O(logn)
C. Hash表插入操作的平均时间复杂度为O(logn)，最坏时间复杂度为O(n)
D. 排序链表插入操作的平均时间复杂度为O(n)，最坏时间复杂度为O(n)

解析：

37.链式A+B

题目描述：
有两个用链表表示的整数，每个结点包含一个数位。这些数位是反向存放的，也就是个位排在链表的首部。编写函数对这两个整数求和，并用链表形式返回结果。、
给定两个链表ListNode* A，ListNode* B，请返回A+B的结果(ListNode*)
测试样例：
{1,2,3},{3,2,1}
返回：
{4,4,4}

/*
一般相加需要考虑两个问题：
1.进位问题
2.长短不一致问题

*/

import java.util.*;
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/

public class Plus {
    public ListNode plusAB(ListNode a, ListNode b) {
        ListNode head = new ListNode(0);
        ListNode p = head;
        int sum = 0;
        while (a != null || b != null || sum != 0) {
            if (a != null) {
                sum += a.val;
                a = a.next;
            }
            if (b != null) {
                sum += b.val;
                b = b.next;
            }
            p.next = new ListNode(sum % 10);
            sum /= 10;
            p = p.next;
        }
        return head.next;
    }
}

38. 到底买不买

题目描述：
小红想买些珠子做一串自己喜欢的珠串。卖珠子的摊主有很多串五颜六色的珠串，但是不肯把任何一串拆散了卖。于是小红要你帮忙判断一
下，某串珠子里是否包含了全部自己想要的珠子？如果是，那么告诉她有多少多余的珠子；如果不是，那么告诉她缺了多少珠子。
为方便起见，我们用[0-9]、[a-z]、[A-Z]范围内的字符来表示颜色。例如，YrR8RrY是小红想做的珠串；那么ppRYYGrrYBR2258可以买，因为包含了
全部她想要的珠子，还多了8颗不需要的珠子；ppRYYGrrYB225不能买，因为没有黑色珠子，并且少了一颗红色的珠子。
输入描述:
每个输入包含1个测试用例。每个测试用例分别在2行中先后给出摊主的珠串和小红想做的珠串，两串都不超过1000个珠子。
输出描述:
如果可以买，则在一行中输出“Yes”以及有多少多余的珠子；如果不可以买，则在一行中输出“No”以及缺了多少珠子。其间以1个空格分隔。
示例1
输入
ppRYYGrrYBR2258
YrR8RrY
输出
Yes 8

/*
1. 用map将原有的珠串的颜色数量存起来
2. 遍历需要的珠串，如果map中含有该颜色珠子，map中该颜色珠子数量减一
3. map中含有该颜色珠子，但是个数为0，缺少珠子个数加一
4. map中根本不含有该颜色珠子，缺少珠子个数加一

*/

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String oldStr = sc.nextLine();
        String needStr = sc.nextLine();
        Map<Character,Integer> map = new HashMap<>();
        
        char[] chars = oldStr.toCharArray();
        for(int i = 0 ;i < chars.length ;i++){
            if(map.containsKey(chars[i])){
                int count = map.get(chars[i]);
                map.put(chars[i],count+1);
            }else{
                map.put(chars[i],1);
            }
        }
        
        char[] needChars = needStr.toCharArray();
        int lastCount = 0;//缺的珠子个数
        for(int i = 0 ;i < needChars.length ;i++){
            if(map.containsKey(needChars[i])){
                if(map.get(needChars[i]) > 0){
                    int count = map.get(needChars[i]);
                    map.put(needChars[i],count-1);
                }else{
                   //map中当前颜色的珠子已经用完
                    lastCount++;
                }
            }else{
            ///map中不含有当前遍历到的颜色的珠子，缺少的珠子个数加一
                lastCount++;
            }
        }
       
        if (lastCount==0){//说明不缺少珠子，可以买
            System.out.println("Yes "+(oldStr.length()-needStr.length()));
        }else {//缺少珠子
            System.out.println("No "+lastCount);
        }
    }
}

39. 已知关键字序列5,8,12,19,28,20,15,22是最小堆，插入关键字3，调整后得到的最小堆是()

(爱奇艺2016开发工程师笔试题)

A. 3,8,12,5,20,15,22,28,19
B. 3,5,12,19,20,15,22,8,28
C. 3,12,5,8,28,20,15,22,19
D. 3,5,12,8,28,20,15,22,19

解析：

调整就是将要插入的元素加到二叉树末尾，依次向上调整
具体步骤如下：

1. 将待插入元素加至末尾
2. 19 > 3，交换
3. 8 > 3，交换
4. 5 > 3，交换
   

40. 一棵完全二叉树第六层有9个叶结点（根为第一层），则结点个数最多有（）

(4399 2017秋招)

A. 112
B. 111
C. 107
D. 109

解析：
第六层有9个叶子节点的意思是，第六层有9个结点没有孩子，这就代表第七层会少 9*2 个结点，结点个数 = 1 + 2 + 4 + 8 + 16 + 32 + 64 - 18 = （2 * 7 - 1）- 18 = 109

41. 两个人两个小时能组装两辆自行车,要在6小时内组装12辆自行车,需要多少人?

（搜狗2017研发工程师笔试题）

A. 2
B. 3
C. 4
D. 5

解析：

我自己是这样理解的：两个人两个小时两辆车，一个人两个小时一辆车，现在有六个小时，一个人可以组装3辆车，题目需要12辆车，12/3 = 4

42.已知一个线性表（38，25，74，63，52，48），假定采用散列函数h（key) = key%7 计算散列地址，并散列存储在散列表A【0…6】中，若采用线性探测方法解决冲突，则在该散列表上进行等概率成功查找的平均查找长度为()

(腾讯、美团2016研发工程师笔试题)

A. 1.5
B. 1.7
C. 2.0
D. 2.3

解析：
依次取模求出哈希地址：

1. 38%7=3 （第1次出现3，无冲突，放在位置3，查找次数为1）
2. 25%7=4（第1次出现4，无冲突，放在位置4，查找次数为1）
3. 74%7=4（第2次出现4，有冲突，放在位置5，查找次数为2）
4. 63%7=0（第1次出现0，无冲突，放在位置0，查找次数为1）
5. 52%7=3（第2次出现3，有冲突，发现冲突3,4,5，放在位置6，查找次数为4）
6. 48%7=6 （第1次出现6，有冲突，发现冲突6,0，放在位置1，查找次数为3）

A	0	1	2	3	4	5	6
元素	63	48		38	25	74	52
查找次数	1	3		1	1	2	4

题目时等概率查找，所以平均查找长度 = 1/6（1 + 3 + 1 + 1 + 2 +4）=2

43.数字分类

(网易笔试练习卷)

题目描述：
给定一系列正整数，请按要求对数字进行分类，并输出以下5个数字：
A1 = 能被5整除的数字中所有偶数的和；
A2 = 将被5除后余1的数字按给出顺序进行交错求和，即计算n1-n2+n3-n4…；
A3 = 被5除后余2的数字的个数；
A4 = 被5除后余3的数字的平均数，精确到小数点后1位；
A5 = 被5除后余4的数字中最大数字。
输入描述:
每个输入包含1个测试用例。每个测试用例先给出一个不超过1000的正整数N，随后给出N个不超过1000的待分类的正整数。数字间以空格分隔。
输出描述:
对给定的N个正整数，按题目要求计算A1~A5并在一行中顺序输出。数字间以空格分隔，但行末不得有多余空格。
若其中某一类数字不存在，则在相应位置输出“N”。
示例1
输入
13 1 2 3 4 5 6 7 8 9 10 20 16 18
输出
30 11 2 9.7 9

//是的，我用了最简单的暴力法，等以后有了新的思路再来更改
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] nums = new int[N];
        int A1 = 0;
        int A2 = 0;
        int A3 = 0;
        float A4 = 0.0f;
        int A5 = 0;

        for(int i = 0 ;i < N ;i++){
            nums[i] = sc.nextInt();
        }

        for(int i = 0 ;i < N ;i++){
            if(nums[i] % 5 == 0 && nums[i] % 2 == 0){
                A1 += nums[i];
            }
        }

        int flag = 1;
        for(int i = 0 ;i < N ;i++){
            if(nums[i] % 5 == 1){
                A2 += flag*nums[i];
                flag = -flag;
            }

        }

        for(int i = 0 ;i < N ;i++){
            if(nums[i] % 5 == 2){
                A3++;
            }
        }

        int count = 0;
        for(int i = 0 ;i < N ;i++){
            if(nums[i] % 5 == 3){
                count++;
                A4 += nums[i];
            }
        }

        Arrays.sort(nums);
        for(int i = N-1 ;i >= 0 ;i--){
            if(nums[i] % 5 == 4){
                A5 = nums[i];
                break;
            }
        }

        if(A1 != 0){
            System.out.print(A1 + " ");
        }else{
            System.out.print("N" + " ");
        }

        if(A2 != 0){
            System.out.print(A2 + " ");
        }else{
            System.out.print("N" + " ");
        }

        if(A3 != 0){
            System.out.print(A3 + " ");
        }else{
            System.out.print("N" + " ");
        }

        if(A4 != 0){
            System.out.printf("%.1f",A4/count);
            System.out.print(" ");
        }else{
            System.out.print("N" + " ");
        }

        if(A5 != 0){
            System.out.print(A5);
        }else{
            System.out.print("N");
        }
    }
}

44. 二叉树平衡检查

题目描述：
实现一个函数，检查二叉树是否平衡，平衡的定义如下，对于树中的任意一个结点，其两颗子树的高度差不超过1。
给定指向树根结点的指针TreeNode* root，请返回一个bool，代表这棵树是否平衡。

/*


*/
import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class Balance {
    public boolean isBalance(TreeNode root) {
        // write code here
        if(root == null) return true;
        if(Math.abs(getHeight(root.left) - getHeight(root.right)) > 1){
            return false;
        }
        return true;
    }
    
    static int getHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = getHeight(root.left);
        int right = getHeight(root.right);
        return left>right?left+1:right+1;
    }
}

45. 关于进程和线程，下列说法正确的有（）

（小米2019秋招）

A. 线程的粒度小于进程
B. 同一进程内的线程只能串行执行
C. 一个程序只能对应一个进程
D. 线程是CPU调度的基本单位

解析：
一个进程可以有多个线程，一个线程只能属于一个进程，所以线程的粒度小于进程
线程是CPU调度的基本单位，进程是资源分配的基本单位

46.数字之和

题目描述：
对于给定的正整数 n，计算其十进制形式下所有位置数字之和，并计算其平方的各位数字之和。
输入描述:
每行输入数据包括一个正整数n(0 输出描述:
对于每个输入数据，计算其各位数字之和，以及其平方值的数字之和，输出在一行中，之间用一个空格分隔，但行末不要有空格。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            int n2 = n*n;//n的平方值
            int sum1 = 0;//各位数字之和
            int sum2 = 0;//平方值的各数字之和，这里是个坑，有歧义
            while(n > 0){
                int tmp = n;
                tmp = tmp % 10;
                sum1 += tmp;
                n /= 10;
            }
            while(n2 > 0){
                int tmp2 = n2;
                tmp2 = tmp2 % 10;
                sum2 += tmp2;
                n2 /= 10;
            }
            System.out.print(sum1 +" ");
            System.out.print(sum2);
            System.out.println();
        }
    }
}

47.计票统计

题目描述：
请实现接口：
—————————————————————————————————
unsigned int AddCandidate (char* pCandidateName);
功能：设置候选人姓名
输入： char* pCandidateName 候选人姓名
输出：无
返回：输入值非法返回0，已经添加过返回0 ，添加成功返回1
—————————————————————————————————
Void Vote(char* pCandidateName);
功能：投票
输入： char* pCandidateName 候选人姓名
输出：无
返回：无
—————————————————————————————————
unsigned int GetVoteResult (char* pCandidateName);
功能：获取候选人的票数。如果传入为空指针，返回无效的票数，同时说明本次投票活动结束，释放资源
输入： char* pCandidateName 候选人姓名。当输入一个空指针时，返回无效的票数
输出：无
返回：该候选人获取的票数
—————————————————————————————————
void Clear()
// 功能：清除投票结果，释放所有资源
// 输入：
// 输出：无
// 返回
输入描述:
输入候选人的人数，第二行输入候选人的名字，第三行输入投票人的人数，第四行输入投票。
输出描述:
每行输出候选人的名字和得票数量。
示例1
输入
4
A B C D
8
A B C D E F G H
输出
A : 1
B : 1
C : 1
D : 1
Invalid : 4

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            LinkedHashMap<String,Integer> map = new LinkedHashMap<String,Integer>();
            sc.nextLine();
            String str = sc.nextLine();
            String[] array = str.split(" ");
            for(int i=0;i<array.length;i++){
                map.put(array[i],0);
            }
            map.put("Invalid",0);
            
            int m = sc.nextInt();
            sc.nextLine();
            String strr = sc.nextLine();
            String[] arrays = strr.split(" ");
            for(String s :arrays){
                if(map.containsKey(s)){
                    map.put(s,map.get(s)+1);
                }else{
                     map.put("Invalid",map.get("Invalid")+1);
                }
            }
            Set<String> set = map.keySet();
            for(String s :set){
                System.out.println(s+" : "+map.get(s));
                  
            }
        }
    }
}

48.在使用锁保证线程安全时，可能会出现活跃度失败的情况，活跃度失败主要包括

（网易2016实习生笔试）

A. 死锁
B. 饥饿
C. 活锁
D. 以上全部

解析：
在使用锁保证现场安全时可能会出现 活跃度 失败的情况主要包括 饥饿、丢失信号、和活锁、死锁 等。【多线程除了死锁之外遇到最多的就是活跃度问题了】

死锁： 由于资源紧张造成，多个线程由于请求资源而形成一个环路，谁也不退让，导致谁也不能执行；

饥饿 ： 是由于线程优先级造成的， 指线程需要访问的资源被永久拒绝 ，以至于不能再继续进行。解决饥饿问题需要平衡线程对资源的竞争，如线程的优先级、任务的权重、执行的周期等。

活锁： 指线程虽然没有被阻塞，但由于某种条件不满足，一直尝试重试却始终失败。解决活锁问题需要对 重试机制 引入一些随机性。例如如果检测到冲突，那么就暂停随机的一定时间进行重试，这会大大减少碰撞的可能性。

49.对进程和线程的描述,以下正确的是()

(蘑菇街2019笔试题)

A. 父进程里的所有线程共享相同的地址空间,父进程的所有子进程共享相同的地址空间
B. 改变进程里面主线程的状态会影响到其他线程的行为,改变父进程的状态不会影响到其他子进程
C. 多线程会引起死锁,而多进程不会
D. 其他选项都不正确

解析：
父进程和子进程都有自己独立的地址空间；
父进程结束，所有子进程都结束，进程结束，所有线程都结束；
如果多个进程同时占有对方需要的资源而同时请求对方的资源，而它们在得到请求之前不会释放所占有的资源，那么就会导致死锁的发生，也就是进程不能实现同步。
多线程和多进程都会引起死锁，一般说的死锁指的是进程间的死锁。

50.整数与IP地址间的转换

题目描述：
原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成
一个长整数。
举例：一个ip地址为10.0.3.193
每段数字 相对应的二进制数
10 00001010
0 00000000
3 00000011
193 11000001
组合起来即为：00001010 00000000 00000011 11000001,转换为10进制数就是：167773121，即该IP地址转换后的数字就是它了。

import java.util.*;
public class Main{
	public static void main(String[] args) {
    	Scanner sc=new Scanner(System.in);
    	while(sc.hasNext()){
        	String ip=sc.next();
        	String num=sc.next();
        	System.out.println(ipToNum(ip));
        	System.out.println(numToIp(num));
   	 	}
	}
 
	//数字转ip
	public static String numToIp(String num){
    	String bin=Long.toBinaryString(Long.parseLong(num));
  	  	bin="00000000000000000000000000000000"+bin;
   	 	bin=bin.substring(bin.length()-32);
    	StringBuffer sb=new StringBuffer();
    	for(int i=0;i<4;i++){
        	String temp=bin.substring(i*8,(i+1)*8);
        	if(i!=3)
            	sb.append(Integer.parseInt(temp,2)+".");
        	else
            	sb.append(Integer.parseInt(temp,2));
    	}
   	 	return sb.toString();
	}
 
 
	//ip转数字
	public static long ipToNum(String ip){
    	String[] sp=ip.split("\\.");
    	StringBuffer sb=new StringBuffer();
    	for(int i=0;i<sp.length;i++){
        	int temp=Integer.parseInt(sp[i]);
        	String merge="00000000"+Integer.toBinaryString(temp);
       	 	merge=merge.substring(merge.length()-8);
        	sb.append(merge);
    	}
    	return Long.parseLong(sb.toString(),2);
	}
}

51. 下列有关在一个处理器（processor）上跑两个线程（thread）的说法中，正确的是?

（阿里巴巴笔试题）

A. 一个线程可以改变另一个线程的程序计数器（program counter）
B. 一个线程既不能读也不能写另一个线程的栈（stack）
C. 一个线程可以读写另一个线程的寄存器（register）
D. 以上都不对

解析：
同一个进程中的两个线程，全局数据区和堆是相互可见的，栈并不是相互可见的，栈是线程私有的，每个线程都有各自私有的程序计数器、寄存器和栈。

52. 密码验证合格程序

题目描述：
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
说明:长度超过2的子串
输入描述:
一组或多组长度超过2的子符串。每组占一行
输出描述:
如果符合要求输出：OK，否则输出NG

//没有用到正则表达式，后面有时间写了再加上

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
           String str = sc.nextLine();
            if(TestLength(str) == true && TestKinds(str) == true && TestRepeat(str) == true){
                System.out.println("OK");
            }else{
                System.out.println("NG");
            }
        }
    }
    
    static boolean TestLength(String str){//检验长度
        if(str.length() > 8){
            return true;
        }
        return false;
    }
    
    static boolean TestKinds(String str){//检验满足三种以上
        char[] Mychar = str.toCharArray();
        int a=0, b=0, c=0, d=0;
        for(Character x:Mychar){
            if(x>='a' && x<='z'){
                a=1;
            }
            else if(x>='A' && x<='Z'){
                b=1;
            }
            else if(x>='0' && x<='9'){
                c=1;
            }
            else{
                d=1;
            }
            if((a+b+c+d)>=3){
                return true;
            }
        }
        return false; 
    }
    
    static boolean TestRepeat(String str){//检验是否有长度 >2 以上子串
        for(int i = 0 ; i < str.length() - 2 ; i++){
            if(str.substring(i+1).contains(str.substring(i,i+3))){
                return false;
            }
        }
        return true;
    }
}

53. 操作系统中关于竞争和死锁的关系下面描述正确的是？

（美团2016笔试题）

A. 竞争一定会导致死锁
B. 死锁一定由竞争引起
C. 竞争可能引起死锁
D. 预防死锁可以防止竞争

解析：
产生死锁的原因主要是：

1. 因为系统资源不足。
2. 进程运行推进的顺序不合适。
3. 资源分配不当等。

产生死锁的四个必要条件：

1. 互斥条件：一个资源每次只能被一个进程使用。
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3. 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

54. 在所有非抢占CPU调度算法中，系统平均响应时间最优的是（ ）

(腾讯2013笔试题)

A. 实时调度算法
B. 短任务优先算法
C. 时间片轮转算法
D. 先来先服务算法

解析：
短任务优先系统平均响应时间最短，但是往往不能确定所有任务的运行时间
先来先服务平均响应时间最长，不适用于分时系统
时间片轮转，适用于分时系统，但是增加了抢占以切换进程，算法性能依赖于时间片大小

55. 以下哪句的说法是正确的？

（盛趣游戏笔试题）

A. 在页式存储管理中，用户应将自己的程序划分为若干个相等的页
B. 所有的进程都挂起时，系统将陷入死锁
C. 执行系统调用可以被中断
D. 进程优先数是进程调度的重要依据，必须根据进程运行情况动态改变

解析：
A，页的划分是操作系统做的。
B，系统进入死锁必须满足4个条件：互斥、循环并等待、不剥夺、请求与保持；所有的进程都挂起，并不表示这些进程间有资源调用和循环等待的关系，有些进程定时器结束后可能自动唤醒。
D，有静态优先级调度。

56. 如果将固定块大小的文件系统中的块大小设置大一些，会造成（）。

（京东2015校招）

A. 更好的磁盘吞吐量和更差的磁盘空间利用率
B. 更好的磁盘吞吐量和更好的磁盘空间利用率
C. 更差的磁盘吞吐量和更好的磁盘空间利用率
D. 更差的磁盘吞吐量和更差的磁盘空间利用率

解析：
文件是按块存储的，如果块大小设置的大一些，读取的时候一次性读取的就更多，磁盘吞吐量提升，但是文件可能不能占满整个块，导致利用率下降。

57.下面有关Cache的说法哪一个是不正确的?

（去哪儿笔试题）

A. 设置Cache的目的，是解决CPU和主存之间的速度匹配问题
B. 设置Cache的理论基础，是程序访问的局部性原理
C. Cache与主存统一编址，Cache的地址空间属于主存的一部分
D. Cache的功能均由硬件实现，对程序员是透明的

解析：
cache是将主存中的页面缓存供cpu高速存取的设备，它和主存的功能是完全不同的。
cache的地址空间和主存的地址空间是映射关系
cache和主存不统一编址
cache的地址空间也不是主存的一部分。

58. 下列方法中，____不可以用来程序调优？

（阿里巴巴2015笔试题）

A. 改善数据访问方式以提升缓存命中率
B. 使用多线程的方式提高 I/O 密集型操作的效率
C. 利用数据库连接池替代直接的数据库访问
D. 利用迭代替代递归
E. 合并多个远程调用批量发送
F. 共享冗余数据提高访问效率

解析：
建议大家去原题下看看 https://www.nowcoder.com/questionTerminal/e0a6d903b1644b95951e978ea00a5756?toCommentId=605526

59.下列关于线程说法错误的是（）

（4399 2015校招）

A. 耗时的操作使用线程，提高程序响应
== B. 耗内存的操作使用线程，提高内存利用率==
C. 多CPU的系统使用线程，提高CPU利用率
D. 并行操作使用线程，如c/s架构中服务端程序为每个客户端请求创建一个线程来响应

60. 什么是内存抖动（Thrashing）（ ）

（腾讯2013笔试题）

A. 非常频繁的换页活动
B. 非常高的CPU执行活动
C. 一个极长的执行进程
D. 一个极大的虚拟内存

解析：
页面的频繁更换，导致整个系统效率急剧下降，这个现象称为内存抖动。
抖动一般是内存分配算法不好，内存太小引或者程序的算法不佳引起的页面频繁从内存调入调出。

61.大整数排序

//偷懒写法，后面可能会来更新ing
import java.util.*;
import java.math.*;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            BigInteger[] bg = new BigInteger[n];
            for(int i=0; i<n; i++)
                bg[i] = sc.nextBigInteger();
            Arrays.sort(bg);
            for(int i=0; i<n; i++)
                System.out.println(bg[i]);
        }
    }
}

62. 关于计算机网络，下列描述当中，正确的是（）

（4399 2017秋招）

A. 在同一信道上同一时刻，可进行双向数据传送的通信方式是半双工
B. TCP协议是无连接的；UDP协议是面向连接的
C. 假设一个主机的ip地址为192.168.8.123，而子网掩码为255.255.255.248，那么该主机的网络号是192.168.8.120
D. 计算机网络中的OSI结构分别是：物理层，数据链路层，传输层，会话层，表示层，应用层

解析：
A：同一信道同一时刻通信的是全双工，半双工是是指在通信过程的任意时刻，信息既可由A传到B，又能由B传A，但只能 由一个方向上的传输存在。
B：TCP协议是有连接的，UDP是无连接的。
C：IP和子网掩码相与得到网络号，应该是192.168.8.120.
D：OSI 七层协议，少了网络层

63. 下列关于 http 状态码描述正确的是（）

（4399 20117秋招）

A. 404读取浏览器缓存，502错误网关
B. 404找不到资源，403服务器错误
C. 500服务器错误，304读取浏览器缓存
D. 304服务器错误，200请求成功
E. 500找不到资源，200请求成功

常见的http状态码要记一些，这些就靠平时积累了

64. 说反话

题目描述：
给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。

输入描述:
测试输入包含一个测试用例，在一行内给出总长度不超过80的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用1个空格分开，输入保证句子末尾没有多余的空格。
输出描述:
每个测试用例的输出占一行，输出倒序后的句子。

/*split方法就是根据指定的字符将字符串分割，得到的是一个String类型的数组*/

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String[] array = str.split(" ");
        for(int i = array.length - 1 ;i > 0 ;i--){
            System.out.print(array[i] + " ");
            
        }
        System.out.print(array[0]);
    }
}

65. 建立一条TCP连接需要（）个步骤，关闭一个TCP连接需要（）个步骤

A. 4，3
B. 4，4
C. 3，4
D. 3，3

解析：
建立TCP连接需要三次握手:即发送方发送SYN包，接收方接收SYN包并发送SYN+ACK包，发送方接收SYN+ACK包发送ACK确认包
释放TCP连接需要四次握手:即发送方发送FIN包主动关闭连接，接收方接收FIN包并发送ACK确认包，发送方接收到ACK包后接收方发送FIN包，发送方发送ACK确认包

66. 通过POP3 协议接收邮件时，使用的传输层服务类型是（）

（蘑菇街2018笔试题）

A. 无连接不可靠的数据传输服务
B. 无连接可靠的数据传输服务
C. 有连接不可靠的数据传输服务
D. 有链接可靠的数据传输服务

解析：
POP3 建立在 TCP 连接上,使用的是有连接可靠的数据传输服务。

67. 当使用TCP协议编程时，下列问题哪个是必须由程序员考虑和处理的？

A. 乱序数据包的重传
B. 数据传输过程中的纠错
C. 网络拥塞处理
D. 发送数据的格式和应用层协议

解析：
TCP协议的主要功能是完成对数据报的确认、流量控制和网络拥塞；自动检测数据报，并提供错误重发的功能；将多条路径传送的数据报按照原来的顺序进行排列，并对重复数据进行择取；控制超时重发，自动调整超时值；提供自动恢复丢失数据的功能。因此，除TCP功能以外需要程序员考虑的为发送数据的格式及应用层协议。

68. Broken Keyboard

题目描述：
On a broken keyboard, some of the keys are worn out. So when you type some sentences, the characters
corresponding to those keys will not appear on screen.
Now given a string that you are supposed to type, and the string that you actually type out, please list those keys
which are for sure worn out.
输入描述:
Each input file contains one test case. For each case, the 1st line contains the original string, and the 2nd line contains the typed-out string. Each string contains
no more than 80 characters which are either English letters [A-Z] (case
insensitive), digital numbers [0-9], or “_” (representing the space). It is guaranteed that both strings are non-empty.
输出描述:
For each test case, print in one line the keys that are worn out, in the order of being detected. The English letters must be capitalized.
Each worn out key must be printed once only. It is guaranteed that there is at least one worn out key.

1.

import java.util.*;
public class Main {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        String a = sc.nextLine();
        String b = sc.nextLine();
        LinkedHashSet<Character> set = new LinkedHashSet<>();
        for (int i = 0;i<a.length();i++){
        //b中不包括的a的元素 也就是坏掉的键 加进set，set自带自动去重的功能
            if(!b.contains(String.valueOf(a.charAt(i)))){
                char x = Character.toUpperCase(a.charAt(i));
                set.add(x);
            }
        }
        for(Character character: set){
            System.out.print(character);
        }
    }
}

2.

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String first=sc.next();//7_This_is_a_test
        String second=sc.next();// _hs_s_a_es
        first=first.toUpperCase();
        second=second.toUpperCase();
        for(int i=0;i<second.length();i++){
            //将能打出来的都替换掉，剩余的是未去重的坏掉的键（大写）
            first=first.replace(second.charAt(i)+"","");//7TIITT
        }
        String coutStr="";
        for(int i=0;i<first.length();i++){
            if(coutStr.contains(first.charAt(i)+"")){
                continue;
            }else{
                System.out.print(first.charAt(i));
                coutStr+=first.charAt(i);//已经打印过的字符就加在coutstr后面，再有一样的字符进来就不再打印
            }
            //7TI
        }
        System.out.println();
    }
}

69. 主机甲和主机乙间已建立一个TCP连接，主机甲向主机乙发送了两个连续的TCP段，分别包含300字节和500字节的有效载荷，第一个段的序列号为200，主机乙正确接收到两个段后，发送给主机甲的确认序列号是？

（2015阿里巴巴实习生笔试题）

A. 500
B. 700
C. 800
D. 1000

解析：
主机乙正确接收到两个段，共300字节加500字节共800个字节，第一个段的序列号为200，则表明确认号为800+200=1000。

70.主机甲和主机乙之间已建立了一个TCP连接 ，TCP最大段长度为1000字节。若主机甲的当 前拥塞窗口为4000字节，在主机甲向主机乙连 续发送两个最大段后，成功收到主机乙发送的 第一个段的确认段，确认段中通告的接收窗口 大小为2000字节，则此时主机甲还可以向主机 乙发送的最大字节数是（）

A. 4000
B. 3000
C. 2000
D. 1000

解析：
当主知机甲连续向主机乙发送两个最大报文段时，主机乙只对第一个报文段进行确认，说明第道二个报文段可能丢失，需要重传第二个报文段，又因为此时主机乙的接收窗口大小为为2000个字节，大于1000个字节，可以容纳主机甲传专送的属第二个段1000个字节，所以主机甲还可以向主机乙发送的最大字节数为1000个字节。

71.ARP 协议的功能是（ ）。

A. 根据 IP 地址查询 MAC 地址
B. 根据 MAC 地址查询 IP 地址
C. 根据域名查询 IP 地址
D. 根据 IP 地址查询域名

解析：

A: ARP：Address Resolution Protocol（地址解析协议）根据IP地址查找MAC地址, 属于链路层
B: RARP：（Reverse Address Resolution Protocol)（反向地址解析协议） 根据MAC地址查找IP地址；属于链路层
C\D: DNS:Domain Name System（域名系统）域名和IP地址之间的转换；属于 应用层
其他：
ICMP（ping命令使用的就是这个协议）： Internet control Message Protocol （Internet控制报文协议)用于控制数据报传***的差错情况。可用于测试主机是否可达；属于网络层
NAT：Network Address Translation（网络地址转换协议）用于把公网的IP地址转换为私网的IP地址；属于网络层
DHCP：Dynamic Host Configuration Protocol（动态主机配置协议）管理网络中IP地址的分配
来源：http://blog.csdn.net/lv_victor/article/details/52523831

72. 百万富翁问题

题目描述：
一个百万富翁遇到一个陌生人，陌生人找他谈了一个换钱的计划。该计划如下：我每天给你10 万元，你第一天给我1 分钱，第二天2 分钱，
第三天4 分钱……
这样交换 30 天后，百万富翁交出了多少钱？陌生人交出了多少钱？（注意一个是万元，一个是分）
输入描述:
该题没有输入
输出描述:
输出两个整数，分别代表百万富翁交出的钱和陌生人交出的钱，富翁交出的钱以万元作单位，陌生人交出的钱以分作单位。

import java.util.*;
import java.lang.Math;
public class Main{
    public static void main(String args[]){
        System.out.print(10*30+" "); 
        System.out.println((long)Math.pow(2,30)-1);
    }
}

73.风口的猪-中国牛市

（小米2015暑期实习笔试题）

题目描述：
风口之下，猪都能飞。当今中国股市牛市，真可谓“错过等七年”。 给你一个回顾历史的机会，已知一支股票连续n天的价格走势，以长度为n的整数数组表示，数组中第i个元素（prices[i]）代表该股票第i天的股价。 假设你一开始没有股票，但有至多两次买入1股而后卖出1股的机会，并且买入前一定要先保证手上没有股票。若两次交易机会都放弃，收益为0。 设计算法，计算你能获得的最大收益。 输入数值范围：2<=n<=100,0<=prices[i]<=100

1.

public int calculateMax(int[] prices) {
       int firstBuy = Integer.MAX_VALUE;//第一次买入的价格
       // 接下来都是买入卖出之后的收益
       int afterFirstSell = 0;
       int afterSecondBuy = Integer.MIN_VALUE;
       int afterSecondSell = 0;
        
       for (int curPrice: prices){
           //第一次买入的价格应该是越小越好，最好是负数，倒贴钱
           firstBuy = Math.min(firstBuy, curPrice);
           //第一次卖出后的收益，等于当前价格减去第一次买入价格，越高越好
           afterFirstSell = Math.max(afterFirstSell, curPrice - firstBuy);
           //第二次买入后的收益，等于第一次卖出后的收益减去当前价格，越高越好
           afterSecondBuy = Math.max(afterSecondBuy, afterFirstSell - curPrice);
           //第二次卖出后的收益，等于第二次买入后的收益加上当前价格，越高越好
           afterSecondSell = Math.max(afterSecondSell, afterSecondBuy + curPrice);
       }
       return afterSecondSell;
   }

2.

public class Solution {
    /**
     * 计算你能获得的最大收益
     *
     * @param prices Prices[i]即第i天的股价
     * @return 整型
     */
    public int calculateMax(int[] prices) {
        int sum = 0,temp;
        for(int i=0; i<prices.length; i++){
            temp = getMax(prices,0,i) + getMax(prices,i,prices.length-1);
            if(temp > sum)
                sum = temp;
        }
        return sum;
    }
    // 求最大start到end之间的最大利润函数
    public int getMax(int[] prices, int start, int end){
        int max = 0;
        int min = prices[start];
        for(int i=start+1; i<=end; i++){
            if(prices[i] < min)
                min = prices[i];
            if(prices[i]-min > max)
                max = prices[i] - min;
        }
        return max;
    }
}

74.下面对Host文件描述正确的是：

A. 这个文件是批处理文件,用来指定域名的访问IP。
B. 一个DNS域名解析服务器文件,用于解析域名对应的IP地址。
C. 作用是网址域名与其对应的IP地址建立一个关联"数据库"。
D. 当用户输入网址后,系统首先到DNS服务器中寻找对应的IP地址,如果不存在会到Host文件中确定最终访问地址。

解析：
Hosts是一个没有扩展名的系统文件，可以用记事本等工具打开，其作用就是将一些常用的网址域名与其对应的IP地址建立一个关联“数据库”，当用户在浏览器中输入一个需要登录的网址时，系统会首先自动从Hosts文件中寻找对应的IP地址，一旦找到，系统会立即打开对应网页，如果没有找到，则系统会再将网址提交DNS域名解析服务器进行IP地址的解析。

75.在TCP/IP建立连接过程中，客户端和服务端的状态转移说法错误的是（ ）？

（完美世界2017校招笔试题）

A. 经历TIME_WAIT状态
B. 经历SYN_SENT状态
C. 经历ESTABLISHED状态
D. 经历SYN_RECV状态
E. 服务器接受到客户端的ack包后将从半连接队列删除
F. 服务器在收到syn包时将加入半连接队列

解析： 图源网络

76.ping下面是基于哪个协议？

(完美世界2016实习笔试题)

A .ICMP
B. TCP
C. IP
D. UDP

解析：
ping在主机和服务器之间传递控制消息，属于ICMP协议，但是ICMP协议是TCP/IP的子协议。

77.下面关于TCP的描述,错误的是()

（搜狗2016笔试题）

A. TCP是一种面向连接的协议,给用户进程提供可靠的全双工的字节流
B. TCP客户端和服务器之间建立连接需要经过3次握手
C. 只要有一方主动关闭连接后,这个TCP连接就结束了
D. TCP在传输数据过程中必须保持着连接,这个连接会给通信过程增加开销

解析：
建立连接三次握手
关闭连接四次挥手
前面的题已经说过无数次了，这里不赘述了

78.字母统计

题目描述：
输入一行字符串，计算其中A-Z大写字母出现的次数
输入描述:
案例可能有多组，每个案例输入为一行字符串。
输出描述:
对每个案例按A-Z的顺序输出其中大写字母出现的次数。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            char[] array = str.toCharArray();
            int[] resArray = new int[100];
            for(char ch:array){
                resArray[ch]++;
            }
            for(int i = 'A' ; i <= 'Z' ; i++){
                System.out.println((char)i +":" +resArray[i]);
            }
        }
    }
}

79.进制转换

（华为研发工程师编程题）

题目描述：
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。（多组同时输入 ）

输入描述:
输入一个十六进制的数值字符串。
输出描述:
输出该数值的十进制字符串。

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while (sc.hasNext()){
            String str=sc.next().substring(2);//将前面的0x截取掉
            System.out.println(Integer.parseInt(str,16));//利用parseInt()方法直接转换
        }
    }
} 

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while (sc.hasNext()){
            StringBuffer sb=new StringBuffer();
            sb.append(sc.next());
            String str=sb.reverse().substring(0,sb.length()-2);
            char ch[]=str.toCharArray();
            int sum=0;
            for(int i=0;i<ch.length;i++){
                if(ch[i]>='A'&&ch[i]<='F'){
                    sum+=(Integer.valueOf(ch[i])-55)*Math.pow(16,i);
                }else {
                    sum+=(Integer.valueOf(ch[i])-48)*Math.pow(16,i);
                }
            }
            System.out.println(sum);
        }
    }
}

80.以下哪个ip不和10.11.12.91/28处于同一个子网

(美团2016笔试题)

A. 10.11.12.85/28
B. 10.11.12.88/28
C. 10.11.12.94/28
D. 10.11.12.97/28

解析：（from牛客原题下解析）
前28位为网络号，故子网掩码为11111111.11111111. 11111111. 11110000（255.255.255.240）。
256-240=16，有16个子网，每一个子网段大小范围是16。
10.11.12.91/28中91可以表示为：01011011，前四位为网络号，后四位为主机号，
故包含10.11.12.91的子网范围是：01010000 ~ 01011111（80~95）。
去掉第一个和最后一个，和 10.11.12.91/28在一个网段的范围为： 10.11.12.81/28~ 10.11.12.94/28。

81. 下面关于synflood攻击的说法,错误的是()

(搜狗2016笔试题)

A. 服务端由于连接队列被占满而不能对外服务
B. 不但能攻击TCP服务,还可以攻击UDP服务
C. 大量连接处于SYN_RECV状态
D. 使用硬件防火墙可以一定程度上抵御攻击

解析：

来源：牛客网

要明白这种攻击的基本原理，还是要从TCP连接建立的过程开始说起：
大家都知道，TCP与UDP不同，它是基于连接的，也就是说：为了在服务端和客户端之间传送TCP数据，必须先建立一个虚拟电路，也就是TCP连接，建立TCP连接的标准过程是这样的：
首先，请求端（客户端）发送一个包含SYN标志的TCP报文，SYN即同步（Synchronize），同步报文会指明客户端使用的端口以及TCP连接的初始序号；
第二步，服务器在收到客户端的SYN报文后，将返回一个SYN+ACK的报文，表示客户端的请求被接受，同时TCP序号被加一，ACK即确认（Acknowledgment）。
第三步，客户端也返回一个确认报文ACK给服务器端，同样TCP序列号被加一，到此一个TCP连接完成。
以上的连接过程在TCP协议中被称为三次握手（Three-way Handshake）。
问题就出在TCP连接的三次握手中，假设一个用户向服务器发送了SYN报文后突然死机或掉线，那么服务器在发出SYN+ACK应答报文后是无法收到客户端的ACK报文的（第三次握手无法完成），这种情况下服务器端一般会重试（再次发送SYN+ACK给客户端）并等待一段时间后丢弃这个未完成的连接，这段时间的长度我们称为SYN Timeout，一般来说这个时间是分钟的数量级（大约为30秒-2分钟）；一个用户出现异常导致服务器的一个线程等待1分钟并不是什么很大的问题，但如果有一个恶意的攻击者大量模拟这种情况，服务器端将为了维护一个非常大的半连接列表而消耗非常多的资源----数以万计的半连接，即使是简单的保存并遍历也会消耗非常多的CPU时间和内存，何况还要不断对这个列表中的IP进行SYN+ACK的重试。实际上如果服务器的TCP/IP栈不够强大，最后的结果往往是堆栈溢出崩溃—即使服务器端的系统足够强大，服务器端也将忙于处理攻击者伪造的TCP连接请求而无暇理睬客户的正常请求（毕竟客户端的正常请求比率非常之小），此时从正常客户的角度看来，服务器失去响应，这种情况我们称作：服务器端受到了SYN Flood攻击（SYN洪水攻击）。

81.5.某学校获取到一个B类地址段,要给大家分开子网使用,鉴于现在上网设备急剧增多,管理员给每个网段进行划分的子网掩码设置为255.255.254.0,考虑每个网段需要有网关设备占用一个地址的情况下,每个网段还有多少可用的主机地址()

A.509
B.511
C.51
D.510
解析：
子网掩码写成二进制形式：1111 1111 1111 1111 1111 1111 1111 11110 0000 0000；
可用地址为2^9=512，减去全0和全1，再要减去一个网关设备，512-3=509

82.假设在x86平台上,有一个int型变量,在内存中的内部由低到高分别是:0x12,0x34,0x56,0x78当通过网络发送该数据时,正确的发送顺序是()

（美团2016笔试题）

A. 0x12,0x34,0x56,0x78
B. 0x78,0x56,0x34,0x12
C. 0x34,0x12,0x78,0x56
D. 0x56,0x78,0x12,0x34

解析：
小端法(Little-Endian)就是低位字节排放在内存的低地址端(即该值的起始地址),高位字节排放在内存的高地址端;
大端法(Big-Endian)就是高位字节排放在内存的低地址端(即该值的起始地址),低位字节排放在内存的高地址端;
X86是Little-Endian ，所以int 型变量值为 0x78563412, 网络发送数据时，采用大段，先发送高位再发送低位

83.下列哪个地址不可能是子网掩码()

（完美世界2016笔试题）

A. 255.224.0.0
B. 255.255.240.0
C. 255.255.255.248
D. 255.255.255.250

解析：
子网掩码前面全是1,后面为0,必须是连续的
224是1 1 1 0 0 0 0 0 0 可行
240是1 1 1 1 0 0 0 0 0 可行
248是1 1 1 1 1 1 0 0 0 可行
250是1 1 1 1 1 1 0 1 0 不可行

84.某公司申请到一个C类IP地址，但要连接6个的子公司，最大的一个子公司有26台计算机，每个子公司在一个网段中，则子网掩码应设为（）

（网易2016校招）

A. 255.255.255.192
B. 255.255.255.128
C. 255.255.255.0
D. 255.255.255.224

解析：
一个子公司26台机器，2^5 = 32，刚好够用，所以IP地址最后8位里的后5位用作子网内区分的地址。
前3位就是子网掩码了，即11100000，即224。
选D，255.255.255.224

85. 下列哪个IP地址可以分配给一台计算机?

(网易2016校招)

A. 256.1.3.4
B. 197.3.11.0
C. 199.5.89
D. 11.15.33.235

解析：
分类的IP地址由：网络号+主机号组成，主要分为A、B、C、D、E五类，我们能使用的只有A~C类，D类为多播地址，E类保留使用。

A类地址：0.0.0.0 ~ 127.255.255.255
主机号是后24位
B类地址：128.0.0.0 ~ 191.255.255.255
主机号是后16位
C类地址：192.0.0.0 ~ 223.255.255.255
主机号是后8位
D类地址：224.0.0.0 ~ 239.255.255.255
后28位为多播组号
E类地址：240.0.0.0 ~ 255.255.255.255
后27位待用

A，256的点分十进制IP地址不存在，最大为255
B，197的网络号对应C类地址，不能使用全0的主机号
C不符合表述
D是符合的A类地址

86.从浏览器打开 http://www.mi.com ，TCP/IP协议族中不会被使用到的协议是（）

(小米2019秋招)

A. SMTP
B. HTTP
C. TCP
D. IP

87.下面对于cookie的描述中错误的是？

（百度2016笔试题）

A. 如果在一台计算机中安装多个浏览器，每个浏览器都会以独立的空间存放cookie
B. Cookie的大小限制在4kb左右，对于复杂的存储需求来说是不够用的
C. Cookie通过HTTP Headers从浏览器端发送到服务器端并存储在服务器端
D. 由于在HTTP请求中的Cookie是明文传递的，所以安全性成问题

解析：
cookie存储在客户端 ，session存储在服务端
cookie指某些网站为了辨别用户身份、进行session跟踪而储存在用户本地终端上的数据（通常经过加密）。 简单来说就是服务器暂时存放在你的电脑里的资料（.txt格式的文本文件），好让服务器用来辨认你的计算机。

88.在网络应用测试中，网络延迟是一个重要指标。以下关于网络延迟的理解，正确的是？

(美团点评2016笔试题)

A. 指响应时间
B. 指报文从客户端发出到客户端接收到服务器响应的间隔时间
C. 指报文在网络上的传输时间
D. 指从报文开始进入网络到它开始离开网络之间的时间

解析：
往返时延：在计算机网络中它是一个重要的性能指标，表示从发送端发送数据开始，到发送端收到来自接收端的确认（接收端收到数据后便立即发送确认），总共经历的时延（选项B）

网络延迟：数据在网络介质中通过网络协议 (如TCP/IP)进行传输， 在传输介质中传输所用的时间，即从报文开始进入网络到它开始离开网络之间的时间。

89.下面哪个协议用于发现设备的硬件地址？（ ）

A. RARP
B. IP
C. ARP
D. ICMP

90.IP地址中的哪个类默认有最多可用的主机地址（）

(凤凰网2016校招)

A. A
B. B
C. C
D. A和B

解析：
A 类地址 8bit 网络号 + 24bit 主机号
B 类地址 16bit 网络号 + 16bit 主机号
C 类地址 24bit 网络号 + 8bit 主机号
D 类地址 多播地址
E 类地址 保留

A类网络的IP地址范围为：1.0.0.1－126.255.255.254；
B类网络的IP地址范围为：128.1.0.1－191.255.255.254；
C类网络的IP地址范围为：192.0.1.1－223.255.255.254
具体解释：
1．A类IP地址知
一个A类IP地址由1字节道（每个字节是8位）的网络地版址和3个字节主机地址组成，网络地址的最高位必须是“0”,即第一段数字范围为1～126。每个A类地址可连接16387064台主权机，Internet有126个A类地址。
2．B类IP地址
一个B类IP地址由2个字节的网络地址和2个字节的主机地址组成，网络地址的最高位必须是“10”，即第一段数字范围为128～191。每个B类地址可连接64516台主机，Internet有16256个B类地址。
3．C类IP地址
一个C类地址是由3个字节的网络地址和1个字节的主机地址组成，网络地址的最高位必须是“110”，即第一段数字范围为192～223。每个C类地址可连接254台主机，Internet有2054512个C类地址。

91.IPv4版本的因特网总共有多少有效A类地址网络()

(滴滴2016笔试题)

A. 255
B. 128
C. 256
D. 126

解析：
A类IP地址范围从1.0.0.0 到126.0.0.0。可用的A类网络有126个。
B类IP地址范围从128.0.0.0到191.255.255.255。可用的B类网络有16382个 。
C类IP地址范围从192.0.0.0到223.255.255.255。C类网络可达209万余个。
D类地址用于多点广播

92. 空格替换

import java.util.*;
public class Replacement {
    public String replaceSpace(String iniString, int length) {
        // write code here
        char[] array = iniString.toCharArray();
        String reg = " ";
        String tmp = "%20";
        return iniString.replaceAll(reg,tmp);
    }
}

93. 最近公共祖先

import java.util.*;

public class LCA {
    public int getLCA(int a, int b) {
        // write code here
        if(a == b){
            return a;
        }
        if(a > b){
            return getLCA(a/2,b);
        }else{
            return getLCA(a,b/2);
        }
    }
}

94. 下列TCP连接建立过程描述正确的是：

（360爱奇艺笔试题）

A. 服务端收到客户端的SYN包后等待2ml时间后就会进入SYN_SENT状态
B. 服务端收到客户端的ACK包后会进入SYN_RCVD状态
C. 当客户端处于ESTABLISHED状态时，服务端可能仍然处于SYN_RCVD状态
D. 服务端未收到客户端确认包，等待2ml时间后会直接关闭连接

解析：
【转载】三次握手四次挥手我已经说累了

链接：https://www.nowcoder.com/questionTerminal/6f192d5f529244609d88263c0a230d10?from=14pdf

此题主要考察TCP三次握手，四次挥手的状态变化，对着图看吧，加深印象。
三次握手如下：

（此图第三次握手的ack应该等于y+1，而不是y，上面看不太清楚，但不影响解这题）

四次挥手如下：

A：SYN_SENT是客户端发送SYN包之后的立即进入的状态，不用等待2ml
B：服务端收到客户端的SYN包后会进入SYN_RCVD状态，服务端收到ACK包后会进入established状态。
C： 当客户端处于ESTABLISHED状态时，服务端等待接收客户端的ACK，所以可能处于SYN_RCVD状态。
D： 客户端收到服务端确认包后，等待2*ml时间后会直接关闭连接。若没有收到，则不会关闭连接。

95. 、TCP建立连接的过程采用三次握手，已知第三次握手报文的发送序列号为1000，确认序列号为2000，请问第二次握手报文的发送序列号和确认序列号分别为

（360 2016笔试题）

A. 1999，999
B. 1999，1000
C. 999，2000
D. 999，1999

解析： 我选错成了A

96.应用程序ping发出的是什么报文？

(百度2018笔试题)

A. TCP请求报文
B. ICMP请求报文
C. TCP应答报文
D. ICMP应答报文

97. 回文串

（蘑菇街2016研发笔试题）

题目描述：
给定一个字符串，问是否能通过添加一个字母将其变为回文串。
输入描述:
一行一个由小写字母构成的字符串，字符串长度小于等于10。
输出描述:
输出答案(YES\NO).

/*
双指针 
i=0，j=字符串长度-1
flag的作用是记录有几次这样的情况，只有一次就满足题目条件

两端相同，i++，j--

当两端不一样的时候
1. str（i+1）要是和str（j）相同，就认为j位置需要添加字符达到目的，i++，flag++
2. 同理，str（i）要是和str（j-1）相同，就认为i位置需要添加字符达到目的，j--，flag++
上面两个都不满足说明两端都需要，flag+2

两端一样的时候
i++，j--

*/

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String str = in.next();
            int flag = 0;
            int i = 0, j = str.length() - 1;
            while (i <= j) {
                if (str.charAt(i) != str.charAt(j)) {
                    if (i + 1 <= j && str.charAt(i + 1) == str.charAt(j)) {
                        i++;
                        flag++;
                    } else if (j - 1 >= i && str.charAt(i) == str.charAt(j - 1)) {
                        j--;
                        flag++;
                    } else {
                        flag+=2;
                        break;
                    }
                } else {
                    i++;
                    j--;
                }
            }
            if (flag < 2) {
                System.out.println("YES");
            } else {
                System.out.println("NO");
            }
        }
    }
}

98.二维数组打印

题目描述：
有一个二维数组(n*n),写程序实现从右上角到左下角沿主对角线方向打印。
给定一个二位数组arr及题目中的参数n，请返回结果数组。
测试样例：
[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]],4
返回：[4,3,8,2,7,12,1,6,11,16,5,10,15,9,14,13]

/*
沿对角线打印，就拿4*4的举例子
循环在[3,0]处结束,也就是 startX 一旦等于（n-1）就结束

再接着每一趟打印的循环：
由于有很多趟，所以设置临时变量x，y用于标志每一趟循环的坐标
第一趟：[0,3]
第二趟：[0,2] [1,3]
第三趟：[0，1] [1，2] [2，3]
第四趟：[0，0] [1，1] [2，2] [3，3]
第五趟：[1，0] [2，1] [3，2]
第六趟：[2，0] [3，1]
第七趟：[3，0]
可以看到，每一趟，x++，y++

打印完一趟后，要是startY > 0，说明在上三角，startY--
反之就是在下三角，startX++
*/

import java.util.*;
public class Printer {
   public int[] arrayPrint(int[][] arr, int n) {
       int[] res = new int[n*n];
       int index = 0;//结果一维数组下标
       int startX = 0;//二维数组X坐标
       int startY = n-1;//二维数组Y坐标
       while(startX<n){
           int x = startX;
           int y = startY;
           while(x<n&&y<n)//
               res[index++]=arr[x++][y++];
           if(startY>0)
               startY--;
           else
               startX++;
       }
       return res;
   }
}

99. tcp三次握手创建连接，双方交互的报文中SYN和ACK的序列是什么样的()

（网易2015校招）

A. SYN，SYN+ACK，ACK
B. SYN，ACK，SYN，ACK
C. SYN+ACK，ACK，SYN
D. SYN，SYN，ACK
解析：

100. 删除公共字符

题目描述：
输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”
输入描述:
每个测试输入包含2个字符串
输出描述:
输出删除后的字符串

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String str1 = sc.nextLine();
        String str2 = sc.nextLine();
        String pattern = "[" + str2 + "]";
        String res = str1.replaceAll(pattern,"");
        System.out.println(res);
    }
}