资题-01~202107

目录

1：有员工工资表和部门表，统计每个部门的总工资

2：有员工工资表和部门表，统计每个部门中工资最高的员工编号

3：自己写一个链式结构的Class类（不需要写具体方法实现）

4：sql优化做过哪些

5：sql加索引为什么会快

6：一个表中只有一个复杂的带了多个字段的查询sql，如何给where后面的字段加索引，怎么加

7：栈中存放哪些数据，什么情况下栈中出现内存溢出

---

1：有员工工资表和部门表，统计每个部门的总工资

employee 员工表

id       员工id

name 姓名

salary 工资

dno      部门编号

department 部门表

dno       部门id

dname  部门名称

答：

oracle 版本

SELECT

            b.dname,

            SUM(nvl(a.salary, 0)) AS sal
FROM employee a, department  b
WHERE a.dno = b.dno
GROUP BY b.dname;

结果参考：

2：有员工工资表和部门表，统计每个部门中工资最高的员工编号

答：

SELECT tt.*, d.name
FROM (
    SELECT e.*, t.maxsalary
    FROM (
        SELECT dno, MAX(salary) AS maxsalary
        FROM employee 
        GROUP BY dno
    ) t
        INNER JOIN employee e ON t.dno = e.dno
    WHERE e.salary = t.maxsalary
) tt
    INNER JOIN department d ON tt.dno = d.id
ORDER BY tt.dno, tt.id

参考：

3：自己写一个链式结构的Class类（不需要写具体方法实现）

答：

所谓链表就是指在某节点存储数据的过程中还要有一个属性用来指向下一个链表节点，这样的数据存储方式叫做链表

链表优缺点：

优点：易于存储和删除

缺点：查询起来较麻烦

首先定义节点类：

package LinkTest;
/**
 * 链表节点类
 * @author admin
 *
 */
public class Node {
    private int value;//存储数据
    private Node next;//下一个节点
    /**
     * 定义构造器
     * @param vlaue
     * @param value 
     */
    public Node(int value){
        this.value=value;
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }
}

定义一个链表类：

* 注意：遍历链表定义了两个方法，一个是普通方法，一个是递归方法，都可以遍历出来

package LinkTest;
/**
 * 链表
 * @author admin
 *
 */
public class Link {
    private Node current;
    private Node root;
    public void insert(int vlaue){
        Node newNode=new Node(vlaue);
        if(this.current==null){
            this.current=newNode;
            this.root=this.current;
        }else{
            this.current.setNext(newNode);
            this.current=this.current.getNext();
        }
    }
    //普通遍历
    public void getList(){
        this.current=this.root;
        while(this.current!=null){
            System.out.print(this.current.getValue());
            this.current=this.current.getNext();
            if(this.current!=null){
                System.out.print("------->");
            }
        }
    }
 
    //递归遍历
    public void getList2(){
        DG(this.root);
    }
 
    //递归方法
    public void DG(Node node){
        System.out.print(node.getValue()+"----->");
        if(node.getNext()!=null){
            DG(node.getNext());
        }else{
            return;
        }
    }
}

测试类：

package LinkTest;
/**
 * 测试类
 * @author admin
 *
 */
public class Test {
    public static void main(String[] args){
        Link l=new Link();
        l.insert(1);
        l.insert(4);
        l.insert(5);
        l.insert(6);
        l.insert(9);
        l.insert(8);
        l.getList();
    }
}

测试类运行结果：

1------->4------->5------->6------->9------->8

4：sql优化做过哪些

答：

参考：https://blog.csdn.net/weixin_35681869/article/details/108289208

MySql总结到 SQL 优化中，就如下三点：

• 最大化利用索引。

• 尽可能避免全表扫描。

• 减少无效数据的查询。

以下 SQL 优化策略适用于数据量较大的场景下

一：避免不走索引的场景

①尽量避免在字段开头模糊查询，会导致数据库引擎放弃索引进行全表扫描；

优化方式：尽量在字段后面使用模糊查询。

②尽量避免使用 in 和 not in，会导致引擎走全表扫描

优化方式：

如果是连续数值，可以用 between 代替。

如果是子查询，可以用 exists 代替。

③尽量避免使用 or，会导致数据库引擎放弃索引进行全表扫描

优化方式：可以用 union 代替 or。

④尽量避免进行 null 值的判断，会导致数据库引擎放弃索引进行全表扫描

优化方式：可以给字段添加默认值 0，对 0 值进行判断。

⑤尽量避免在 where 条件中等号的左侧进行表达式、函数操作，会导致数据库引擎放弃索引进行全表扫描

优化方式：可以将表达式、函数操作移动到等号右侧

⑥当数据量大时，避免使用 where 1=1 的条件

优化方式：用代码拼装 SQL 时进行判断，没 where 条件就去掉 where，有 where 条件就加 and。

⑦查询条件不能用 <> 或者 !=

使用索引列作为条件进行查询时，需要避免使用<>或者!=等判断条件。

⑧where 条件仅包含复合索引非前置列

如下：复合（联合）索引包含 key_part1，key_part2，key_part3 三列，但 SQL 语句没有包含索引前置列"key_part1"，按照 MySQL 联合索引的最左匹配原则，不会走联合索引。

select col1 from table where key_part2=1 and key_part3=2

⑨隐式类型转换造成不使用索引

如下 SQL 语句由于索引对列类型为 varchar，但给定的值为数值，涉及隐式类型转换，造成不能正确走索引。

select col1 from table where col_varchar=123; 

⑩order by 条件要与 where 中条件一致，否则 order by 不会利用索引进行排序

如下：

-- 不走age索引
SELECT * FROM t order by age;
 
-- 走age索引
SELECT * FROM t where age > 0 order by age;

SELECT 语句其他优化

①避免出现 select *

②避免出现不确定结果的函数

③多表关联查询时，小表在前，大表在后

④使用表的别名

⑤用 where 字句替换 HAVING 字句

⑥调整 Where 字句中的连接顺序

增删改 DML 语句优化

①大批量插入数据

②适当使用 commit

③避免重复查询更新的数据

④查询优先还是更新（insert、update、delete）优先

查询条件优化

①对于复杂的查询，可以使用中间临时表暂存数据

②优化 group by 语句

③优化 join 语句

④优化 union 查询

⑤拆分复杂 SQL 为多个小 SQL，避免大事务

⑥使用 truncate 代替 delete

5：sql加索引为什么会快

答：

参考:https://blog.csdn.net/wanghao112956/article/details/98177114

是因为索引的底层数据结构是B+树。B+树的中间节点都是存储的索引，只有叶子节点存储的是数据的指针(普通索引是存储的id)，所以，所以磁盘页中可以存储更多的节点元素，也就是说可以让树的高度变得更低，来减少IO的次数。

6：一个表中只有一个复杂的带了多个字段的查询sql，如何给where后面的字段加索引，怎么加

答：

参考：https://blog.csdn.net/qq_35783095/article/details/103423396

7：栈中存放哪些数据，什么情况下栈中出现内存溢出

答:

栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。 栈有一个很重要的特殊性，就是存在栈中的数据可以共享。

如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常。

如果虚拟机在动态扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常。

wei hai guan li