整理（三）

下列与队列结构有关联的是（D）
A 函数的递归调用
B 数组元素的引用
C 多重循环的执行
D 先到先服务的作业调度

队列先进先出

下面属于黑盒测试方法的是（C）
A 语句覆盖
B 逻辑覆盖
C 边界值分析
D 路径覆盖

黑盒测试主要的方法有：等价类划分法、边界值分析法、错误推测法、因果图法、决策表法、场景法等。
而白盒测试的主要方法有：语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、条件组合覆盖、路径覆盖等。

a与b定义如下，下列哪个是正确的？（B）
a = ‘123’
b = '123’
A a != b
B a is b
C a == 123
D a + b = 246

a,b为字符串不可变类型，所以指向相同地址，所以 a is b
is指地址相同
== 内容相同
=== 内容和格式相同
a+b=‘123123’
a==123，字符和int不相同

关于 Socket 通信编程，以下描述错误的是（D）
A 服务器端通过new ServerSocket()创建TCP连接对象
B 服务器端通过TCP连接对象调用accept()方法创建通信的Socket对象
C 客户端通过new Socket()方法创建通信的Socket对象
D 客户端通过new ServerSocket()创建TCP连接对象

Socket套接字 ：
就是源IP地址、目标IP地址、源端口号和目标端口号的组合
（1）服务器端：ServerSocket提供的实例
ServerSocket server= new ServerSocket(端口号)
（2）客户端：Socket提供的实例
Socket soc=new Socket(ip地址，端口号)

小易去附近的商店买苹果，奸诈的商贩使用了捆绑交易，只提供6个每袋和8个每袋的包装(包装不可拆分)。 可是小易现在只想购买恰好n个苹果，小易想购买尽量少的袋数方便携带。如果不能购买恰好n个苹果，小易将不会购买。
思路分析：

商店提供6个或8个包装袋，若要恰好装满，则购买数量一定是偶数，同时需要满足不小于6，并且偶数中的10是不满足的；
对于10以上的偶数，对8进行取余，余数可能为2、4、6；
余数为2：从前面两个袋子中取出2个苹果，袋子总数为18/n
余数为4：从前面一个袋子中取出2个苹果，袋子总数为18/n
余数为6：恰好装满一个袋子，袋子总数为1*8/n
所以只要存在余数袋子总数就是1+8/n

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){
            int n = sc.nextInt();
            if (n%2 != 0 || n<6 || n == 10){
                System.out.println(-1);
            }else {
                if (n % 8 == 0){
                    System.out.println(n/8);
                }else {
                    System.out.println(n/8+1);
                }
            }

        }
    }
}

输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”
思路分析：

对于这道题，其实可以不进行删除处理，只需要遍历第一个字符串，找出其中与字符串2相同的部分，跳过它，进行不换行打印即可
而String中提供了contains方法，可以不写对字符串2的遍历

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String string1 = sc.nextLine();
        String string2 = sc.nextLine();
        char[] ch = string1.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            if (!string2.contains(String.valueOf(ch[i]))){//将ch转换成String型
                System.out.print(ch[i]);
            }
        }

    }
}

以下代码结果是什么？（C）

public class foo {
    public static void main(String sgf[]) {
        StringBuffer a=new StringBuffer(“A”);
        StringBuffer b=new StringBuffer(“B”);
        operate(a,b);
        System.out.println(a+”.”+b);
    }
    static void operate(StringBuffer x,StringBuffer y) {
        x.append(y);
        y=x;
    }
}

A 代码可以编译运行，输出“AB.AB”。
B 代码可以编译运行，输出“A.A”。
C 代码可以编译运行，输出“AB.B”。
D 代码可以编译运行，输出“A.B”。

StringBuffer类作为参数传递时‘引用传递’，即传的是地址值

下面代码的运行结果是（C）

        public static void main(String[] args){
            String s;
            System.out.println("s="+s);
        }

A 代码编程成功，并输出”s=”
B 代码编译成功，并输出”s=null”
C 由于String s没有初始化，代码不能编译通过。
D 代码编译成功，但捕获到NullPointException异常

局部变量需要初始化
成员变量在类加载时会初始化赋值

下列哪个说法是正确的（D）
A ConcurrentHashMap使用synchronized关键字保证线程安全
B HashMap实现了Collction接口
C Array.asList方法返回java.util.ArrayList对象
D SimpleDateFormat是线程不安全的

ConcurrentHashMap使用segment来分段和管理锁
HashMap实现的是Map接口
Arrays.asList()
将一个数组转化为一个List对象，这个方法会返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的静态内部类！用这个对象对列表进行添加删除更新操作，就会报UnsupportedOperationException异常。（摘自牛客网回答）

下列代码执行结果为（A）

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

A 21
B 12
C 可能为12，也可能为21
D 以上答案都不对

join() 等待调用这个方法的线程执行完毕才会执行主线程
即，在延迟2秒后打印“1”，然后打印“2”

指出以下程序运行的结果是（B）

public class Example{
    String str=new String("good");
    char[]ch={'a','b','c'};
    public static void main(String args[]){
        Example ex=new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str+" and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[]){
//引用类型变量，传递的是地址，属于引用传递。
        str="test ok";
        ch[0]='g';
    }
}

A good and abc
B good and gbc
C test ok and abc
D test ok and gbc

String不是值传递，执行change方法的时候，传递的是引用的拷贝，因为String是个特殊的final类
给方法中的str赋值，由于String不能改变所引用的值，所以赋值实际是新创建一个对象"test ok",并指向str
使用在主函数中打印str，打印的仍是good

有一个神奇的口袋，总的容积是40，用这个口袋可以变出一些物品，这些物品的总体积必须是40。John现在有n个想要得到的物品，每个物品的体积分别是a1，a2……an。John可以从这些物品中选择一些，如果选出的物体的总体积是40，那么利用这个神奇的口袋，John就可以得到这些物品。现在的问题是，John有多少种不同的选择物品的方式。
解题思路：

本题采用的是递归的方法
public static void back(int s, int n) //s:剩余空间 n:剩余物品个数
同时递归分两种情况
1.口袋中装了a[n]后，剩下的物品中存在满足装满口袋的体积
2.口袋装了a[n]后，剩下的物品无法满足条件，则跳过该物品，装下一个物品

import java.util.Scanner;

public class Main {
    static int[] a;
    static int n;
    static int count = 0;

    public static void back(int s, int n) {//s:剩余空间 n：剩余物品个数
        if(s==0) {//如果正好装满
            count++;
            return ;
        }
        if(s < 0 || s > 0 && n < 1) {// s<0或n<1则不能完成
            return;
        }
        //口袋中装了a[n]后，剩下的物品中存在满足装满口袋的体积
        back(s-a[n],n-1);
        //口袋装了a[n]后，剩下的物品无法满足条件，则跳过该物品，装下一个物品
        back(s,n-1);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            n = scanner.nextInt();
            a = new int[n+1];
            for (int i = 1; i <= n; i++) {
                a[i] = scanner.nextInt();
            }
            back(40,n);
            System.out.println(count);
        }
    }
}

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
解题思路：

本题需要两个栈来完成
栈1用来作入队列
栈2用来出队列，当栈2为空时，栈1全部出栈到栈2,栈2再出栈（即出队列）

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        if (stack1.empty() && stack2.empty()){
            throw new RuntimeException("队列为空");
        }
        if (stack2.empty()){
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}