Java面向对象编程

一个关系数据库文件中的各条记录 （） 。

A. 前后顺序不能任意颠倒，一定要按照输入的顺序排列

B. 前后顺序可以任意颠倒，不影响库中的数据关系

C. 前后顺序可以任意颠倒，但排列顺序不同，统计处理的结果就可能不同

D. 前后顺序不能任意颠倒，一定要按照关键字字段值的顺序排列

答案：B

一名员工可以使用多台计算机，每台计算机只能由一名员工使用，则实体员工和计算机间的联系是（ ）

A. 一对多

B. 多对多

C. 多对一

D. 一对一

答案：A

下列关于视图的说法错误的是：

A. 视图是从一个或多个基本表导出的表，它是虚表

B. 视图一经定义就可以和基本表一样被查询、删除和更新

C. 某一用户可以定义若干个视图

D. 视图可以用来定义新的视图

答案：B

在Mysql中，订单表 ( 订单号，雇员代号，地区代号，订购日期 ) 中订单号为主键，要删除订单中前三年以前的信息， SQL 为：

A. delete from订单表where订购日期 B. delete from订单表where 订购日期

C. delete from订单表where订购日期 D.delete from订单表where订购日期

答案：D

负责数据库中查询操作的数据库语言是（ ）。

A. 数据定义语言

B. 数据管理语言

C. 数据操纵语言

D. 数据控制语言

答案：C

数据库管理系统是（ ）。

A. 操作系统的一部分

B. 在操作系统支持下的系统软件

C. 一种编译系统

D. 一种操作系统

答案：B

SQL 语句中修改表结构的命令是（）

A. MODIFY TABLE

B. MODIFY STRUCTURE

C. ALTER TABLE

D. ALTER STRUCTURE

答案：C

在sql数据库中，哪个语句能校验整数列 i 的值不小于 1 不大于 10 ？

A. i BETWEEN 1 AND 10

B. i BETWEEN 0 AND 11

C. i IN INTERVAL(0,11)

D. i IN INTERVAL(1,10)

答案：A

在学生表 Student 的系别 (Sdept) 属性中查询信息系 (IS) 、数学系 (MA) 和计算机系 (CS) 的学生姓名 (Sname) 和性别 (Ssex) ，正确的命名格式应为：

A. SELECT Student FROM Sname, Ssex WHERE Sdept IN (‘IS’, ’MA’, ‘CS’)

B. SELECT Sname, Ssex FROM Student WHERE Sdept IN (‘IS’, ’MA’, ‘CS’)

C. SELECT Sname, Ssex FROM Student WHERE Sdept (IS, MA, CS)

D. SELECT Sname, Ssex FROM Student WHERE Sdept LIKE IS, MA, CS

答案：B

SQL 查询语句中 WHERE 、 GROUP BY 、 HAVING 这些关键字区别和用法总结错误的是（）

A. HAVING在查询语句中必须依赖于GROUP BY

B. WHERE子句用来限制SELECT语句从表中指定选取的行

C. GROUP BY子句用来分组WHERE子句的输出结果集

D. HAVING子句用来从分组的结果中筛选列

答案：D

参数解析

题目描述：在命令行输入如下命令：

 xcopy /s c:\\ d:\\e，

 各个参数如下：

参数1：命令字xcopy

参数2：字符串/s

参数3：字符串c:\\

参数4: 字符串d:\\e

请编写一个参数解析程序，实现将命令行各个参数解析出来。

 解析规则：

 1.参数分隔符为空格

2.对于用""包含起来的参数，如果中间有空格，不能解析为多个参数。比如在命令行输入xcopy /s "C:\\program files" "d:\"时，参数仍然是4个，第3个参数应 该是字符串C:\\program files，而不是C:\\program，注意输出参数时，需要将""去掉，引号不存在嵌套情况。

 3.参数不定长

4.输入由用例保证，不会出现不符合要求的输入 数据范围：字符串长度:1<=N<=1000

 进阶：时间复杂度：O(N)，空间复杂度：O(N)

 输入描述：输入一行字符串，可以有空格

输出描述：输出参数个数，分解后的参数，每个参数都独占一行

public class Main {
    //参数解析
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String str=scanner.nextLine();
        int count=0;
        //计算空格的个数
        //参数的总个数=空格个数+1 

    for (int i = 0; i < str.length(); i++) {

            //遇到左引号的时候，要一直遍历，直到遇到右引号

            //这样才说明，双引号中的参数遍历完了

            if (str.charAt(i) =='"'){//左引号

                do {

                    i++;

                }while (str.charAt(i)=='"');

            }

            //碰到双引号以外的空格，count++

            if (str.charAt(i)==' '){

                count++;

            }

        }

        //参数的总个数=空格个数+1

        System.out.println(count+1);

        int flag=1;



        for (int i = 0; i < str.length(); i++) {

            //当碰到左引号的时候，falg变为0，当碰到右引号的时候，flag变为1

            //说明在flag==0的时候，我们一直在遍历双引号当中的参数

            if (str.charAt(i)=='"'){

                flag^=1;

                //将flag变为1

            }

            //除了双引号中的空格和双引号，其他字符都输出

            if (str.charAt(i) !=' '&& str.charAt(i) !='"'){

                System.out.print(str.charAt(i));

            }

            //双引号里面的空格需要输出

            if (str.charAt(i)==' ' && flag==0){

                System.out.print(str.charAt(i));

            }

            //碰到双引号以外的空格要换行

            if (str.charAt(i)==' '&& flag==1){

                System.out.println();

            }

        }

    }

}

//xcopy /s c:\\ d:\\e

跳石板

题目描述：小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3.......

 这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的 石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和 本身的约数)的位置。 小易当前处在编号为N的石板，他想跳到编号恰好为M的石板去，小易想知道最少需要跳跃几次可以到达。

 例如： N = 4，M = 24：

 4->6->8->12->18->24

于是小易最少需要跳跃5次，就可以从4号石板跳到24号石板

输入描述：输入为一行，有两个整数N，M，以空格隔开。 (4 ≤ N ≤ 100000) (N ≤ M ≤ 100000)

输出描述：输出小易最少需要跳跃的步数,如果不能到达输出-1

public class Main2 {

    //跳石板

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);

        int n=scanner.nextInt();

        int m=scanner.nextInt();

        //有m块石板，为了将石板的编号，与数组的下标对应在一起，所以，定义数组的长度为m+1

        int[] step=new int[m+1];

        for (int i = 0; i < m+1; i++) {

            step[i]=Integer.MAX_VALUE;//赋初始值

        }

        //从第n块石板开始跳跃

        step[n]=0;



        for (int i = n; i < m; i++) {

            if (step[i]==Integer.MAX_VALUE){

                //如果是最大值，那么，没有办法跳跃到该位置处

                continue;

            }

            //i代表当前石板的编号

            List<Integer> list=div(i);

            //j代表一次可以跳几块石板

            for (int j:list) {

                if (i+j<=m && step[i+j]!=Integer.MAX_VALUE){

                    step[i+j]=Math.min(step[i+j],step[i]+1);

                    //最小值

                }else if (i+j<=m){

                    step[i+j]=step[i]+1;

                }

            }

        }

        if (step[m]==Integer.MAX_VALUE){

            System.out.println(-1);

        }else {

            System.out.println(step[m]);

        }

    }

    //求 i 的约数 ，List相当于一个数组，用来存放约数

    public static List<Integer> div(int num){

        List<Integer> list=new ArrayList<>();

        for (int i = 2; i*i <= num; i++) {

            if (num % i ==0){

                list.add(i);

                //与i相对应的num/i也是约数，但是需要注意的是i不能相同！！

                if (num/i !=i){

                    list.add(num/i);

                }

            }

        }

        return list;

    }

}