高亚科技公司笔试题目（附答案）

曾经终败给现在 2022-05-13 06:56 271阅读 0赞

**目录**

（一）int和Integer的区别

（二）String和StringBuffer的区别

（三）运行时异常和一般异常的区别

（四）final的意思

（五）error和exception的区别

（六）String s = new String("x"+"y"+"z")共创建多少个对象

（七）List,Set,Map是否继承Collection接口

（八）this()和super()的区别

（九）ArrayList和LinkListed的区别

编程题部分：

最后一题数据库题

--------------------

# **（一）int和Integer的区别** #

1、Integer是int的包装类，int则是java的一种基本数据类型   
2、Integer变量必须实例化后才能使用，而int变量不需要   
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值   
4、Integer的默认值是null，int的默认值是0

# **（二）String和StringBuffer的区别** #

1. String 类 ， String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空间。 String a = "a"; //假设a指向地址0x0001 a = "b";//重新赋值后a指向地址0x0002，但0x0001地址中保存的"a"依旧存在，但已经不再是a所指向的,a 已经指向了其它地址。 因此String的操作都是改变赋值地址而不是改变值操作。

2. StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。 每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。   
   StringBuffer buf=new StringBuffer(); //分配长16字节的字符缓冲区   
   StringBuffer buf=new StringBuffer(512); //分配长512字节的字符缓冲区   
   StringBuffer buf=new StringBuffer("this is a test")//在缓冲区中存放了字符串，并在后面预留了16字节的空缓冲区。

3.StringBuffer   
StringBuffer和StringBuilder类功能基本相似，主要区别在于StringBuffer类的方法是多线程、安全的，而 StringBuilder不是线程安全的，相比而言，StringBuilder类会略微快一点。对于经常要改变值的字符串应该使用 StringBuffer和StringBuilder类。

4.线程安全   
StringBuffer 线程安全   
StringBuilder 线程不安全   
5.速度   
一般情况下,速度从快到慢:StringBuilder>StringBuffer>String,这种比较是相对的，不是绝对的。   
6.总结   
（1）.如果要操作少量的数据用 = String   
（2）.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder   
（3）.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

# **（三）运行时异常和一般异常的区别** #

运行时异常与一般异常区别：  
一般异常表示程序运行过程中可能出现的非正常状态；运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

**Throwable**是Java错误处理的父类，有两个子类：Error和Exception。

**Error**：无法预期的严重错误，导致JVM虚拟机无法继续执行，几乎无法恢复捕捉的

**Exception**：可恢复捕捉的。java健壮程序的手段。

Java提供了两类主要的异常:runtime exception和checked exception （编译时被检查的异常）。

**checked exception** （编译时被检查的异常）：JAVA编译器强制要求我们必需对出现的这些异常进行catch或throws。所以，面对这种异常不管我们是否愿意，只能写一大堆catch块或throws去处理可能的异常。

如IO异常，以及SQL异常等。

**runtime exception**：编译通过，但运行通不过，出现RuntimeException,通常是程序员出错。虚拟机接管会终止线程或主程序。如错误的类型转换、数组越界访问和访问空指针等

# **（四）final的意思** #

*  修饰变量：final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
 *  修饰方法：final方法不能被子类方法覆盖，但可以被继承。
 *  修饰类：final类不能被继承，没有子类，final类中所有方法都是final的。

# **（五）error和exception的区别** #

Error类和Exception类都继承自Throwable类。

Error的继承关系：

[![0927490.png][]][0927490.png]

Exception的继承关系：

[![0927491.png][]][0927491.png]

二者的不同之处：

Exception：

1．可以是可被控制(checked) 或不可控制的(unchecked)。

2．表示一个由程序员导致的错误。

3．应该在应用程序级被处理。

Error：

1．总是不可控制的(unchecked)。

2．经常用来用于表示系统错误或低层资源的错误。

3．如何可能的话，应该在系统级被捕捉。

Java 中定义了两类异常：

1) Checked exception: 这类异常都是Exception的子类 。异常的向上抛出机制进行处理，假如子类可能产生A异常，那么在父类中也必须throws A异常。可能导致的问题：代码效率低，耦合度过高。

2) Unchecked exception: 这类异常都是RuntimeException的子类，虽然RuntimeException同样也是Exception的子类，但是它们是非凡的，它们不能通过client code来试图解决，所以称为Unchecked exception 。

Java 中异常类的继承关系图：

[![0927492.gif][]][0927492.gif]

# **（六）String s = new String("x"+"y"+"z")共创建多少个对象** #

创建了一个,后面的"x","y","z"只是从字符串池里面取的,用完就释放了

# **（七）List,Set,Map是否继承Collection接口** #

:List,Set是,Map不是。

# **（八）this()和super()的区别** #

super()与this()的区别主要有以下：   
不同点：   
1、super()主要是对父类构造函数的调用，this()是对重载构造函数的调用   
2、super()主要是在继承了父类的子类的构造函数中使用，是在不同类中的使用；this()主要是在同一类的不同构造函数中的使用   
相同点：   
1、super()和this()都必须在构造函数的第一行进行调用，否则就是错误的

# **（九）ArrayList和LinkListed的区别** #

1.ArrayList是实现了基于**动态数组**的数据结构，LinkedList基于**链表**的数据结构。   
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。   
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

# **编程题部分：** #

1.有一个包含N个Integer的向量(vector).它包含的Intger 可以是 1 到 N ＋1 之间任何一个，但是互不相同，也就是说vector 中不包含任何重复的值，因为有N个对象并且可能得值有N+1 个，所以有一个值没有包含在这个vector中，请编程 找到这个vector中没有包含的那个整数，（注意:只可以使用Vector.get(),Vector.getSize()） 。

public int find(Vector<Integer> v){
         int n = v.size();
         int result = 0;
         
         for(int i=1;i<=n+1;i++){
          boolean isExist = false;
          
          for(int j=0;j<n;j++){
           if(i == v.get(j)){
            isExist = true;
            break;
           }
          }
          
          if(isExist == false){
           result = i;
           break;
          }
         }
         
         return result;  //返回0 证明传入的参数不符合规定或N+1个值都包含在vector中
       }

2.给你一组字符串 如 \{5，2，3，2，4，5，1，2，1\}，让你输出里面出现次数最多且数值最大的一个，出现几次 （这题想喷了，仔细想想，应该这样理解：输出里面出现次数最多，（如果最多的次数有好几个数）且其中数值最大的一个）

答案在这里：[http://wenku.baidu.com/view/d2de8e94daef5ef7ba0d3c31.html][http_wenku.baidu.com_view_d2de8e94daef5ef7ba0d3c31.html]

3员工对象(包括姓名,账号,性别,年龄)这几个属性  
有形如下的人员组织:  
        A  
       / \\  
      B   C  
     / \\ / \\  
    D  E F  G  
   / \\  
  H   I  
1.请用程序数据结构描述出来,组织结构中的人员用  
  员工对象表示.  
2.编写一个方法,实现输入任何一个人员,按层次打印  
  出自己及其所有下属.  
 如输入B:打印出:  
  B  
   -D  
   --H  
   --I  
   -E

数据结构题，参考[http://bbs.csdn.net/topics/300007175][http_bbs.csdn.net_topics_300007175]

树节点定义:
     
    class TreeNode {
        public TreeNode left;
     
        public TreeNode right;
     
        public int value;
     
        public TreeNode(TreeNode left, TreeNode right, int value) {
            this.left = left;
            this.right = right;
            this.value = value;
        }
    }
     
    二叉树及其操作:
     
    public class BinaryTree {
     
        public static int getTreeHeight(TreeNode root) {
            if (root == null)
                return 0;
            if (root.left == null && root.right == null)
                return 1;
            return 1 + Math
                    .max(getTreeHeight(root.left), getTreeHeight(root.right));
        }
     
        public static void recursePreOrder(TreeNode root) {
            if (root == null)
                return;
            System.out.println(root.value);
            if (root.left != null)
                recursePreOrder(root.left);
            if (root.right != null)
                recursePreOrder(root.right);
        }
     
        public static void stackPreOrder(TreeNode root) {
            Stack stack = new Stack();
            if (root == null)
                return;
            stack.push(root);
            System.out.println(root.value);
            TreeNode temp = root.left;
            while (temp != null) {
                stack.push(temp);
                System.out.println(temp.value);
                temp = temp.left;
            }
            temp = (TreeNode) stack.pop();
            while (temp != null) {
                temp = temp.right;
                while (temp != null) {
                    stack.push(temp);
                    System.out.println(temp.value);
                    temp = temp.left;
                }
                if (stack.empty())
                    break;
                temp = (TreeNode) stack.pop();
            }
        }
     
        public static void recurseInOrder(TreeNode root) {
            if (root == null)
                return;
            if (root.left != null)
                recurseInOrder(root.left);
            System.out.println(root.value);
            if (root.right != null)
                recurseInOrder(root.right);
        }
     
        public static void stackInOrder(TreeNode root) {
            Stack stack = new Stack();
            if (root == null)
                return;
            else
                stack.push(root);
            TreeNode temp = root.left;
            while (temp != null) {
                stack.push(temp);
                temp = temp.left;
            }
            temp = (TreeNode) stack.pop();
            while (temp != null) {
                System.out.println(temp.value);
                temp = temp.right;
                while (temp != null) {
                    stack.push(temp);
                    temp = temp.left;
                }
                if (stack.empty())
                    break;
                temp = (TreeNode) stack.pop();
            }
        }
     
        public static void main(String[] args) {
            TreeNode node1 = new TreeNode(null, null, 1);
            TreeNode node2 = new TreeNode(null, node1, 2);
            TreeNode node3 = new TreeNode(null, null, 3);
            TreeNode node4 = new TreeNode(node2, node3, 4);
            TreeNode node5 = new TreeNode(null, null, 5);
            TreeNode root = new TreeNode(node4, node5, 0);
            System.out.println("Tree Height is " + getTreeHeight(root));
            System.out.println("Recurse In Order Traverse");
            recurseInOrder(root);
            System.out.println("Stack In Order Traverse");
            stackInOrder(root);
            System.out.println("Recurse Pre Order Traverse");
            recursePreOrder(root);
            System.out.println("Stack Pre Order Traverse");
            stackPreOrder(root);
        }
    }
     
    用LinkedList重写的Stack:
     
    import java.util.EmptyStackException;
    import java.util.LinkedList;
     
    public class Stack {
     
        private LinkedList list;
     
        public Stack() {
            this.list = new LinkedList();
        }
     
        public boolean empty() {
            return list.isEmpty();
        }
     
        public Object peek() {
            if (empty())
                throw new EmptyStackException();
            return list.getLast();
        }
     
        public Object pop() {
            if (empty())
                throw new EmptyStackException();
            return list.removeLast();
        }
     
        public void push(Object o) {
            list.add(o);
        }
     
        public static void main(String[] args) {
            Stack stack = new Stack();
            stack.push(new Integer(1));
            stack.push(new Integer(11));
            stack.push(new Integer(1111));
            stack.push(new Integer(22));
            stack.push(new Integer(222));
            stack.push(new Integer(31));
            stack.push(new Integer(221));
            while (!stack.empty()) {
                System.out.println(stack.pop());
            }
        }
    }

# 最后一题数据库题 #

本题用到下面三个关系表：CARD     借书卡。   CNO 卡号，NAME  姓名，CLASS 班级BOOKS    图书。     BNO 书号，BNAME 书名,AUTHOR 作者，PRICE 单价，QUANTITY 库存册数 BORROW   借书记录。 CNO 借书卡号，BNO 书号，RDATE 还书日期备注：限定每人每种书只能借一本；库存册数随借书、还书而改变。

要求实现如下15个处理：

**1**． 写出建立BORROW表的SQL语句，要求定义主码完整性约束和引用完整性约束。

CREATE
    TABLE BORROW(    CNO int
    FOREIGN
    KEY
    REFERENCES CARD(CNO),    BNO int
    FOREIGN
    KEY
    REFERENCES BOOKS(BNO),    RDATE datetime,    PRIMARY
    KEY(CNO,BNO))

**2**． 找出借书超过5本的读者,输出借书卡号及所借图书册数。

2. 找出借书超过5本的读者,输出借书卡号及所借图书册数--实现代码：
    SELECT CNO,借图书册数=COUNT(*)FROM BORROWGROUP
    BY CNOHAVING
    COUNT(*)>5

**3**． 查询借阅了"水浒"一书的读者，输出姓名及班级。

3. 查询借阅了"水浒"一书的读者，输出姓名及班级--实现代码：
    SELECT
    *
    FROM CARD cWHERE
    EXISTS(    SELECT
    *
    FROM BORROW a,BOOKS b     WHERE a.BNO=b.BNO        AND b.BNAME=N'水浒'
    AND a.CNO=c.CNO)

**4**． 查询过期未还图书，输出借阅者（卡号）、书号及还书日期。

4. 查询过期未还图书，输出借阅者（卡号）、书号及还书日期--实现代码：
    SELECT
    *
    FROM BORROW WHERE RDATE<GETDATE()

**5**． 查询书名包括"网络"关键词的图书，输出书号、书名、作者。

5. 查询书名包括"网络"关键词的图书，输出书号、书名、作者--实现代码：
    SELECT BNO,BNAME,AUTHOR FROM BOOKSWHERE BNAME LIKE N'%网络%'

**6**． 查询现有图书中价格最高的图书，输出书名及作者。

6. 查询现有图书中价格最高的图书，输出书名及作者--实现代码：
    SELECT BNO,BNAME,AUTHOR FROM BOOKSWHERE PRICE=(    SELECT
    MAX(PRICE) FROM BOOKS)

**7**． 查询当前借了"计算方法"但没有借"计算方法习题集"的读者，输出其借书卡号，并按卡号降序排序输出。

7. 查询当前借了"计算方法"但没有借"计算方法习题集"的读者，输出其借书卡号，并按卡号降序排序输出--实现代码：
    SELECT a.CNOFROM BORROW a,BOOKS bWHERE a.BNO=b.BNO AND b.BNAME=N'计算方法'
    AND
    NOT
    EXISTS(        SELECT
    *
    FROM BORROW aa,BOOKS bb        WHERE aa.BNO=bb.BNO            AND bb.BNAME=N'计算方法习题集'
    AND aa.CNO=a.CNO)ORDER
    BY a.CNO DESC

**8**． 将"C01"班同学所借图书的还期都延长一周。

8. 将"C01"班同学所借图书的还期都延长一周--实现代码：
    UPDATE b SET RDATE=DATEADD(Day,7,b.RDATE)FROM CARD a,BORROW bWHERE a.CNO=b.CNO    ANDa.CLASS=N'C01'

**9**． 从BOOKS表中删除当前无人借阅的图书记录。

9. 从BOOKS表中删除当前无人借阅的图书记录--实现代码：
    DELETE A FROM BOOKS aWHERE
    NOT
    EXISTS(    SELECT
    *
    FROM BORROW    WHERE BNO=a.BNO)

**10**．如果经常按书名查询图书信息，请建立合适的索引。

10. 如果经常按书名查询图书信息，请建立合适的索引--实现代码：
    CREATE
    CLUSTERED
    INDEX IDX_BOOKS_BNAME ON BOOKS(BNAME)

**11**．在BORROW表上建立一个触发器，完成如下功能：如果读者借阅的书名是"数据库技术及应用"，就将该读者的借阅记录保存在BORROW\_SAVE表中（注ORROW\_SAVE表结构同BORROW表）。

11. 在BORROW表上建立一个触发器，完成如下功能：如果读者借阅的书名是"数据库技术及应用"，就将该读者的借阅记录保存在BORROW_SAVE表中（注ORROW_SAVE表结构同BORROW表）--实现代码：
    CREATE
    TRIGGER TR_SAVE ON BORROWFOR
    INSERT,UPDATE
    AS
    IF
    @@ROWCOUNT>0
    INSERT BORROW_SAVE SELECT i.*
    FROM INSERTED i,BOOKS bWHERE i.BNO=b.BNO    AND b.BNAME=N'数据库技术及应用'

**12**．建立一个视图，显示"力01"班学生的借书信息（只要求显示姓名和书名）。

12. 建立一个视图，显示"力01"班学生的借书信息（只要求显示姓名和书名）--实现代码：
    CREATE
    VIEW V_VIEWAS
    SELECT a.NAME,b.BNAMEFROM BORROW ab,CARD a,BOOKS bWHERE ab.CNO=a.CNO    ANDab.BNO=b.BNO    AND a.CLASS=N'力01'

**13**．查询当前同时借有"计算方法"和"组合数学"两本书的读者，输出其借书卡号，并按卡号升序排序输出。

13. 查询当前同时借有"计算方法"和"组合数学"两本书的读者，输出其借书卡号，并按卡号升序排序输出--实现代码：
    SELECT a.CNOFROM BORROW a,BOOKS bWHERE a.BNO=b.BNO    AND b.BNAME IN(N'计算方法',N'组合数学')GROUP
    BY a.CNOHAVING
    COUNT(*)=2
    ORDER
    BY a.CNO DESC

**14**．假定在建BOOKS表时没有定义主码，写出为BOOKS表追加定义主码的语句。

14. 假定在建BOOKS表时没有定义主码，写出为BOOKS表追加定义主码的语句--实现代码：
    ALTER
    TABLE BOOKS ADD
    PRIMARY
    KEY(BNO)

**15**．对CARD表做如下修改：    a. 将NAME最大列宽增加到10个字符（假定原为6个字符）。    b. 为该表增加1列NAME（系名），可变长，最大20个字符。**1**. 写出建立BORROW表的SQL语句，要求定义主码完整性约束和引用完整性约束--实现代码：

15.1 将NAME最大列宽增加到10个字符（假定原为6个字符）--实现代码：
    ALTER
    TABLE CARD ALTER
    COLUMN NAME varchar(10) 15.2 为该表增加1列NAME（系名），可变长，最大20个字符--实现代码：
    ALTER
    TABLE CARD ADD 系名 varchar(20)

参考网址：[https://blog.csdn.net/rebornsgundam/article/details/8775209][https_blog.csdn.net_rebornsgundam_article_details_8775209]

[0927490.png]: /images/20220513/43c796d87fc44d43929b15272fcba9cf.png
[0927491.png]: /images/20220513/eaee1f916cfc455a9dce091caa0bdf87.png
[0927492.gif]: /images/20220513/56e3e6df35624bf3ba9ed99f28826c25.png
[http_wenku.baidu.com_view_d2de8e94daef5ef7ba0d3c31.html]: http://wenku.baidu.com/view/d2de8e94daef5ef7ba0d3c31.html
[http_bbs.csdn.net_topics_300007175]: http://bbs.csdn.net/topics/300007175
[https_blog.csdn.net_rebornsgundam_article_details_8775209]: https://blog.csdn.net/rebornsgundam/article/details/8775209