xbsNotes

剑指offer-困难篇

2020-07-16T11:59:35.000Z

对称的二叉树

题目描述：叉树同此二叉树的镜像是同样的，定义其为对称的。

思路：递归，编写方法，判断以两根节点的二叉树是否对称

public class Solution {
  boolean isSymmetrical(TreeNode pRoot){
    if(pRoot == null) return true;
    return isSymmetrical(pRoot.left, pRoot.right);
  }

  boolean isSymmetrical(TreeNode node1, TreeNode node2){
    if(node1 == null && node2 == null) return true;
    if(node1 == null || node2 == null) return false;
    if(node1.val != node2.val) return false;
    return isSymmetrical(node1.left, node2.right) && isSymmetrical(node1.right, node2.left);
  }
}

数组中的逆序对

题目描述：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

思路：

穷举：超时；

public int InversePairs(int [] array) {
  int count = 0;
  for(int i = 1;i < array.length;i++){
    for(int j = 0;j < i;j++){
      if(array[j] > array[i]){
        count++;
      }
    }
  }
  return count%1000000007;
}

1
2

从上往下打印二叉树

题目描述：从上往下打印出二叉树的每个节点，同层节点从左至右打印。

思路：二叉树层次遍历，利用队列

public ArrayList PrintFromTopToBottom(TreeNode root) {
  if(root == null) return new ArrayList();
  ArrayList res = new ArrayList();
  Queue queue = new LinkedList<>();
  
  queue.add(root);
  while(!queue.isEmpty()){
    int n = queue.size();
    for(int i = 0; i < n; i++){
      TreeNode node = queue.poll();
      res.add(node.val);
      if(node.left != null) queue.add(node.left);
      if(node.right != null) queue.add(node.right);
    }
  }
  return res;
}

mysql数据库

2020-06-26T03:43:06.000Z

登录和退出MySQL服务器

#登陆
mysql -uroot -p12345612;
#退出
exit;

增删改查基本语法

-- 显示所有数据库
show databases;

-- 创建数据库
CREATE DATABASE test;

-- 切换数据库
use test;

-- 显示数据库中的所有表
show tables;

-- 创建数据表
CREATE TABLE pet (
    name VARCHAR(20),
    owner VARCHAR(20),
    species VARCHAR(20),
    sex CHAR(1),
    birth DATE,
    death DATE
);

-- 查看数据表结构
-- describe pet;
desc pet;

-- 查询表
SELECT * from pet;

-- 插入数据
INSERT INTO pet VALUES ('puffball', 'Diane', 'hamster', 'f', '1990-03-30', NULL);

-- 修改数据
UPDATE pet SET name = 'squirrel' where owner = 'Diane';

-- 删除数据
DELETE FROM pet where name = 'squirrel';

-- 删除表
DROP TABLE myorder;

mysql 建表约束

主键约束：

-- 主键约束
-- 使某个字段不重复且不得为空，确保表内所有数据的唯一性。
CREATE TABLE user (
    id INT PRIMARY KEY,
    name VARCHAR(20)
);

mysql> desc user;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | NO   | PRI | NULL    |       |
| name  | varchar(20) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+

-- 联合主键
-- 联合主键中的每个字段都不能为空，并且*加起来*不能和已设置的联合主键重复即可。
CREATE TABLE user2 (
    id INT,
    name VARCHAR(20),
    password VARCHAR(20),
    PRIMARY KEY(id, name)
);

mysql> desc user2;
+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| id       | int(11)     | NO   | PRI | NULL    |       |
| name     | varchar(20) | NO   | PRI | NULL    |       |
| password | varchar(20) | YES  |     | NULL    |       |
+----------+-------------+------+-----+---------+-------+

-- 自增约束：auto_increment
-- 自增约束的主键由系统自动递增分配。
create table user3(
  id int primary key auto_increment,
  name varchar(20)
);

mysql> desc user3;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(11)     | NO   | PRI | NULL    | auto_increment |
| name  | varchar(20) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+


insert into user3 (name) values ('zhangsan');

mysql> select * from user3;
+----+----------+
| id | name     |
+----+----------+
|  1 | zhangsan |
+----+----------+


-- 添加主键约束
-- 如果忘记设置主键，还可以通过SQL语句设置（两种方式）：
ALTER TABLE user ADD PRIMARY KEY(id);
ALTER TABLE user MODIFY id INT PRIMARY KEY;

-- 删除主键
ALTER TABLE user drop PRIMARY KEY;

唯一约束：

-- 建表时创建唯一字段
CREATE TABLE user5 (
    id INT,
    name VARCHAR(20),
    UNIQUE(name)
);

#表示(id,name)合在一起不同即可
CREATE TABLE user6 (
    id INT,
    name VARCHAR(20),
    UNIQUE(id,name)
);

-- 添加唯一约束
-- 如果建表时没有设置唯一约束，还可以通过SQL语句设置（两种方式）：
ALTER TABLE user ADD UNIQUE(name);
ALTER TABLE user MODIFY name VARCHAR(20) UNIQUE;

-- 删除唯一约束
ALTER TABLE user DROP INDEX name;

非空约束：

-- 建表时添加非空约束
-- 约束某个字段不能为空
CREATE TABLE user7 (
    id INT,
    name VARCHAR(20) NOT NULL
);

mysql> desc user7;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(20) | NO   |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+


-- 移除非空约束
ALTER TABLE user MODIFY name VARCHAR(20);

默认约束：

-- 建表时添加默认约束
-- 约束某个字段的默认值
CREATE TABLE user9 (
    id INT,
    name VARCHAR(20),
    age INT DEFAULT 10
);

mysql> desc user9;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(20) | YES  |     | NULL    |       |
| age   | int(11)     | YES  |     | 10      |       |
+-------+-------------+------+-----+---------+-------+

外键约束：

-- 外键约束
-- 涉及两个表：主表，副表

-- 班级表 
create table class(
  id int primary key,
  name varchar(20)
);

mysql> desc class;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | NO   | PRI | NULL    |       |
| name  | varchar(20) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+


-- 学生表 
create table student(
  id int primary key,
  name varchar(20),
  -- 这里的 class_id 要和 classes 中的 id 字段相关联
  class_id int,
  -- 表示 class_id 的值必须来自于 classes 中的 id 字段值
  foreign key(class_id) references class(id)
);

mysql> desc student;
+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| id       | int(11)     | NO   | PRI | NULL    |       |
| name     | varchar(20) | YES  |     | NULL    |       |
| class_id | int(11)     | YES  | MUL | NULL    |       |
+----------+-------------+------+-----+---------+-------+
-- 注意：
-- 1.主表（class）中没有的数据值，在副表（student）中不能使用；
-- 2.主表中的记录被副表引用，不不可以删除的；

数据表设计-三大范式

1NF

只要字段值还可以继续拆分，就不满足第一范式。

范式设计得越详细，对某些实际操作可能会更好，但并非都有好处，需要对项目的实际情况进行设定。

1	address>>- country \| province \| city \| details \|

2NF

在满足第一范式的前提下，其他列都必须完全依赖于主键列。如果出现不完全依赖，只可能发生在联合主键的情况下：

-- 订单表
CREATE TABLE myorder (
    product_id INT,
    customer_id INT,
    product_name VARCHAR(20),
    customer_name VARCHAR(20),
    PRIMARY KEY (product_id, customer_id)
);

实际上，在这张订单表中，product_name 只依赖于 product_id ，customer_name 只依赖于 customer_id 。也就是说，product_name和 customer_id 是没用关系的，customer_name 和 product_id 也是没有关系的。

这就不满足第二范式：其他列都必须完全依赖于主键列！–>拆分！

CREATE TABLE myorder (
    order_id INT PRIMARY KEY,
    product_id INT,
    customer_id INT
);

CREATE TABLE product (
    id INT PRIMARY KEY,
    name VARCHAR(20)
);

CREATE TABLE customer (
    id INT PRIMARY KEY,
    name VARCHAR(20)
);

拆分之后，myorder 表中的 product_id 和 customer_id 完全依赖于 order_id 主键，而 product 和 customer 表中的其他字段又完全依赖于主键。满足了第二范式的设计！

3NF

在满足第二范式的前提下，除了主键列之外，其他列之间不能有传递依赖关系。

CREATE TABLE myorder (
    order_id INT PRIMARY KEY,
    product_id INT,
    customer_id INT,
    customer_phone VARCHAR(15)
);

表中的 customer_phone 有可能依赖于除了 customer_id 之外的 order_id 列，也就不满足了第三范式的设计：除了主键列之外，其他列之间不能有传递依赖关系。

CREATE TABLE myorder (
    order_id INT PRIMARY KEY,
    product_id INT,
    customer_id INT
);

CREATE TABLE customer (
    id INT PRIMARY KEY,
    name VARCHAR(20),
    phone VARCHAR(15)
);

修改后就不存在其他列之间的传递依赖关系，其他列都只依赖于主键列，满足了第三范式的设计！

mysql查询练习

准备数据

创建表：学生表(student)、教师表(teacher)、成绩表(score)、课程表(course)

-- 创建学生表
-- 学号
-- 姓名
-- 性别
-- 生日
-- 班级
CREATE TABLE student (
    no VARCHAR(20) PRIMARY KEY,
    name VARCHAR(20) NOT NULL,
    sex VARCHAR(10) NOT NULL,
    birthday DATE, -- 生日
    class VARCHAR(20) -- 所在班级
);


-- 创建教师表
-- 编号 
-- 姓名
-- 性别
-- 生日
-- 职称
-- 部门 
CREATE TABLE teacher (
    no VARCHAR(20) PRIMARY KEY,
    name VARCHAR(20) NOT NULL,
    sex VARCHAR(10) NOT NULL,
    birthday DATE,
    profession VARCHAR(20) NOT NULL, -- 职称
    department VARCHAR(20) NOT NULL -- 部门
);


-- 创建课程表
-- 课程编号
-- 教师名称
-- 教师编号
CREATE TABLE course (
    no VARCHAR(20) PRIMARY KEY,
    name VARCHAR(20) NOT NULL,
    t_no VARCHAR(20) NOT NULL, -- 教师编号
    -- 外键：表示该 tno 来自于 teacher 表中的 no 字段值
    FOREIGN KEY(t_no) REFERENCES teacher(no) 
);


-- 成绩表
-- 学生编号
-- 课程编号
-- 成绩
CREATE TABLE score (
    s_no VARCHAR(20) NOT NULL, -- 学生编号
    c_no VARCHAR(20) NOT NULL, -- 课程号
    degree DECIMAL,-- 成绩
    -- 外键：表示该 s_no, c_no 分别来自于 student, course 表中的 no 字段值
    FOREIGN KEY(s_no) REFERENCES student(no),
    FOREIGN KEY(c_no) REFERENCES course(no),
    -- 设置 s_no, c_no 为联合主键
    PRIMARY KEY(s_no, c_no)
);

添加数据：

-- 添加学生表数据
INSERT INTO student VALUES('101', '曾华', '男', '1977-09-01', '95033');
INSERT INTO student VALUES('102', '匡明', '男', '1975-10-02', '95031');
INSERT INTO student VALUES('103', '王丽', '女', '1976-01-23', '95033');
INSERT INTO student VALUES('104', '李军', '男', '1976-02-20', '95033');
INSERT INTO student VALUES('105', '王芳', '女', '1975-02-10', '95031');
INSERT INTO student VALUES('106', '陆军', '男', '1974-06-03', '95031');
INSERT INTO student VALUES('107', '王尼玛', '男', '1976-02-20', '95033');
INSERT INTO student VALUES('108', '张全蛋', '男', '1975-02-10', '95031');
INSERT INTO student VALUES('109', '赵铁柱', '男', '1974-06-03', '95031');

-- 添加教师表数据
INSERT INTO teacher VALUES('804', '李诚', '男', '1958-12-02', '副教授', '计算机系');
INSERT INTO teacher VALUES('856', '张旭', '男', '1969-03-12', '讲师', '电子工程系');
INSERT INTO teacher VALUES('825', '王萍', '女', '1972-05-05', '助教', '计算机系');
INSERT INTO teacher VALUES('831', '刘冰', '女', '1977-08-14', '助教', '电子工程系');

-- 添加课程表数据
INSERT INTO course VALUES('3-105', '计算机导论', '825');
INSERT INTO course VALUES('3-245', '操作系统', '804');
INSERT INTO course VALUES('6-166', '数字电路', '856');
INSERT INTO course VALUES('9-888', '高等数学', '831');

-- 添加添加成绩表数据
INSERT INTO score VALUES('103', '3-105', '92');
INSERT INTO score VALUES('103', '3-245', '86');
INSERT INTO score VALUES('103', '6-166', '85');
INSERT INTO score VALUES('105', '3-105', '88');
INSERT INTO score VALUES('105', '3-245', '75');
INSERT INTO score VALUES('105', '6-166', '79');
INSERT INTO score VALUES('109', '3-105', '76');
INSERT INTO score VALUES('109', '3-245', '68');
INSERT INTO score VALUES('109', '6-166', '81');

-- 查看表结构
SELECT * FROM course;
SELECT * FROM score;
SELECT * FROM student;
SELECT * FROM teacher;

十道练习题

-- 1.查询student表中所有记录
select * from student;

mysql> select * from student;
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 101 | 曾华      | 男  | 1977-09-01 | 95033 |
| 102 | 匡明      | 男  | 1975-10-02 | 95031 |
| 103 | 王丽      | 女  | 1976-01-23 | 95033 |
| 104 | 李军      | 男  | 1976-02-20 | 95033 |
| 105 | 王芳      | 女  | 1975-02-10 | 95031 |
| 106 | 陆军      | 男  | 1974-06-03 | 95031 |
| 107 | 王尼玛    | 男  | 1976-02-20 | 95033 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
| 109 | 赵铁柱    | 男  | 1974-06-03 | 95031 |
+-----+-----------+-----+------------+-------+


-- 2.查询 student 表中的 name、sex 和 class 字段的所有行
select name, sex, class from student;

mysql> select name, sex, class from student;
+-----------+-----+-------+
| name      | sex | class |
+-----------+-----+-------+
| 曾华      | 男  | 95033 |
| 匡明      | 男  | 95031 |
| 王丽      | 女  | 95033 |
| 李军      | 男  | 95033 |
| 王芳      | 女  | 95031 |
| 陆军      | 男  | 95031 |
| 王尼玛    | 男  | 95033 |
| 张全蛋    | 男  | 95031 |
| 赵铁柱    | 男  | 95031 |
+-----------+-----+-------+


-- 3.查询 teacher 表中不重复的 department 列
--   distinct: 去重查询
select distinct department from teacher;

mysql> select distinct department from teacher;
+-----------------+
| department      |
+-----------------+
| 计算机系        |
| 电子工程系      |
+-----------------+


-- 4.查询 score 表中成绩在60-80之间的所有行（区间查询和运算符查询）
--   BETWEEN xx AND xx: 查询区间, AND 表示 "并且"
select * from score where degree between 60 and 80;
select * from score where degree > 60 and degree < 80;

mysql> select * from score where degree between 60 and 80;
mysql> select * from score where degree > 60 and degree < 80;
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 105  | 3-245 |     75 |
| 105  | 6-166 |     79 |
| 109  | 3-105 |     76 |
| 109  | 3-245 |     68 |
+------+-------+--------+


-- 5.查询 score 表中成绩为 85, 86 或 88 的行
--   IN: 查询规定中的多个值
select * from score where degree in (85,86,88);

mysql> select * from score where degree in (85,86,88);
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-245 |     86 |
| 103  | 6-166 |     85 |
| 105  | 3-105 |     88 |
+------+-------+--------+


-- 6.查询 student 表中 '95031' 班或性别为 '女' 的所有行
--   or: 表示或者关系
select * from student where class = '95031' or sex = '女';

mysql> select * from student where class = '95031' or sex = '女';
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 102 | 匡明      | 男  | 1975-10-02 | 95031 |
| 103 | 王丽      | 女  | 1976-01-23 | 95033 |
| 105 | 王芳      | 女  | 1975-02-10 | 95031 |
| 106 | 陆军      | 男  | 1974-06-03 | 95031 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
| 109 | 赵铁柱    | 男  | 1974-06-03 | 95031 |
+-----+-----------+-----+------------+-------+


-- 7.以 class 降序的方式查询 student 表的所有行
--   DESC: 降序，从高到低
--   ASC（默认）: 升序，从低到高
select * from student order by class desc;
select * from student order by class; (asc)

mysql> select * from student order by class desc;
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 101 | 曾华      | 男  | 1977-09-01 | 95033 |
| 103 | 王丽      | 女  | 1976-01-23 | 95033 |
| 104 | 李军      | 男  | 1976-02-20 | 95033 |
| 107 | 王尼玛    | 男  | 1976-02-20 | 95033 |
| 102 | 匡明      | 男  | 1975-10-02 | 95031 |
| 105 | 王芳      | 女  | 1975-02-10 | 95031 |
| 106 | 陆军      | 男  | 1974-06-03 | 95031 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
| 109 | 赵铁柱    | 男  | 1974-06-03 | 95031 |
+-----+-----------+-----+------------+-------+

mysql> select * from student order by class;
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 102 | 匡明      | 男  | 1975-10-02 | 95031 |
| 105 | 王芳      | 女  | 1975-02-10 | 95031 |
| 106 | 陆军      | 男  | 1974-06-03 | 95031 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
| 109 | 赵铁柱    | 男  | 1974-06-03 | 95031 |
| 101 | 曾华      | 男  | 1977-09-01 | 95033 |
| 103 | 王丽      | 女  | 1976-01-23 | 95033 |
| 104 | 李军      | 男  | 1976-02-20 | 95033 |
| 107 | 王尼玛    | 男  | 1976-02-20 | 95033 |
+-----+-----------+-----+------------+-------+


-- 8.以 c_no 升序、degree 降序查询 score 表的所有行
--   先以c_no升、再以score降序
select * from score order by c_no , degree desc;

mysql> select * from score order by c_no , degree desc;
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-105 |     92 |
| 105  | 3-105 |     88 |
| 109  | 3-105 |     76 |
| 103  | 3-245 |     86 |
| 105  | 3-245 |     75 |
| 109  | 3-245 |     68 |
| 103  | 6-166 |     85 |
| 109  | 6-166 |     81 |
| 105  | 6-166 |     79 |
+------+-------+--------+


-- 9.查询 "95031" 班的学生人数
--   COUNT: 统计
select count(*) from student where class = '95031';

mysql> select count(*) from student where class = '95031';
+----------+
| count(*) |
+----------+
|        5 |
+----------+


-- 10.查询 score 表中的最高分的学生学号和课程编号（子查询或排序查询）。
--    (SELECT MAX(degree) FROM score): 子查询，算出最高分
select s_no, c_no from score where degree = (select max(degree) from score);

mysql> select s_no, c_no from score where degree = (select max(degree) from score);
+------+-------+
| s_no | c_no  |
+------+-------+
| 103  | 3-105 |
+------+-------+

--    排序方式
--    limit num1,num2
--    num1:表示从第 num1 条记录开始取；
--    num2:表示取 num2 条记录；
select s_no, c_no from score order by degree desc limit 0,1;

mysql> select s_no, c_no from score order by degree desc limit 0,1;
+------+-------+
| s_no | c_no  |
+------+-------+
| 103  | 3-105 |
+------+-------+

分组计算平均成绩

-- 查询每门课的平均成绩
-- AVG: 平均值
select avg(degree) from score where c_no = '3-105';

mysql> select avg(degree) from score where c_no = '3-105';
+-------------+
| avg(degree) |
+-------------+
|     85.3333 |
+-------------+


-- GROUP BY: 分组查询
SELECT c_no, AVG(degree) FROM score GROUP BY c_no;

mysql> SELECT c_no, AVG(degree) FROM score GROUP BY c_no;
+-------+-------------+
| c_no  | AVG(degree) |
+-------+-------------+
| 3-105 |     85.3333 |
| 3-245 |     76.3333 |
| 6-166 |     81.6667 |
+-------+-------------+

分组条件与模糊查询

-- 查询 score 表中至少有 2 名学生选修，并以 3 开头的课程的平均分数

-- 查询出至少有 2 名学生选修的课程
-- HAVING: 表示持有
HAVING COUNT(c_no) >= 2

-- 并且是以 3 开头的课程
-- LIKE 表示模糊查询，"%" 是一个通配符，匹配 "3" 后面的任意字符。
AND c_no LIKE '3%'

-- 最终语句
select c_no, avg(degree), count(c_no) from score GROUP BY c_no
HAVING COUNT(c_no) >= 2 and 
c_no LIKE '3%';

mysql> select c_no, avg(degree), count(c_no) from score GROUP BY c_no
    -> HAVING COUNT(c_no) >= 2 and
    -> c_no LIKE '3%';
+-------+-------------+-------------+
| c_no  | avg(degree) | count(c_no) |
+-------+-------------+-------------+
| 3-105 |     85.3333 |           3 |
| 3-245 |     76.3333 |           3 |
+-------+-------------+-------------+

多表查询

查询所有学生的 name，以及该学生在 score 表中对应的 c_no 和 degree :

-- SELECT no, name FROM student;
mysql> SELECT no, name FROM student;
+-----+-----------+
| no  | name      |
+-----+-----------+
| 101 | 曾华      |
| 102 | 匡明      |
| 103 | 王丽      |
| 104 | 李军      |
| 105 | 王芳      |
| 106 | 陆军      |
| 107 | 王尼玛    |
| 108 | 张全蛋    |
| 109 | 赵铁柱    |
+-----+-----------+


-- SELECT s_no, c_no, degree FROM score;

mysql> SELECT s_no, c_no, degree FROM score;
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-105 |     92 |
| 103  | 3-245 |     86 |
| 103  | 6-166 |     85 |
| 105  | 3-105 |     88 |
| 105  | 3-245 |     75 |
| 105  | 6-166 |     79 |
| 109  | 3-105 |     76 |
| 109  | 3-245 |     68 |
| 109  | 6-166 |     81 |
+------+-------+--------+


-- 查询所有学生的 name，以及该学生在 score 表中对应的 c_no 和 degree 
select name, c_no, degree from student, score
where student.no = score.s_no;

mysql> select name, c_no, degree from student, score
    -> where student.no = score.s_no;
+-----------+-------+--------+
| name      | c_no  | degree |
+-----------+-------+--------+
| 王丽      | 3-105 |     92 |
| 王丽      | 3-245 |     86 |
| 王丽      | 6-166 |     85 |
| 王芳      | 3-105 |     88 |
| 王芳      | 3-245 |     75 |
| 王芳      | 6-166 |     79 |
| 赵铁柱    | 3-105 |     76 |
| 赵铁柱    | 3-245 |     68 |
| 赵铁柱    | 6-166 |     81 |
+-----------+-------+--------+

查询所有学生的 no 、课程名称 ( course 表中的 name ) 和成绩 ( score 表中的 degree ) 列：

-- 查询所有学生的 no 、课程名称 ( course 表中的 name ) 和成绩 ( score 表中的 degree ) 列
select s_no, name, degree from course, score 
where course.no = score.c_no;

mysql> select s_no, name, degree from course, score
    -> where course.no = score.c_no;
+------+-----------------+--------+
| s_no | name            | degree |
+------+-----------------+--------+
| 103  | 计算机导论      |     92 |
| 103  | 操作系统        |     86 |
| 103  | 数字电路        |     85 |
| 105  | 计算机导论      |     88 |
| 105  | 操作系统        |     75 |
| 105  | 数字电路        |     79 |
| 109  | 计算机导论      |     76 |
| 109  | 操作系统        |     68 |
| 109  | 数字电路        |     81 |
+------+-----------------+--------+

-- as 表示取一个该字段的别名。
select s_no, name as c_name, degree from course, score 
where course.no = score.c_no;

mysql> select s_no, name as c_name, degree from course, score
    -> where course.no = score.c_no;
+------+-----------------+--------+
| s_no | c_name          | degree |
+------+-----------------+--------+
| 103  | 计算机导论      |     92 |
| 103  | 操作系统        |     86 |
| 103  | 数字电路        |     85 |
| 105  | 计算机导论      |     88 |
| 105  | 操作系统        |     75 |
| 105  | 数字电路        |     79 |
| 109  | 计算机导论      |     76 |
| 109  | 操作系统        |     68 |
| 109  | 数字电路        |     81 |
+------+-----------------+--------+

三表关联查询

查询所有学生的 name 、课程名 ( course 表中的 name ) 和 degree ：

-- 查询所有学生的 `name` 、课程名 ( `course` 表中的 `name` ) 和 `degree` 
-- name --> student表
-- c_name --> course表
-- degree --> score表
-- 只有 score 表中关联学生的学号和课堂号，我们只要围绕着 score 这张表查询就好了

-- 由于字段名存在重复，使用 "表名.字段名 as 别名" 代替。
select student.name, course.name as c_name, degree 
from student, course, score 
where student.no = score.s_no and 
course.no = score.c_no;

mysql> select student.name, course.name as c_name, degree
    -> from student, course, score
    -> where student.no = score.s_no and
    -> course.no = score.c_no;
+-----------+-----------------+--------+
| name      | c_name          | degree |
+-----------+-----------------+--------+
| 王丽      | 计算机导论      |     92 |
| 王丽      | 操作系统        |     86 |
| 王丽      | 数字电路        |     85 |
| 王芳      | 计算机导论      |     88 |
| 王芳      | 操作系统        |     75 |
| 王芳      | 数字电路        |     79 |
| 赵铁柱    | 计算机导论      |     76 |
| 赵铁柱    | 操作系统        |     68 |
| 赵铁柱    | 数字电路        |     81 |
+-----------+-----------------+--------+

子查询加分组求平均分

查询 95031 班学生每门课程的平均成绩：

-- 查询 95031 班学生每门课程的平均成绩
-- 1.查询 95031 班的学生学号作为条件
select no from student where class = '95031'

mysql> select no from student where class = '95031';
+-----+
| no  |
+-----+
| 102 |
| 105 |
| 106 |
| 108 |
| 109 |
+-----+

-- 2.IN (..): 将筛选出的学生号当做 s_no 的条件查询
select s_no, c_no, degree from score 
where s_no in (select no from student where class = '95031');

mysql> select s_no, c_no, degree from score
    -> where s_no in (select no from student where class = '95031');
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 105  | 3-105 |     88 |
| 105  | 3-245 |     75 |
| 105  | 6-166 |     79 |
| 109  | 3-105 |     76 |
| 109  | 3-245 |     68 |
| 109  | 6-166 |     81 |
+------+-------+--------+

-- 按课程号分组求平均：group by c_no
select c_no, avg(degree) 
from score 
where s_no in (select no from student where class = '95031') 
group by c_no;

mysql> select c_no, avg(degree)
    -> from score
    -> where s_no in (select no from student where class = '95031')
    -> group by c_no;
+-------+-------------+
| c_no  | avg(degree) |
+-------+-------------+
| 3-105 |     82.0000 |
| 3-245 |     71.5000 |
| 6-166 |     80.0000 |
+-------+-------------+

-- 将课程编号换成课程名
select name as c_name, avg(degree) 
from score, course
where s_no in (select no from student where class = '95031')   
and course.no = score.c_no
group by c_no;

mysql> select name as c_name, avg(degree)
    -> from score, course
    -> where s_no in (select no from student where class = '95031')
    -> and course.no = score.c_no
    -> group by c_no;
+-----------------+-------------+
| c_name          | avg(degree) |
+-----------------+-------------+
| 计算机导论      |     82.0000 |
| 操作系统        |     71.5000 |
| 数字电路        |     80.0000 |
+-----------------+-------------+

子查询

查询在 3-105 课程中，所有成绩高于 109 号同学的记录：

-- 查询在 3-105 课程中，所有成绩高于 109 号同学的记录
-- 1.首先筛选出课堂号为 3-105
select s_no, c_no from score where c_no = '3-105';

mysql> select s_no, c_no from score where c_no = '3-105';
+------+-------+
| s_no | c_no  |
+------+-------+
| 103  | 3-105 |
| 105  | 3-105 |
| 109  | 3-105 |
+------+-------+


-- 2.找到 109 同学的 3-105 成绩
select degree from score where s_no = '109' and c_no ='3-105';

mysql> select degree from score where s_no = '109' and c_no ='3-105';
+--------+
| degree |
+--------+
|     76 |
+--------+


-- 3.最终语句
select * from score 
where c_no = '3-105' 
and degree > (select degree from score where s_no = '109' and c_no ='3-105');

mysql> select * from score
    -> where c_no = '3-105'
    -> and degree > (select degree from score where s_no = '109' and c_no ='3-105');
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-105 |     92 |
| 105  | 3-105 |     88 |
+------+-------+--------+


-- 查询所有成绩高于 109 号同学的 3-105 课程成绩的所有记录。
select * from score 
where degree > (select degree from score where s_no = '109' and c_no ='3-105');
mysql> select * from score
    -> where degree > (select degree from score where s_no = '109' and c_no ='3-105');
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-105 |     92 |
| 103  | 3-245 |     86 |
| 103  | 6-166 |     85 |
| 105  | 3-105 |     88 |
| 105  | 6-166 |     79 |
| 109  | 6-166 |     81 |
+------+-------+--------+

YEAR 函数与带 IN 关键字查询

查询所有和 101 、108 号学生同年出生的 no 、name 、birthday 列

-- 查询所有和 `101` 、`108` 号学生同年出生的 `no` 、`name` 、`birthday` 列
select * from student where no in ('101', '108');

mysql> select * from student where no in ('101', '108');
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 101 | 曾华      | 男  | 1977-09-01 | 95033 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
+-----+-----------+-----+------------+-------+


-- 查询年份 year
select year(birthday) from student where no in ('101', '108');

mysql> select year(birthday) from student where no in ('101', '108');
+----------------+
| year(birthday) |
+----------------+
|           1977 |
|           1975 |
+----------------+


-- 最终语句
select no, name, birthday from student 
where year(birthday) 
in ( select year(birthday) from student where no in ('101', '108') );

mysql> select no, name, birthday from student
    -> where year(birthday)
    -> in ( select year(birthday) from student where no in ('101', '108') );
+-----+-----------+------------+
| no  | name      | birthday   |
+-----+-----------+------------+
| 101 | 曾华      | 1977-09-01 |
| 102 | 匡明      | 1975-10-02 |
| 105 | 王芳      | 1975-02-10 |
| 108 | 张全蛋    | 1975-02-10 |
+-----+-----------+------------+

多层嵌套子查询

查询 '张旭' 教师任课的学生成绩表

-- 查询 '张旭' 教师任课的学生成绩表

-- 查找对应教师的编号
select no from teacher where name = '张旭';

mysql> select no from teacher where name = '张旭';
+-----+
| no  |
+-----+
| 856 |
+-----+


-- 2.通过教师编号查找对应的课程
select * from course where t_no = (select no from teacher where name = '张旭');

mysql> select * from course where t_no = (select no from teacher where name = '张旭');
+-------+--------------+------+
| no    | name         | t_no |
+-------+--------------+------+
| 6-166 | 数字电路     | 856  |
+-------+--------------+------+


-- 3.通过课程编号查找学生成绩表
select * from score 
where c_no = 
(select no from course where t_no = (select no from teacher where name = '张旭'));

mysql> select * from score
    -> where c_no =
    -> (select no from course where t_no = (select no from teacher where name = '张旭'));
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 6-166 |     85 |
| 105  | 6-166 |     79 |
| 109  | 6-166 |     81 |
+------+-------+--------+

多表查询

查询某选修课程多于5个同学的教师姓名

-- 查询某选修课程多于5个同学的教师姓名

-- 1.找到选修课程大于5个同学的课程
select c_no from score group by c_no having count(c_no)>5;

mysql> select c_no from score group by c_no having count(c_no)>5;
+-------+
| c_no  |
+-------+
| 3-105 |
+-------+


-- 2.找到该课程对应的教师编号
select t_no from course 
where no in (select c_no from score group by c_no having count(c_no)>5);

mysql> select t_no from course
    -> where no in (select c_no from score group by c_no having count(c_no)>5);
+------+
| t_no |
+------+
| 825  |
+------+


-- 3.根据教师编号找到对应的教师姓名
select name from teacher 
where no in (select t_no from course 
where no in (select c_no from score group by c_no having count(c_no)>5));
             
mysql> select name from teacher
    -> where no in (select t_no from course
    -> where no in (select c_no from score group by c_no having count(c_no)>5));
+--------+
| name   |
+--------+
| 王萍   |
+--------+

子查询-2

查询计算机系所有老师的上的课的成绩表

-- 查询计算机系所有老师的上的课的成绩表

-- 1.查询所有计算机系的老师
select * from teacher where department = '计算机系';

mysql> select * from teacher where department = '计算机系';
+-----+--------+-----+------------+------------+--------------+
| no  | name   | sex | birthday   | profession | department   |
+-----+--------+-----+------------+------------+--------------+
| 804 | 李诚   | 男  | 1958-12-02 | 副教授     | 计算机系     |
| 825 | 王萍   | 女  | 1972-05-05 | 助教       | 计算机系     |
+-----+--------+-----+------------+------------+--------------+


-- 2.根据教师编号，查询计算机系老师上的课
select * from course 
where t_no in (select no from teacher where department = '计算机系');

mysql> select * from course
    -> where t_no in (select no from teacher where department = '计算机系');
+-------+-----------------+------+
| no    | name            | t_no |
+-------+-----------------+------+
| 3-245 | 操作系统        | 804  |
| 3-105 | 计算机导论      | 825  |
+-------+-----------------+------+


-- 3.根据课程编号，查询对应课程的成绩表
select * from score
where c_no in (select no from course 
where t_no in (select no from teacher where department = '计算机系'));

mysql> select * from score
    -> where c_no in (select no from course
    -> where t_no in (select no from teacher where department = '计算机系'));
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-245 |     86 |
| 105  | 3-245 |     75 |
| 109  | 3-245 |     68 |
| 101  | 3-105 |     90 |
| 102  | 3-105 |     91 |
| 103  | 3-105 |     92 |
| 104  | 3-105 |     89 |
| 105  | 3-105 |     88 |
| 109  | 3-105 |     76 |
+------+-------+--------+

UNION 和 NOT IN 的使用

-- 查询 计算机系 与 电子工程系 中的不同职称的教师
-- -- NOT: 代表逻辑非
-- -- UNION：求并集

-- 查询 计算机系 教师的职称
select profession from teacher where department = '计算机系';

-- 查询 电子工程系 教师的职称
select profession from teacher where department = '电子工程系';


-- 查询 计算机系 中，职称在电子工程系没有的教师
select * from teacher 
where department = '计算机系' 
and profession not in (select profession from teacher where department = '电子工程系');

+-----+--------+-----+------------+------------+--------------+
| no  | name   | sex | birthday   | profession | department   |
+-----+--------+-----+------------+------------+--------------+
| 804 | 李诚   | 男  | 1958-12-02 | 副教授     | 计算机系     |
+-----+--------+-----+------------+------------+--------------+


-- 查询 电子工程系 中，职称在计算机系没有的教师
select * from teacher 
where department = '电子工程系' 
and profession not in (select profession from teacher where department = '计算机系');

+-----+--------+-----+------------+------------+-----------------+
| no  | name   | sex | birthday   | profession | department      |
+-----+--------+-----+------------+------------+-----------------+
| 856 | 张旭   | 男  | 1969-03-12 | 讲师       | 电子工程系      |
+-----+--------+-----+------------+------------+-----------------+


-- 最终语句：用 UNION 将两个语句合起来
select * from teacher 
where department = '计算机系' 
and profession not in (select profession from teacher where department = '电子工程系')
union
select * from teacher 
where department = '电子工程系' 
and profession not in (select profession from teacher where department = '计算机系');

+-----+--------+-----+------------+------------+-----------------+
| no  | name   | sex | birthday   | profession | department      |
+-----+--------+-----+------------+------------+-----------------+
| 804 | 李诚   | 男  | 1958-12-02 | 副教授     | 计算机系        |
| 856 | 张旭   | 男  | 1969-03-12 | 讲师       | 电子工程系      |
+-----+--------+-----+------------+------------+-----------------+

ANY 表示至少一个 - DESC ( 降序 )

查询课程 3-105 且成绩至少高于 3-245 的 score 表(大于 3-245 的最小值)

-- 查询课程 `3-105` 且成绩 至少 高于 `3-245` 的 `score` 表
select * from score 
where c_no = '3-105' and degree > any(select degree from score where c_no = '3-245')
order by degree desc;

mysql> select * from score
    -> where c_no = '3-105' and degree > any(select degree from score where c_no = '3-245')
    -> order by degree desc;
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-105 |     92 |
| 102  | 3-105 |     91 |
| 101  | 3-105 |     90 |
| 104  | 3-105 |     89 |
| 105  | 3-105 |     88 |
| 109  | 3-105 |     76 |
+------+-------+--------+

表示所有的 ALL

查询课程 3-105 且成绩高于 3-245 的 score 表

-- 查询课程 3-105 且成绩高于 3-245 的 score 表
-- all
select * from score 
where c_no = '3-105' and degree > all(select degree from score where c_no = '3-245')
order by degree desc;

mysql> select * from score
    -> where c_no = '3-105' and degree > all(select degree from score where c_no = '3-245')
    -> order by degree desc;
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-105 |     92 |
| 102  | 3-105 |     91 |
| 101  | 3-105 |     90 |
| 104  | 3-105 |     89 |
| 105  | 3-105 |     88 |
+------+-------+--------+

复制表的数据作为条件查询

查询某课程成绩比该课程平均成绩低的 score 表

-- 查询某课程成绩比该课程平均成绩低的 `score` 表
-- 查询平均分
SELECT c_no, AVG(degree) FROM score GROUP BY c_no;

mysql> SELECT c_no, AVG(degree) FROM score GROUP BY c_no;
+-------+-------------+
| c_no  | AVG(degree) |
+-------+-------------+
| 3-105 |     87.6667 |
| 3-245 |     76.3333 |
| 6-166 |     81.6667 |
+-------+-------------+

-- 将表 b 作用于表 a 中查询数据
-- score a (b): 将表声明为 a (b)，
-- 如此就能用 a.c_no = b.c_no 作为条件执行查询了
select * from score a
where degree < (SELECT AVG(degree) FROM score b where a.c_no = b.c_no);

mysql> select * from score a
    -> where degree < (SELECT AVG(degree) FROM score b where a.c_no = b.c_no);
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 105  | 3-245 |     75 |
| 105  | 6-166 |     79 |
| 109  | 3-105 |     76 |
| 109  | 3-245 |     68 |
| 109  | 6-166 |     81 |
+------+-------+--------+

子查询 - 4

查询所有任课 ( 在 course 表里有课程 ) 教师的 name 和 department

-- 查询所有任课 ( 在 `course` 表里有课程 ) 教师的 `name` 和 `department` 
select name, department from teacher 
where no in (select t_no from course);

mysql> select name, department from teacher
    -> where no in (select t_no from course);
+--------+-----------------+
| name   | department      |
+--------+-----------------+
| 李诚   | 计算机系        |
| 王萍   | 计算机系        |
| 刘冰   | 电子工程系      |
| 张旭   | 电子工程系      |
+--------+-----------------+

条件加组筛选

查询 student 表中至少有 2 名男生的 class

-- 查询 `student` 表中至少有 2 名男生的 `class` 
select * from student;

mysql> select * from student;
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 101 | 曾华      | 男  | 1977-09-01 | 95033 |
| 102 | 匡明      | 男  | 1975-10-02 | 95031 |
| 103 | 王丽      | 女  | 1976-01-23 | 95033 |
| 104 | 李军      | 男  | 1976-02-20 | 95033 |
| 105 | 王芳      | 女  | 1975-02-10 | 95031 |
| 106 | 陆军      | 男  | 1974-06-03 | 95031 |
| 107 | 王尼玛    | 男  | 1976-02-20 | 95033 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
| 109 | 赵铁柱    | 男  | 1974-06-03 | 95031 |
| 200 | 王喜全    | 男  | 1974-06-03 | 95038 |
+-----+-----------+-----+------------+-------+

select class from student 
WHERE sex = '男'
group by class having count(sex) > 1;

mysql> select class from student
    -> WHERE sex = '男'
    -> group by class having count(sex) > 1;
+-------+
| class |
+-------+
| 95031 |
| 95033 |
+-------+

NOTLIKE 模糊查询取反

查询 student 表中不姓 “王” 的同学记录

-- NOT: 取反
-- LIKE: 模糊查询
select * from student where name not like '王%';

mysql> select * from student where name not like '王%';
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 101 | 曾华      | 男  | 1977-09-01 | 95033 |
| 102 | 匡明      | 男  | 1975-10-02 | 95031 |
| 104 | 李军      | 男  | 1976-02-20 | 95033 |
| 106 | 陆军      | 男  | 1974-06-03 | 95031 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
| 109 | 赵铁柱    | 男  | 1974-06-03 | 95031 |
+-----+-----------+-----+------------+-------+

YEAR 与 NOW 函数

查询 student 表中每个学生的姓名和年龄

-- 查询 `student` 表中每个学生的姓名和年龄
-- select year(now())查询当前年份
select year(now()); -- 查询当前年份

mysql> select year(now());
+-------------+
| year(now()) |
+-------------+
|        2020 |
+-------------+

-- 查询姓名，年龄
select name, year(now())-year(birthday) as '年龄' from student;

mysql> select name, year(now())-year(birthday) as '年龄' from student;
+-----------+--------+
| name      | 年龄   |
+-----------+--------+
| 曾华      |     43 |
| 匡明      |     45 |
| 王丽      |     44 |
| 李军      |     44 |
| 王芳      |     45 |
| 陆军      |     46 |
| 王尼玛    |     44 |
| 张全蛋    |     45 |
| 赵铁柱    |     46 |
| 王喜全    |     46 |
+-----------+--------+

MAX 与 MIN 函数

查询 student 表中最大和最小的 birthday 值

-- 查询 `student` 表中最大和最小的 `birthday` 值
select max(birthday), min(birthday) from student; -- 根据年份数值的大小

mysql> select max(birthday), min(birthday) from student;
+---------------+---------------+
| max(birthday) | min(birthday) |
+---------------+---------------+
| 1977-09-01    | 1974-06-03    |
+---------------+---------------+

多段排序

以 class 和 birthday 从大到小的顺序查询 student 表

-- 以 `class` 和 `birthday` 从大到小的顺序查询 `student` 表
select * from student order by class desc, birthday;

mysql> select * from student order by class desc, birthday;
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 200 | 王喜全    | 男  | 1974-06-03 | 95038 |
| 103 | 王丽      | 女  | 1976-01-23 | 95033 |
| 104 | 李军      | 男  | 1976-02-20 | 95033 |
| 107 | 王尼玛    | 男  | 1976-02-20 | 95033 |
| 101 | 曾华      | 男  | 1977-09-01 | 95033 |
| 106 | 陆军      | 男  | 1974-06-03 | 95031 |
| 109 | 赵铁柱    | 男  | 1974-06-03 | 95031 |
| 105 | 王芳      | 女  | 1975-02-10 | 95031 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
| 102 | 匡明      | 男  | 1975-10-02 | 95031 |
+-----+-----------+-----+------------+-------+

子查询 - 5

查询 “男” 教师及其所上的课程

-- 查询 "男" 教师及其所上的课程
select * from teacher where sex = '男';

mysql> select * from teacher where sex = '男';
+-----+--------+-----+------------+------------+-----------------+
| no  | name   | sex | birthday   | profession | department      |
+-----+--------+-----+------------+------------+-----------------+
| 804 | 李诚   | 男  | 1958-12-02 | 副教授     | 计算机系        |
| 856 | 张旭   | 男  | 1969-03-12 | 讲师       | 电子工程系      |
+-----+--------+-----+------------+------------+-----------------+

-- 查询课程
select * from course 
where t_no in (select no from teacher where sex = '男');

mysql> select * from course
    -> where t_no in (select no from teacher where sex = '男');
+-------+--------------+------+
| no    | name         | t_no |
+-------+--------------+------+
| 3-245 | 操作系统     | 804  |
| 6-166 | 数字电路     | 856  |
+-------+--------------+------+


-- 显示教师姓名
select teacher.name, course.name 
from teacher,course 
where t_no in (select no from teacher where sex = '男') 
and teacher.no = course.t_no;

mysql> select teacher.name, course.name
    -> from teacher,course
    -> where t_no in (select no from teacher where sex = '男')
    -> and teacher.no = course.t_no;
+--------+--------------+
| name   | name         |
+--------+--------------+
| 李诚   | 操作系统     |
| 张旭   | 数字电路     |
+--------+--------------+

MAX 函数与子查询

查询最高分同学的 score

-- 查询最高分同学的 `score` 
-- 查询最高成绩
select max(degree) from score;

mysql> select max(degree) from score;
+-------------+
| max(degree) |
+-------------+
|          92 |
+-------------+

-- 查询学生
select * from score 
where degree = (select max(degree) from score);

mysql> select * from score
    -> where degree = (select max(degree) from score);
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 103  | 3-105 |     92 |
+------+-------+--------+

-- 多表查询
select student.name, score.s_no, degree 
from student,score 
where degree = (select max(degree) from score)
and student.no = score.s_no;

mysql> select student.name, score.s_no, degree
    -> from student,score
    -> where degree = (select max(degree) from score)
    -> and student.no = score.s_no;
+--------+------+--------+
| name   | s_no | degree |
+--------+------+--------+
| 王丽   | 103  |     92 |
+--------+------+--------+

子查询 - 6

查询和 “李军” 同性别的所有同学 name

-- 查询和 "李军" 同性别的所有同学 `name` 

-- 查询李军性别
select sex from student where name = '李军';

mysql> select sex from student where name = '李军';
+-----+
| sex |
+-----+
| 男  |
+-----+


-- 查询同性别
select name from student 
where sex = (select sex from student where name = '李军');

mysql> select name from student
    -> where sex = (select sex from student where name = '李军');
+-----------+
| name      |
+-----------+
| 曾华      |
| 匡明      |
| 李军      |
| 陆军      |
| 王尼玛    |
| 张全蛋    |
| 赵铁柱    |
| 王喜全    |
+-----------+

子查询 - 7

查询和 “李军” 同性别且同班的同学 name

-- 查询和 "李军" 同性别且同班的同学 `name`
select name, class from student 
where sex = (select sex from student where name = '李军')
and class = (select class from student where name = '李军');

mysql> select name, class from student
    -> where sex = (select sex from student where name = '李军')
    -> and class = (select class from student where name = '李军');
+-----------+-------+
| name      | class |
+-----------+-------+
| 曾华      | 95033 |
| 李军      | 95033 |
| 王尼玛    | 95033 |
+-----------+-------+

子查询 - 8

查询所有选修 “计算机导论” 课程的 “男” 同学成绩表

需要的 “计算机导论” 和性别为 “男” 的编号可以在 course 和 student 表中找到

-- 查询所有选修 "计算机导论" 课程的 "男" 同学成绩表

-- 查询计算机导论
select * from course where name = '计算机导论';

mysql> select * from course where name = '计算机导论';
+-------+-----------------+------+
| no    | name            | t_no |
+-------+-----------------+------+
| 3-105 | 计算机导论      | 825  |
+-------+-----------------+------+


-- 查询性别为男
select * from student where sex = '男';

mysql> select * from student where sex = '男';
+-----+-----------+-----+------------+-------+
| no  | name      | sex | birthday   | class |
+-----+-----------+-----+------------+-------+
| 101 | 曾华      | 男  | 1977-09-01 | 95033 |
| 102 | 匡明      | 男  | 1975-10-02 | 95031 |
| 104 | 李军      | 男  | 1976-02-20 | 95033 |
| 106 | 陆军      | 男  | 1974-06-03 | 95031 |
| 107 | 王尼玛    | 男  | 1976-02-20 | 95033 |
| 108 | 张全蛋    | 男  | 1975-02-10 | 95031 |
| 109 | 赵铁柱    | 男  | 1974-06-03 | 95031 |
| 200 | 王喜全    | 男  | 1974-06-03 | 95038 |
+-----+-----------+-----+------------+-------+


-- 查询成绩表
select * from score 
where c_no = (select no from course where name = '计算机导论')
and s_no in (select no from student where sex = '男');

mysql> select * from score
    -> where c_no = (select no from course where name = '计算机导论')
    -> and s_no in (select no from student where sex = '男');
+------+-------+--------+
| s_no | c_no  | degree |
+------+-------+--------+
| 101  | 3-105 |     90 |
| 102  | 3-105 |     91 |
| 104  | 3-105 |     89 |
| 109  | 3-105 |     76 |
+------+-------+--------+

按等级查询

-- 建立一个 `grade` 表代表学生的成绩等级，并插入数据
create table grade(
  low int(5),
  top int(5),
  grade char(1) 
);

insert into grade values(90, 100, 'A');
INSERT INTO grade VALUES (80, 89, 'B');
INSERT INTO grade VALUES (70, 79, 'C');
INSERT INTO grade VALUES (60, 69, 'D');
INSERT INTO grade VALUES (0, 59, 'E');

mysql> select * from grade;
+------+------+-------+
| low  | top  | grade |
+------+------+-------+
|   90 |  100 | A     |
|   80 |   89 | B     |
|   70 |   79 | C     |
|   60 |   69 | D     |
|    0 |   59 | E     |
+------+------+-------+

-- 查询所有学生的degree  s_no 、c_no 和 grade 列
select score.degree, score.s_no, score.c_no, grade 
from score, grade 
where degree between low and top;

ysql> select score.degree, score.s_no, score.c_no, grade
    -> from score, grade
    -> where degree between low and top;
+--------+------+-------+-------+
| degree | s_no | c_no  | grade |
+--------+------+-------+-------+
|     90 | 101  | 3-105 | A     |
|     91 | 102  | 3-105 | A     |
|     92 | 103  | 3-105 | A     |
|     86 | 103  | 3-245 | B     |
|     85 | 103  | 6-166 | B     |
|     89 | 104  | 3-105 | B     |
|     88 | 105  | 3-105 | B     |
|     75 | 105  | 3-245 | C     |
|     79 | 105  | 6-166 | C     |
|     76 | 109  | 3-105 | C     |
|     68 | 109  | 3-245 | D     |
|     81 | 109  | 6-166 | B     |
+--------+------+-------+-------+

mysql连接查询

准备数据：

CREATE DATABASE testJoin;

CREATE TABLE person (
    id INT,
    name VARCHAR(20),
    cardId INT
);

CREATE TABLE card (
    id INT,
    name VARCHAR(20)
);

INSERT INTO card VALUES (1, '饭卡'), (2, '建行卡'), (3, '农行卡'), (4, '工商卡'), (5, '邮政卡');

SELECT * FROM card;
+------+-----------+
| id   | name      |
+------+-----------+
|    1 | 饭卡      |
|    2 | 建行卡    |
|    3 | 农行卡    |
|    4 | 工商卡    |
|    5 | 邮政卡    |
+------+-----------+

INSERT INTO person VALUES (1, '张三', 1), (2, '李四', 3), (3, '王五', 6);

SELECT * FROM person;
+------+--------+--------+
| id   | name   | cardId |
+------+--------+--------+
|    1 | 张三   |      1 |
|    2 | 李四   |      3 |
|    3 | 王五   |      6 |
+------+--------+--------+

分析两张表发现，person 表并没有为 cardId 字段设置一个在 card 表中对应的 id 外键。如果设置了的话，person 中 cardId 字段值为 6 的行就插不进去，因为该 cardId 值在 card 表中并没有

内连接

inner join 或者 join

要查询这两张表中有关系的数据，可以使用 INNER JOIN ( 内连接 ) 将它们连接在一起

select * from person inner join card on person.cardId = card.id;

mysql> select * from person inner join card on person.cardId = card.id;
+------+--------+--------+------+-----------+
| id   | name   | cardId | id   | name      |
+------+--------+--------+------+-----------+
|    1 | 张三   |      1 |    1 | 饭卡      |
|    2 | 李四   |      3 |    3 | 农行卡    |
+------+--------+--------+------+-----------+

-- 将 INNER 关键字省略掉，结果也是一样的
-- SELECT * FROM person JOIN card on person.cardId = card.id;

注意：card 的整张表被连接到了右边

外链接

左外连接：left join 或者 left outer join

完整显示左边的表 ( person ) ，右边的表如果符合条件就显示，不符合则补 NULL

select * from person left join card on person.cardId = card.id;

mysql> select * from person left join card on person.cardId = card.id;
+------+--------+--------+------+-----------+
| id   | name   | cardId | id   | name      |
+------+--------+--------+------+-----------+
|    1 | 张三   |      1 |    1 | 饭卡      |
|    2 | 李四   |      3 |    3 | 农行卡    |
|    3 | 王五   |      6 | NULL | NULL      |
+------+--------+--------+------+-----------+

--  left outer join，结果也是一样的

右外连接：right join 或者 right outer join

完整显示右边的表 ( card ) ，左边的表如果符合条件就显示，不符合则补 NULL

select * from person right join card on person.cardId = card.id;

mysql> select * from person right join card on person.cardId = card.id;
+------+--------+--------+------+-----------+
| id   | name   | cardId | id   | name      |
+------+--------+--------+------+-----------+
|    1 | 张三   |      1 |    1 | 饭卡      |
|    2 | 李四   |      3 |    3 | 农行卡    |
| NULL | NULL   |   NULL |    2 | 建行卡    |
| NULL | NULL   |   NULL |    4 | 工商卡    |
| NULL | NULL   |   NULL |    5 | 邮政卡    |
+------+--------+--------+------+-----------+

--  right outer join，结果也是一样的

完全连接：full join 或者 full outer join

-- mysql 不支持全连接语法
-- SELECT * FROM person FULL JOIN card on person.cardId = card.id;
-- ERROR 1054 (42S22): Unknown column 'person.cardId' in 'on clause'

-- 使用union
select * from person left join card on person.cardId = card.id
union
select * from person right join card on person.cardId = card.id;

mysql> select * from person left join card on person.cardId = card.id
    -> union
    -> select * from person right join card on person.cardId = card.id;
+------+--------+--------+------+-----------+
| id   | name   | cardId | id   | name      |
+------+--------+--------+------+-----------+
|    1 | 张三   |      1 |    1 | 饭卡      |
|    2 | 李四   |      3 |    3 | 农行卡    |
|    3 | 王五   |      6 | NULL | NULL      |
| NULL | NULL   |   NULL |    2 | 建行卡    |
| NULL | NULL   |   NULL |    4 | 工商卡    |
| NULL | NULL   |   NULL |    5 | 邮政卡    |
+------+--------+--------+------+-----------+

事务

在 MySQL 中，事务其实是一个最小的不可分割的工作单元。事务能够保证一个业务的完整性。

-- 比如我们的银行转账：
-- a -> -100
UPDATE user set money = money - 100 WHERE name = 'a';

-- b -> +100
UPDATE user set money = money + 100 WHERE name = 'b';

在实际项目中，假设只有一条 SQL 语句执行成功，而另外一条执行失败了，就会出现数据前后不一致。

因此，在执行多条有关联 SQL 语句时，事务会要求这些 SQL 语句要么同时执行成功，要么就都执行失败。

如何控制事务 - COMMIT / ROLLBACK

在 MySQL 中，事务的自动提交状态默认是开启的

-- 查询事务的自动提交状态
SELECT @@AUTOCOMMIT;

mysql> SELECT @@AUTOCOMMIT;
+--------------+
| @@AUTOCOMMIT |
+--------------+
|            1 |
+--------------+

自动提交的作用：当我们执行一条 SQL 语句的时候，其产生的效果就会立即体现出来，且不能回滚。

什么是回滚？举个例子：

CREATE DATABASE bank;

CREATE TABLE user (
    id INT PRIMARY KEY,
    name VARCHAR(20),
    money INT
);

-- 插入数据
INSERT INTO user VALUES (1, 'a', 1000);

SELECT * FROM user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
+----+------+-------+

可以看到，在执行插入语句后数据立刻生效，原因是 MySQL 中的事务自动将它提交到了数据库中。那么所谓回滚的意思就是，撤销执行过的所有 SQL 语句，使其回滚到最后一次提交数据时的状态。

在 MySQL 中使用 ROLLBACK 执行回滚：

-- 回滚到最后一次提交
rollback;

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT * FROM user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
+----+------+-------+

由于所有执行过的 SQL 语句都已经被提交过了，所以数据并没有发生回滚。那如何让数据可以发生回滚：设置AUTOCOMMIT = 0；

-- 关闭自动提交
-- 关闭 AUTOCOMMIT 后，数据的变化是在一张虚拟的临时数据表中展示，
-- 发生变化的数据并没有真正插入到数据表中。
SET AUTOCOMMIT = 0;

mysql> SET AUTOCOMMIT = 0;
Query OK, 0 rows affected (0.00 sec)

mysql> select @@autocommit;
+--------------+
| @@autocommit |
+--------------+
|            0 |
+--------------+


-- 测试回滚
INSERT INTO user VALUES (2, 'b', 1000);

mysql> INSERT INTO user VALUES (2, 'b', 1000);
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT * FROM user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
+----+------+-------+


-- 手动提交数据（持久性），
-- 将数据真正提交到数据库中，执行后不能再回滚提交过的数据
commit;

mysql> INSERT INTO user VALUES (2, 'b', 1000);
Query OK, 1 row affected (0.00 sec)

mysql> commit;
Query OK, 0 rows affected (0.00 sec)

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT * FROM user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
-- 发现回滚无效

总结：

自动提交
- 查看自动提交状态：SELECT @@AUTOCOMMIT ；
- 设置自动提交状态：SET AUTOCOMMIT = 0 。
手动提交
@@AUTOCOMMIT = 0 时，使用 COMMIT 命令提交事务。
事务回滚
@@AUTOCOMMIT = 0 时，使用 ROLLBACK 命令回滚事务。

-- 测试银行转账
update user set money = money - 100 where id = 1;
update user set money = money + 100 where id = 2;

mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1100 |
+----+------+-------+

-- 回滚：假设转账发生了意外，需要回滚
rollback;

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+

这时我们又回到了发生意外之前的状态，也就是说，事务给我们提供了一个可以反悔的机会。假设数据没有发生意外，这时可以手动将数据真正提交到数据表中：COMMIT

手动开启事务 - BEGIN / START TRANSACTION

-- 设置为自动提交
set autocommit = 1;

select @@autocommit;

mysql> select @@autocommit;
+--------------+
| @@autocommit |
+--------------+
|            1 |
+--------------+

事务的默认提交被开启 ( @@AUTOCOMMIT = 1 ) 后，此时就不能使用事务回滚了。但是我们还可以手动开启一个事务处理事件，使其可以发生回滚：

使用 BEGIN 或者 START TRANSACTION 手动开启一个事务:

-- 使用 BEGIN 或者 START TRANSACTION 手动开启一个事务
begin;
update user set money = money - 100 where id = 1;
update user set money = money + 100 where id = 2;

mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1100 |
+----+------+-------+

-- 回滚
rollback;

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+

-- 用commit提交事务

事务的 ACID 特征与使用

事务的四大特征：

A(Atomicity)：原子性：事务是最小的单位，不可以再分割；

C(Consistency)：一致性：要求同一事务中的 SQL 语句，必须保证同时成功或者失败；

I(Isolation)：隔离性：事务1 和事务2 之间是具有隔离性的；

D(Durability)：持久性：事务一旦结束 ( COMMIT ) ，就不可以再返回了 ( ROLLBACK ) ；

事务的隔离性可分为四种 ( 性能从低到高 ) ：

READ - UNCOMMITTED ( 读取未提交 )
如果有多个事务，那么任意事务都可以看见其他事务的未提交数据。
READ - COMMITTED ( 读取已提交 )
只能读取到其他事务已经提交的数据。
REPEATABLE - READ ( 可被重复读 )
如果有多个连接都开启了事务，那么事务之间不能共享数据记录，否则只能共享已提交的记录。
SERIALIZABLE ( 串行化 )
所有的事务都会按照固定顺序执行，执行完一个事务后再继续执行下一个事务的写入操作。

-- 查看当前数据库的默认隔离级别：
-- MySQL 8.x, GLOBAL 表示系统级别，不加表示会话级别。
SELECT @@GLOBAL.TRANSACTION_ISOLATION;
SELECT @@TRANSACTION_ISOLATION;


-- MySQL 5.x
mysql> SELECT @@GLOBAL.TX_ISOLATION;
+-----------------------+
| @@GLOBAL.TX_ISOLATION |
+-----------------------+
| REPEATABLE-READ       | -- MySQL的默认隔离级别，可以重复读。
+-----------------------+


-- 设置系统隔离级别，LEVEL 后面表示要设置的隔离级别 (READ UNCOMMITTED)
set global transaction isolation level READ COMMITTED;

mysql> set global transaction isolation level READ COMMITTED;
Query OK, 0 rows affected (0.01 sec)

mysql> SELECT @@GLOBAL.TX_ISOLATION;
+-----------------------+
| @@GLOBAL.TX_ISOLATION |
+-----------------------+
| READ-COMMITTED        |
+-----------------------+

脏读：READ UNCOMMITTED ( 读取未提交 )

一个事务读取到另外一个事务还未提交的数据。这在实际开发中是不允许出现的；

如果此时 rollback ，之前操作的数据就会失效

不可重复读：读取已提交：READ - COMMITTED ( 读取已提交 )

虽然 READ COMMITTED 让我们只能读取到其他事务已经提交的数据，但还是会出现问题，就是在读取同一个表的数据时，可能会发生前后不一致的情况。这被称为不可重复读现象 ( READ COMMITTED )

幻读：REPEATABLE - READ ( 可被重复读 )

当前事务开启后，没提交之前，查询不到，提交后可以被查询到。但是，在提交之前其他事务被开启了，那么在这条事务线上，就不会查询到当前有操作事务的连接。相当于开辟出一条单独的线程。

无论小张是否执行过 COMMIT ，在小王这边，都不会查询到小张的事务记录，而是只会查询到自己所处事务的记录

-- 小张 - 成都
START TRANSACTION;
INSERT INTO user VALUES (6, 'd', 1000);

-- 小王 - 北京
START TRANSACTION;

-- 小张 - 成都
COMMIT;

SELECT * FROM user;
+----+-----------+-------+
| id | name      | money |
+----+-----------+-------+
|  1 | a         |   900 |
|  2 | b         |  1100 |
|  3 | 小明      |  1000 |
|  4 | 淘宝店    |  1000 |
|  5 | c         |   100 |
+----+-----------+-------+

这是因为小王在此之前开启了一个新的事务 ( START TRANSACTION ) ，那么在他的这条新事务的线上，跟其他事务是没有联系的，也就是说，此时如果其他事务正在操作数据，它是不知道的。

然而事实是，在真实的数据表中，小张已经插入了一条数据

串行化：SERIALIZABLE ( 串行化 )

-- 设置隔离级别
set global transaction isolation level SERIALIZABLE;

mysql> set global transaction isolation level SERIALIZABLE;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @@GLOBAL.TX_ISOLATION;
+-----------------------+
| @@GLOBAL.TX_ISOLATION |
+-----------------------+
| SERIALIZABLE          |
+-----------------------+


-- 小张插入数据
INSERT INTO user VALUES (7, 'hhh', 1000);

mysql> commit;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
|  7 | hhh  |  1000 |
+----+------+-------+

-- 小王查询
mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
|  7 | hhh  |  1000 |
+----+------+-------+

此时会发生什么呢？由于现在的隔离级别是 SERIALIZABLE ( 串行化 ) ，串行化的意思就是：假设把所有的事务都放在一个串行的队列中，那么所有的事务都会按照固定顺序执行，执行完一个事务后再继续执行下一个事务的写入操作 ( 这意味着队列中同时只能执行一个事务的写入操作 ) 。

根据这个解释，小王在插入数据时，会出现等待状态，直到小张执行 COMMIT 结束它所处的事务，或者出现等待超时。 所以性能较差

常用数据结构和算法

2020-06-25T14:06:27.000Z

排序算法

冒泡排序

需要 array.length-1 轮的比较，可以通过优化标识来减少比较的次数，时间复杂度O(n^2)

public void bubbleSort(int[] array){
  int temp = 0;
  boolean flag = false;//优化标识
  for(int j = 0; j1; j++){
    for(int i = 0; i1); i++){
      if(array[i] > array[i+1]){
        flag = true;
        temp = array[i];
        array[i] = array[i+1];
        array[i+1] = temp;
      }
    }
    if(flag){//发生过交换
      flag = false;
    }else{
      break;
    }
  }
}

快速排序

思路：

1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

public void quickSort(int[] array, int i, int j){
  if(i > j) {
    return;
  }else{
    int index = getPosition(array, i, j);
    quickSort(array, i, index-1);
    quickSort(array, index+1, j);
  } 
}

//1.找到基准对应的索引
//2.对数据分成两部分，大于基准在右侧；小于基准在左侧
public int getPosition(int[] array, int i, int j){
  int temp = array[j];
  while(i < j){
    while(array[i] <= temp && i < j){
      i++;
    }
    array[j] = array[i];
    
    while(array[j] > temp && i < j){
      j--;
    }
    array[i] = array[j];
  }
  // 跳出循环时low和high相等,此时的low或high就是tmp的正确索引位置
  array[i] = temp;
  return i;
}

查找算法

二分查找

必须是有序数组

public int binarySearch(int[] array, int target){
  int i = 0;
  int j = array.length-1;
  int mid = 0;
  while(i <= j){
    mid = i + (j-i)/2;
    if(array[mid] == target){
      return mid;
    }else if(array[mid] < target){
      i = mid + 1;
    }else{
      j = mid - 1;
    }
  }
  return -1;
}

变种：二分查找找最左

可以用来查找相同元素的个数

public int binarySearchForLeft(int[] array, int target){
  int i = 0;
  int j = array.length-1;
  int mid= 0;
  
  while(i < j){
    mid = i + (j-i)/2;
    if(array[mid] >= target){
      j = mid;
    }else{
      i = mid + 1;
    }
  }
  return i;
}

注意：为了验证有没有查找到，需要在调用端判断一下返回位置上的值和 key 是否相等

剑指offer-较难篇

2020-06-25T04:56:22.000Z

滑动窗口的最大值

题目描述：给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}；针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

思路：

public ArrayList maxInWindows(int [] num, int size){
  if (num == null || num.length == 0 || size <= 0 || num.length < size) {
    return new ArrayList();
  }
  
  ArrayList res = new ArrayList<>();
  LinkedList queue = new LinkedList<>();
  
  for(int i = 0;i < num.length; i++){
    while(!queue.isEmpty() && num[queue.peekLast()] < num[i]){
      queue.pollLast();
    }
    
    queue.addLast(i);
    
    //判断头索引是否超出size
    if(queue.peekFirst() <= i - size){
      queue.pollFirst();
    }
    
    //将最大值加入结果集
    if(i >= size-1){
      res.add(num[queue.peekFirst()]);
    }
  }
  return res;
}

二叉搜索树的第k个结点

题目描述：给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8）中，按结点数值大小顺序第三小结点的值为4。

思路：中序遍历第K个节点即可

public class Solution {
  private TreeNode res;
  private int index = 0;//计数器
  
  TreeNode KthNode(TreeNode pRoot, int k){
inOrder(pRoot, k);
    return res;
  }

  private void inOrder(TreeNode root, int k){
    if(root == null){
      return;
    }
    inOrder(root.left, k);
    
    index++;
    if(index == k){
      res = root;
    }
    
    inOrder(root.right, k);
  }

}

序列化二叉树

题目描述：请实现两个函数，分别用来序列化和反序列化二叉树

二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#），以！表示一个结点值的结束（value!）。

二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，我们可以把一个只有根节点为1的二叉树序列化为”1,”，然后通过自己的函数来解析回这个二叉树

思路：递归

public class Solution {
  public int index = -1;
  String Serialize(TreeNode root) {

    if(root == null){
      return "#";
    }
    return root.val + "," + Serialize(root.left) + "," + Serialize(root.right);
  }


  TreeNode Deserialize(String str) {
    index++;    
    String[] strr = str.split(",");
    TreeNode node = null;
    if(!strr[index].equals("#")){
      node = new TreeNode(Integer.valueOf(strr[index]));
      node.left = Deserialize(str);
      node.right = Deserialize(str);
    }

    return node;
  }
}

按之字形顺序打印二叉树

题目描述：请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

思路：使用队列

public ArrayList > Print(TreeNode pRoot) {
  if(pRoot == null) return new ArrayList();
  
  ArrayList > res = new ArrayList >();
  Queue queue = new LinkedList<>();
  queue.add(pRoot);
  int count = 1;//记录行数

  while(!queue.isEmpty()){
    int n = queue.size();
    ArrayList list = new ArrayList();
    for(int i = 0; i
      TreeNode node = queue.poll();
      list.add(node.val);
      if(node.left != null) queue.add(node.left);
      if(node.right != null) queue.add(node.right);
    }

    if(count % 2 == 1){//奇数行
      res.add(list);
      count++;
    }else{//偶数行
      Collections.reverse(list);
      res.add(list);
      count++;
    }
  }
  return res;
}

删除链表中重复的结点

题目描述：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

思路：三指针

public ListNode deleteDuplication(ListNode pHead){
  if (pHead==null || pHead.next==null) return pHead;
  ListNode newHead = new ListNode(-1);
  newHead.next = pHead;
  ListNode pre = newHead;
  ListNode last = newHead.next;
  while(last != null){

    if (last.next != null && last.val == last.next.val){
      while(last.next != null && last.val == last.next.val) {
        last = last.next;
      }
      pre.next = last.next;
      last = last.next;
    } else {
      pre = pre.next;
      last = last.next;
    }
  }
  return newHead.next;
}

把字符串转换成整数

题目描述：将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0

输入描述:

输入一个字符串,包括数字字母符号,可以为空
例：
+2147483647
1a33

输出描述:

如果是合法的数值表达则返回该数字，否则返回0
例：
2147483647
0

思路：

public int StrToInt(String str) {
  if(str.length() == 0 || str == null){
    return 0;
  }
  int res = 0;
  for(int i = 0; i
    char c = str.charAt(i);
    if(c == '0' || c == '+' || c == '-'){
      continue;
    }

    if(c < '0' || c > '9'){
      return 0;
    }

    res = res*10 +(c-'0');

  }
  return str.charAt(0) == '-' ? -res : res;
}

翻转单词顺序列

题目描述：将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0

思路：先反转每个单词，再反转整个句子;

public String ReverseSentence(String str) {
  //先反转每个单词，再反转整个句子
  char[] chars = str.toCharArray();
  int n = chars.length;
  int i = 0;
  int j = 0;
  while(j <= n){
    if(j == n || chars[j] == ' '){ // 利用短路特性，否则会报数组越界
      reverse(chars, i, j-1);
      i = j+1;
    }
    j++;
  }
  reverse(chars, 0, n-1);
  return new String(chars);
}

//反转单词
private void reverse(char[] chars, int i, int j){
  while(i < j){
    char temp = chars[i];
    chars[i] = chars[j];
    chars[j] = temp;
    i++;
    j--;
  }  
}

把数组排成最小的数

题目描述：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

思路：可以看成是一个排序问题，在比较两个字符串 S1 和 S2 的大小时，应该比较的是 S1+S2 和 S2+S1 的大小，如果 S1+S2 < S2+S1，那么应该把 S1 排在前面，否则应该把 S2 排在前面。

补充：

Comparator：对任意类型集合对象进行整体排序，排序时将此接口的实现传递给Collections.sort方法或者Arrays.sort方法排序.
实现int compare(T o1, T o2);方法，返回正数，零，负数各代表大于，等于，小于。

compareTo()：的返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等,结束比较，返回他们之间的差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方全比较完，这时就比较字符的长度.

public String PrintMinNumber(int [] numbers) {
  String[] str = new String[numbers.length];
  for(int i = 0; i
    str[i] = numbers[i]+"";
  }
  StringBuilder res = new StringBuilder();

  Arrays.sort(str,new Comparator(){
    @Override
    public int compare(String s1, String s2) {
      String c1 = s1 + s2;
      String c2 = s2 + s1;
      return c1.compareTo(c2);
    }
  });

  for(int i = 0;i
    res.append(str[i]);
  }

  return res.toString();
}

二叉树中和为某一值的路径

题目描述：输入一颗二叉树的根节点和一个整数，按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

思路：深度遍历：

以上面的树模拟先序遍历的过程

10–>5–>4 已近到达叶子结点，不满足要求22，因此该路径访问结束，需要访问下一个路径
因为在访问节点的过程中，我们并不知道该路径是否满足要求，所以我们每访问一个节点就要记录该结点
访问下有一个结点前，要先从结点4退回到结点5，再访问下一个结点7，因为4不在去往7的路径上，所以要在路径中将4删除
10–>5–>7 满足要求，保存该路径
访问下一个结点，从结点7回到结点5再回到结点10
10–>12，满足要求，保存该路径

public class Solution {
  ArrayList> res = new ArrayList>();
  ArrayList list = new ArrayList();
  public ArrayList> FindPath(TreeNode root,int target) {
    if(root == null) {
      return res;
    }
    target = target - root.val;
    list.add(root.val);
    if(target == 0 && root.left == null && root.right == null){
      res.add(new ArrayList(list));
    }
    FindPath(root.left, target);
    FindPath(root.right, target);
    list.remove(list.size()-1);//回退
    return res;
  }
}

最小的K个数

题目描述：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

思路：

public ArrayList GetLeastNumbers_Solution(int [] input, int k) {
  ArrayList res = new ArrayList();
  if(k > input.length) return res;
  Arrays.sort(input);
  for(int i = 0; i
    res.add(input[i]);
  }

  return res;
}

二叉搜索树的后序遍历序列

题目描述：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

思路：

public boolean VerifySquenceOfBST(int [] sequence) {
  if(sequence.length == 0) return false;
  return judge(sequence, 0, sequence.length-1);
}

public boolean judge(int [] sequence, int begin, int end){
  if(begin >= end){
    return true;
  }
  int i = begin;
  //找到以end节点为根节点的左子树
  while(sequence[i] < sequence[end]){
    i++;
  }

  for(int j = i; j < end; j++){
    //右子树如果有小于根节点的，则返回false
    if(sequence[j] < sequence[end]){
      return false;
    }
  }
  return judge(sequence, begin, i-1) && judge(sequence, i, end-1);
}

二维数组中的查找

题目描述：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

思路：从二维数组的右上角开始遍历，比当前值小的就在左边，比当前值大的就在下边

public boolean Find(int target, int [][] array) {
  int row = array.length;//行数
  int col = array[0].length;//列数
  //从右上角开始搜索
  int i = 0;
  int j = col - 1;
  while(i < row && j >= 0){
    if(array[i][j] == target){
      return true;
    }else if(array[i][j] < target){
      i++;
    }else{
      j--;
    }
  }
  return false;
}

替换空格

题目描述：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

思路：

public String replaceSpace(StringBuffer str) {
  String strs = str.toString();
  char[] strChars = strs.toCharArray();
  StringBuilder sb = new StringBuilder();
  for(int i = 0; i
    if(strChars[i] == ' '){
      sb.append("%20");
    }else{
      sb.append(strChars[i]);
    }
  }
  return sb.toString();
}

从尾到头打印链表

题目描述：输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

思路：利用栈，实现逆序打印

public ArrayList printListFromTailToHead(ListNode listNode) {
  ArrayList res = new ArrayList();
  Stack stack = new Stack<>();
  while(listNode != null){
    stack.push(listNode);
    listNode = listNode.next;
  }
  
  while(!stack.isEmpty()){
    ListNode node = stack.pop();
    res.add(node.val);
  }
  
  return res;
}

调整数组顺序使奇数位于偶数前面

题目描述：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

思路：统计原始数组中的奇数个数，利用拷贝数组，将原始数组进行位置调整

public void reOrderArray(int [] array) {
  int count = 0;
  //统计数组中奇数的个数
  for(int num : array){
    if(num % 2 == 1){
      count++;
    }
  }
  
  //创建拷贝数组
  int[] copy = new int[array.length];
  for(int i = 0; i
    copy[i] = array[i];
  }
  
  //调整位置
  int i = 0;//奇数索引
  int j = count;//偶数索引
  for(int num : copy){
    if(num % 2 == 1){
      array[i] = num;
      i++;
    }else{
      array[count] = num;
      count++;
    }
  }
}

链表中倒数第k个结点

题目描述：输入一个链表，输出该链表中倒数第k个结点。

思路：创建两个指针，都指向头节点。第一个比第二个多走 k 个节点，然后两指针同时向后遍历，直到第一个指针遍历到结尾，返回第二个指针。

public ListNode FindKthToTail(ListNode head,int k) {
  ListNode p1 = head;
  ListNode p2 = head;
  for(int i = 0; i
    if(p1 != null){
      p1 = p1.next;
    }else{
      return null;
    }    
  }
  
  while(p1 != null){
    p1 = p1.next;
    p2 = p2.next;
  }
  return p2;
}

树的子结构

题目描述：输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

思路：先编写方法 isSubTree() 判断B树与A树从根开始是有否相同的结构；再从头遍历A二叉树判断是否有和B树相同的结构

public class Solution {
  public boolean HasSubtree(TreeNode root1,TreeNode root2) {
    if(root1 == null || root2 == null) return false;
    if(isSubTree(root1, root2)) return true;
    return HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
  }

  public boolean isSubTree(TreeNode root1, TreeNode root2){
    if(root2 == null) return true;
    if(root1 == null) return false;
    if(root1.val != root2.val) return false;
    return isSubTree(root1.left, root2.left) && isSubTree(root1.right, root2.right);
  }
}

顺时针打印矩阵

题目描述：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路：创建四个指针，根据顺时针顺序进行顺序输出；注意条件：在添加最后一列和最后一行的时候增加判断条件：r1 != r2，c1 != c2

public class Solution {
  public ArrayList printMatrix(int [][] matrix) {
    ArrayList res = new ArrayList();
    
    int r1 = 0;
    int r2 = matrix.length-1;
    int c1 = 0;
    int c2 = matrix[0].length-1;
    
    while(r1 <= r2 && c1 <= c2){
      //添加当前矩阵第一行
      for(int i = c1; i <= c2; i++){
        res.add(matrix[r1][i]);
      }
      
      //添加当前矩阵最后一列
      for(int i = r1+1; i <= r2; i++){
        res.add(matrix[i][c2]);
      }
      
      //添加当前矩阵最后一行
      if (r1 != r2){
        for(int i = c2-1; i >= c1; i--){
          res.add(matrix[r2][i]);
        }
      }
      //添加当前矩阵第一列
      if(c1 != c2){
        for(int i = r2-1; i > r1; i--){
        res.add(matrix[i][c1]);
      }
      }  
      r1++;
      r2--;
      c1++;
      c2--;
    }
    return res;
  }
}

二叉树中和为某一值的路径

思路：递归

public class Solution {
  ArrayList> res = new ArrayList>();
  ArrayList list = new ArrayList();
  public ArrayList> FindPath(TreeNode root,int target) {
    if(root == null) return res;
    target -= root.val;
    list.add(root.val);
    if(target == 0 && root.left == null && root.right == null){
      res.add(new ArrayList(list));
    }
    FindPath(root.left, target);
    FindPath(root.right, target);
    list.remove(list.size()-1);
    return res;
  }
}

复杂链表的复制

题目描述：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

思路：第一步，在每个节点的后面插入复制的节点；第二步，建立 random 链接；第三步，拆分；

public class Solution {
  public RandomListNode Clone(RandomListNode pHead){
if(pHead == null) return null;
    //插入新节点
    RandomListNode cur = pHead;
    while(cur != null){
      RandomListNode clone = new RandomListNode(cur.label);
      clone.next = cur.next;
      cur.next = clone;
      cur = clone.next;
    }
    
    //建立random连接
    cur = pHead;
    while(cur != null){
      RandomListNode clone = cur.next;
      if (cur.random != null){
        clone.random = cur.random.next;
      }
      cur = clone.next;
    }
    
    //拆分
    cur = pHead;
    RandomListNode cloneHead = cur.next;
    while(cur != null){
      RandomListNode next = cur.next;
      cur.next = next.next;
      cur = next;    
    }
    return cloneHead;
  }
  
}

把数组排成最小的数

思路：Comparator的用法：https://blog.csdn.net/yongh701/article/details/44131051?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.compare&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.compare

compareTo方法：https://www.iteye.com/blog/chenfeng0104-409754

public String PrintMinNumber(int [] numbers) {
  String[] strs = new String[numbers.length];
  for(int i = 0; i
    strs[i] = numbers[i] + "";
  }

  //Collections也有类似的用法
  Arrays.sort(strs, new Comparator(){
    public int compare(Object s1, Object s2){
      String c1 = (String)s1+(String)s2;
      String c2 = (String)s2+(String)s1;
      return c1.compareTo(c2);
    }
  });

  StringBuilder res = new StringBuilder();
  for(String s : strs){
    res.append(s);
  }
  return res.toString();
}

丑数

题目描述：把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

思路：

我们没有必要维护三个队列，只需要记录三个指针显示到达哪一步；“|”表示指针,arr表示丑数数组；

（1）1

目前指针指向0,0,0，队列头arr[0] * 2 = 2, arr[0] * 3 = 3, arr[0] * 5 = 5

（2）1 2

2 |4

|3 6

|5 10

目前指针指向1,0,0，队列头arr[1] * 2 = 4, arr[0] * 3 = 3, arr[0] * 5 = 5

（3）1 2 3

2| 4 6

3 |6 9

|5 10 15

目前指针指向1,1,0，队列头arr[1] * 2 = 4, arr[1] * 3 = 6, arr[0] * 5 = 5

………………

public int GetUglyNumber_Solution(int N) {
  if(N < 7) return N;
  int i2 = 0;//质因子为2的指针
  int i3 = 0;//质因子为3的指针
  int i5 = 0;//质因子为5的指针
  int[] dp = new int[N];//丑数数组
  dp[0] = 1;
  for(int i = 1; i
    int next2 = dp[i2] * 2;
    int next3 = dp[i3] * 3;
    int next5 = dp[i5] * 5;
    dp[i] = Math.min( next2,(Math.min(next3,next5)) );
    if(dp[i] == next2) i2++;
    if(dp[i] == next3) i3++;
    if(dp[i] == next5) i5++;
  }
  return dp[N-1];
}

第一个只出现一次的字符

题目描述：在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）

思路：使用数组统计字符出现的次数

public int FirstNotRepeatingChar(String str) {
  int[] count = new int[256];//用来统计字符出现过的次数
  
  //统计字符出现过的次数
  for(int i = 0; i < str.length(); i++){
    char c = str.charAt(i);
    count[c]++;
  }
  
  //找到第一个只出现一次的字符
  for(int i = 0; i < str.length(); i++){
    char c = str.charAt(i);
    if(count[c] == 1){
      return i;
    }
  }
  return -1;
}

机器人的运动范围

题目描述：地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

思路：递归回溯：

public class Solution {
  private int rows;
  private int cols;
  private int threshold;
  public int movingCount(int threshold, int rows, int cols){
    this.rows = rows;
    this.cols = cols;
    this.threshold = threshold;
    boolean isVisited[][] = new boolean[rows][cols];
    int count = dfs(0, 0, isVisited);
    return count;
  }

  private int dfs(int i, int j, boolean[][] isVisited){
    if(i < 0 || i >= rows || j < 0 || j >= cols ||
       (numSum(i) + numSum(j)) > threshold || isVisited[i][j]){
      return 0;
    }
    isVisited[i][j] = true;
    return dfs(i+0, j+1, isVisited)+
      dfs(i+1, j+0, isVisited)+
      dfs(i-1, j+0, isVisited)+
      dfs(i+0, j-1, isVisited)+1;
  }

  private int numSum(int threshold){
    int sum = 0;
    while((threshold / 10) > 0){
      sum += threshold%10;
      threshold = threshold/10;
    }
    sum = sum+threshold;
    return sum;
  }
}

java-基础

2020-06-16T14:54:27.000Z

Java面向对象

面向对象：是一种程序设计的思想，其基本思想是使用对象、类、封装、继承、多态等基本概念来进行程序设计。
三大特性：

封装：封装性就是尽可能的隐藏对象内部细节，只保留一些对外的接口使其与外部发生联系。用户无需关心对象内部的细节，但可以通过对象对外提供的接口来访问该对象。
可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。
优点：1.实现了高内聚，低耦合；2.提高系统的可扩展性、可维护性
继承： 子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。
- Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。继承实现了代码的复用。
- Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
- 子类不能继承父类中访问权限为private的成员变量和方法。
- 子类可以重写父类的方法，即命名与父类同名的成员变量。
多态：对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。
Java中多态体现在两个方面：
- 编译时多态：编译时多态主要指方法的重载
- 运行时多态：指的是方法的重写：产生运行时多态有三个条件：(1)继承；(2)方法重写；(3)父类引用指向子类对象；

Java 和 C++ 的区别

Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
Java 通过虚拟机(JVM)从而实现跨平台特性，但是 C++ 依赖于特定的平台。
Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
Java 支持自动垃圾回收，而 C++ 需要手动回收。
Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。

JDK/JRE/JVM

JVM：是java 虚拟机，当我们运行一个程序时，JVM 负责将Java源文件编译成能被Java虚拟机执行的字节码文件。除此之外，JVM 提供了内存管理/ 垃圾回收和安全机制等。
JRE：Java Runtime Environment，Java 运行环境的简称，为 Java 的运行提供了所需的环境。它是一个 JVM 程序，主要包括了 JVM 的标准实现和一些 Java 基本类库。
JDK：Java Development Kit，Java 开发工具包，提供了 Java 的开发及运行环境。JDK 是 Java 开发的核心，集成了 JRE 以及一些其它的工具，比如编译 Java 源码的编译器 javac 等。

Java数据类型以及自动拆箱/装箱

Java语言支持的数据类型包括两种：

基本数据类型：

byte：1字节(8位)
short(2)：2字节(16位)
char(2)：2字节(16位)
int(4)：4字节(32位)
float(4)：4字节(32位)
long(8)：8字节(64位)
double(8)：8字节(64位)
Boolean(1)：true、false，可以使用 1 位(bit) 来存储，但是具体大小没有明确规定。JVM 会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。JVM 支持 boolean 数组，但是是通过读写 byte 数组来实现的。

java采用Unicode编码，不论汉字、字母、数字，每个字符都占用2字节。

自动装箱是Java编译器在基本数据类型和对应的对象包装类型之间做的一个转化。反之就是自动拆箱。自动装箱就是Java编译器在基本数据类型和对应的对象包装类型间的转化，即int转化为Integer,自动拆箱是Integer调用其方法将其转化为int的过程。

1 2	Integer x = 2; // 装箱调用了 Integer.valueOf(2) int y = x; // 拆箱调用了 X.intValue()

Java容器

容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着键值对（两个对象）的映射表。

Collection

注：List是有序可重复元素集合，Set是无序不可重复元素集合；

Set

TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。
LinkedHashSet：具有 HashSet 的查找效率，并且内部使用双向链表维护元素的插入顺序。

List

ArrayList：基于动态数组实现，支持随机访问。
Vector：和 ArrayList 类似，但它是线程安全的。
LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。

Queue

LinkedList：可以用它来实现双向队列。
PriorityQueue：基于堆结构实现，可以用它来实现优先队列。

Map

TreeMap：基于红黑树实现。
HashMap：基于哈希表实现。
HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程同时写入 HashTable 不会导致数据不一致。它是遗留类，不应该去使用它，而是使用 ConcurrentHashMap 来支持线程安全，ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。

迭代器模式

Collection 继承了 Iterable 接口，其中的 iterator() 方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历 Collection 中的元素。

Java中的Iterator功能比较简单，并且只能单向移动：

(1) 使用方法iterator()要求容器返回一个Iterator。注意：iterator()方法是java.lang.Iterable接口的方法，被Collection继承。

(2) 使用hasNext()检查序列中是否还有元素。

(3) 使用next()获得序列中的下一个元素。

(4) 使用remove()将迭代器新返回的元素删除。

Iterator只能正向遍历集合，适用于获取移除元素。ListIterator继承自Iterator，专门针对List，可以从两个方向来遍历List，同时支持元素的修改(插入和删除)。从 JDK 1.5 之后可以使用 for each方法来遍历实现了 Iterable 接口的聚合对象。

源码分析

ArrayList

ArrayList 是基于数组实现的，所以支持快速随机访问。

数组的默认大小为 10。

1	private static final int DEFAULT_CAPACITY = 10;

扩容： oldCapacity + (oldCapacity >> 1)，为旧容量的 1.5 倍，扩容操作需要调用 Arrays.copyOf() 把原数组整个复制到新数组中，操作代价很高。
删除元素：需要调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上，该操作的时间复杂度为 O(N)，可以看到 ArrayList 删除元素的代价是非常高的。

Vector

同步：它的实现与 ArrayList 类似，但是使用了 synchronized 进行同步。
与ArrayList比较：
（1）Vector 是同步的，因此开销就比 ArrayList 要大，访问速度更慢。最好使用 ArrayList 而不是 Vector，因为同步操作完全可以由程序员自己来控制；
（2）Vector 每次扩容请求其大小的 2 倍（也可以通过构造函数设置增长的容量），而 ArrayList 是 1.5 倍。
替代方案：可以使用 Collections.synchronizedList(); 得到一个线程安全的 ArrayList。
1
2
List list = new ArrayList<>();
List synList = Collections.synchronizedList(list);
也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。
1
List list = new CopyOnWriteArrayList<>();

CopyOnWriteArrayList

读写分离：写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。
写操作需要加锁，防止并发写入时导致写入数据丢失。
写操作结束之后需要把原始数组指向新的复制数组。
优缺点：
优点：CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能。
缺点：
- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
适用场景：适合读多写少的应用场景，不适合内存敏感以及对实时性要求很高的场景。

LinkedList

ArrayList 基于动态数组实现，LinkedList 基于双向链表实现。ArrayList 和 LinkedList 的区别可以归结为数组和链表的区别：
数组支持随机访问，但插入删除的代价很高，需要移动大量元素；
链表不支持随机访问，但插入删除只需要改变指针。

HashMap

内部包含了一个 Entry 类型的数组 table。Entry 存储着键值对。它包含了四个字段，从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值和散列桶取模运算结果相同的 Entry。

拉链法
1
2
3
4
HashMap map = new HashMap<>();
map.put("K1", "V1");
map.put("K2", "V2");
map.put("K3", "V3");
（1）新建一个 HashMap，默认大小为 16
（2）插入键值对，先计算 K1 的 hashCode 为 113，使用除留余数法得到所在的桶下标 113%16=1。
（3）插入键值对，先计算 K2 的 hashCode 为 120，使用除留余数法得到所在的桶下标 120%16=8。
（4）插入键值对，先计算 K3 的 hashCode 为 120，使用除留余数法得到所在的桶下标 120%16=8，插在前面。（注意：头插法）
扩容
当需要扩容时，令 capacity 为原来的两倍。扩容使用 resize() 实现，需要注意的是，扩容操作同样需要把 oldTable 的所有键值对重新插入 newTable 中，因此这一步是很费时的。
链表转红黑树
从 JDK 1.8 开始，一个桶存储的链表长度大于等于 8 时会将链表转换为红黑树。
与HashTable比较
（1）Hashtable 使用 synchronized 来进行同步。
（2）HashMap 可以插入键为 null 的 Entry。(HashMap 使用第 0 个桶存放键为 null 的键值对)
（3）HashMap 的迭代器是 fail-fast 迭代器。
（4）HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。

ConcurrentHashMap

ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。
size操作：ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。
JDK1.8后改动：
- JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与 Segment 数量相等。
- JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁 synchronized。

Java泛型

Java1.4或更早版本的开发背景的人都知道，在集合中存储对象并在使用前进行类型转换是多么的不方便。泛型防止了那种情况的发生。它提供了编译期的类型安全，确保你只能把正确类型的对象放入集合中，避免了在运行时出现ClassCastException。

Java并发

为什么要使用多线程

多线程并不一定能提升性能（甚至还会降低性能）；多线程也不只是为了提升性能。多线程主要有以下的应用场景：

避免阻塞（异步调用）
单个线程中的程序，是顺序执行的。如果前面的操作发生了阻塞，那么就会影响到后面的操作。这时候可以采用多线程，我感觉就等于是异步调用。这样的例子有很多：eg.ajax调用，就是浏览器会启一个新的线程，不阻塞当前页面的正常操作。
避免CPU空转
以web请求为例，处理完一条请求，再处理下一条请求的话，CPU会存在大量的闲置时间。因为处理一条请求，经常涉及到RPC、数据库访问、磁盘IO等操作，这些操作的速度比CPU慢很多，而在等待这些响应的时候，CPU却不能去处理新的请求，因此都采用对每个请求创建新线程来响应的方式实现，这样在等待IO操作的等待时间里，就可以去继续处理其他请求，对并发的响应性就好了很多。
提升性能
在满足条件的前提下，多线程确实能提升性能。多核CPU才行

进程和线程

进程是执行着的应用程序，而线程是进程内部的一个执行序列。一个进程可以有多个线程。

地址空间和其它资源：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
进程是资源分配的最小单位，它使用独立的数据空间；线程是程序执行的最小单位，它共享进程的数据结构。

使用线程的三种方法

实现Runnable接口

1.创建：实现Runnable接口 + 重写run()

2.启动：创建实现类对象 + Thread对象 + start

public class StartRun implements Runnable {
  /**
 * 线程入口点
 */
  @Override
  public void run() {
    for(int i=0;i<10;i++) {
      System.out.println("一边听歌");
    }
  }

  public static void main(String[] args) {
    new Thread(new StartRun()).start();
    
    for(int i=0;i<10;i++) {
      System.out.println("一边敲代码");
    }
  }
}

继承Thread类

1.创建：继承Thread + 重写run()

2.启动：创建子类对象 + start

public class StartThread extends Thread {
/**
 * 线程入口点
 */
@Override
public void run() {
for(int i=0;i<10;i++) {
System.out.println("一边听歌");
}
}
  
public static void main(String[] args) {
//启动线程
//1.创建子类对象
StartThread st = new StartThread();
//2.调用start
st.start();   //交给cpu，形成两条路径，但start方法不保证立即运行，由cpu去调用

for(int i=0;i<10;i++) {
System.out.println("一边敲代码");
}
}
}

实现Callable接口

与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装，并且抛出异常。

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }

  public static void main(String[] args) throws ExecutionException, InterruptedException {
      MyCallable mc = new MyCallable();
      FutureTask ft = new FutureTask<>(mc);
      Thread thread = new Thread(ft);
      thread.start();
      System.out.println(ft.get());
  }
}

推荐实现接口：避免单继承的局限性，优先使用接口，方便共享资源。

基础线程机制

线程池：
装有线程的池子，我们可以把要执行的多线程交给线程池来处理，和连接池的概念一样。使用实现了Executor接口的ThreadPoolExecutor来创建线程池。通过维护一定数量的线程池来达到多个线程的复用。（为了减少在创建和销毁线程上所花的时间以及系统资源的开销）。
主要有三种 Executor：
- CachedThreadPool：一个任务创建一个线程；
- FixedThreadPool：所有任务只能使用固定大小的线程；
- SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。
守护线程(Daemon)：
当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
main() 属于非守护线程。
在线程启动之前使用 setDaemon() 方法可以将一个线程设置为守护线程。
sleep():
Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。使线程停止运行一段时间，将处于阻塞状态。
如果调用了sleep方法之后，没有其他等待执行的线程，这个时候当前线程不会马上恢复执行！
sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
1
2
3
4
5
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
yield():
yield:礼让线程，暂停线程直接进入就绪状态，不是阻塞状态。
如果调用了yield方法之后，没有其他等待执行的线程，这个时候当前线程就会马上恢复执行！

synchronized和ReentrantLock

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。

synchronized：

同步一个代码块：同一个对象
同步一个方法：同一个对象
同步一个类：两个线程调用该类的不同对象上的这种同步语句，也会进行同步
同步一个静态方法：作用于整个类

ReentrantLock：

ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁

比较：

锁的实现：synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
性能：新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
等待可中断：当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。ReentrantLock 可中断，而 synchronized 不行。
公平锁：公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
锁绑定多个条件：一个 ReentrantLock 可以同时绑定多个 Condition 对象
除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。

线程中的相互协作

join()：

在线程中调用另一个线程的 join() 方法，会将当前线程挂起，直到目标线程结束。

虽然 b 线程先启动，但是如果在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。

wait()：

调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。

注意：

使用 wait() 挂起期间，线程会释放锁，而sleep() 不会；
wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；

线程状态

Java I/O

磁盘操作

File 类可以用于表示文件和目录的信息，但是它不表示文件的内容。

递归地列出一个目录下的所有文件

public void show(File dir){
  if(dir == null && !dir.exists){
    return;
  }
  if(dir.isFile()){
    System.out.println(dir.getName());
    return;
  }
  for(File f : dir.listFiles()){
    show(f);
  }
}

字节操作

InputStream
Java I/O 使用了装饰者模式来实现。以 InputStream 为例，
- InputStream 是抽象组件；
- FileInputStream 是 InputStream 的子类，属于具体组件，提供了字节流的输入操作；
- FilterInputStream 属于抽象装饰者，装饰者用于装饰组件，为组件提供额外的功能。例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
  
  实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可

字符操作

编码与解码：编码就是把字符转换为字节，而解码是把字节重新组合成字符。
- GBK 编码中，中文字符占 2 个字节，英文字符占 1 个字节；
- UTF-8 编码中，中文字符占 3 个字节，英文字符占 1 个字节；
- UTF-16be 编码中，中文字符和英文字符都占 2 个字节；(Java：Java 使用这种双字节编码是为了让一个中文或者一个英文都能使用一个 char 来存储。)
Reader和Writer
- InputStreamReader 实现从字节流解码成字符流；(转换流)
OutputStreamWriter 实现字符流编码成为字节流。(转换流)
- 从JDK文档中可以知道FileOutputStream是OutputStream的直接子类，FileInputStream也是InputStream的直接子类，但是在字符流文件的两个操作类却有一些特殊，FileWriter并不直接是Writer的子类，而是OutputStreamWriter的子类，而FileReader也不直接是Reader的子类，而是InputStreamReader的子类，那么从这两个类的继承关系就可以清楚的发现，不管是是使用字节流还是字符流实际上最终都是以字节形式操作输出流的。

### 对象操作

序列化：

序列化就是将一个对象转换成字节序列，方便存储和传输。
- 序列化：ObjectOutputStream.writeObject()
- 反序列化：ObjectInputStream.readObject()

不会对静态变量进行序列化，因为序列化只是保存对象的状态，静态变量属于类的状态。

Serializable：

序列化的类需要实现 Serializable 接口，它只是一个标准，没有任何方法需要实现，但是如果不去实现它的话而进行序列化，会抛出异常。

transient：

java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

ArrayList 中存储数据的数组 elementData 是用 transient 修饰的

1	private transient Object[] elementData;

通过一些重写的方法，只序列化数组中有内容的那部分数据

网络操作

Java 中的网络支持：

InetAddress：用于表示网络上的硬件资源，即 IP 地址；
URL：统一资源定位符；
Sockets：使用 TCP 协议实现网络通信；
Datagram：使用 UDP 协议实现网络通信。

从URL读取字节数据：

public static void main(String[] args) throws IOException {
  URL url = new URL("http://www.baidu.com");

  /* 字节流 */
  InputStream is = url.openStream();

  /* 字符流 */
  InputStreamReader isr = new InputStreamReader(is, "utf-8");

  /* 提供缓存功能 */
  BufferedReader br = new BufferedReader(isr);

  String line;
  while ((line = br.readLine()) != null) {
    System.out.println(line);
  }

  br.close();
}

Sockets：

ServerSocket：服务器端类
Socket：客户端类
服务器和客户端通过 InputStream 和 OutputStream 进行输入输出。

NIO

NIO即New IO，这个库是在JDK1.4 中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。

流与块：

I/O 与 NIO 最重要的区别是数据打包和传输的方式，I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。
- 面向流的 I/O 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
- 面向块的 I/O 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。

通道和缓冲区：

通道 Channel：是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。
通道与流的不同之处在于，流只能在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)，而通道是双向的，可以用于读、写或者同时用于读写。
缓冲区：发送给一个通道的所有数据都必须首先放到缓冲区中，同样地，从通道中读取的任何数据都要先读到缓冲区中。也就是说，不会直接对通道进行读写数据，而是要先经过缓冲区。
- 缓冲区实质上是一个数组，但它不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。
- 缓冲区状态变量：
  1.capacity：最大容量；
  2.position：当前已经读写的字节数；
  3.limit：还可以读写的字节数。

选择器与非阻塞I/O：

NIO 常常被叫做非阻塞 IO，主要是因为 NIO 在网络通信中的非阻塞特性被广泛使用。
NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。
通过配置监听的通道 Channel 为非阻塞，那么当 Channel 上的 IO 事件还未到达时，就不会进入阻塞状态一直等待，而是继续轮询其它 Channel，找到 IO 事件已经到达的 Channel 执行。
因为创建和切换线程的开销很大，因此使用一个线程来处理多个事件而不是一个线程处理一个事件，对于 IO 密集型的应用具有很好地性能。

NIO 与 IO 主要区别：

NIO 面向块，IO 面向流
NIO 非阻塞，IO 阻塞

Java虚拟机

参考资料

Cyc2018 ：https://cyc2018.github.io/CS-Notes/#/README

剑指offer-中等篇

2020-06-10T13:03:53.000Z

剪绳子

题目描述：给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],…,k[m]。请问k[0] x k[1] x … x k[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

思路：

5<2x3，6<3x3，比6更大的数字我们就更不用考虑了，肯定要继续分。
其次看2和3的数量，2的数量肯定小于3个，为什么呢？因为2x2x2 < 3x3，那么题目就简单了。
直接用n除以3，根据得到的余数判断是一个2还是两个2还是没有2就行了。

public int cutRope(int target) {
  if(target == 2) return 1;
  if(target == 3) return 2;

  int x = target % 3;
  int y = target / 3;

  if(x == 0){
    return (int)Math.pow(3,y);
  }else if(x == 1){//7%3=2···1   2*2*3
    return 2*2*(int)Math.pow(3,y-1);
  }else{//8%3=2···2    3*3*2
    return 2*(int)Math.pow(3,y);
  }
}

把二叉树打印成多行

题目描述：从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

思路：用队列实现二叉树的层次遍历(标准写法)

ArrayList > Print(TreeNode pRoot) {
  if(pRoot == null) return new ArrayList();
  ArrayList > res = new ArrayList >();
  Queue queue = new LinkedList<>();
  queue.add(pRoot);
  while(!queue.isEmpty()){
    ArrayList list = new ArrayList();
    int count = queue.size();
    for(int i = 0; i
      TreeNode node = queue.poll();
      list.add(node.val);
      if(node.left != null) queue.add(node.left);
      if(node.right != null) queue.add(node.right);
    }
    res.add(list);
  }  
  return res;
}

二叉树的下一个结点

题目描述：给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

思路：判断当前节点的右子节点是否为空

public TreeLinkNode GetNext(TreeLinkNode pNode){
  if(pNode.right != null){//当前节点右子节点不为空
    TreeLinkNode node = pNode.right;
    while(node.left != null){//找到右子节点的最底层左子节点
      node = node.left;
    }
    return node;
  }else{//当前节点右子节点为空
    while(pNode.next != null){
      TreeLinkNode parent = pNode.next;//指向当前节点的父节点
      if(parent.left == pNode){//判断当前节点是否为父节点的左子节点
        return parent;
      }
      pNode = pNode.next;
    } 
  }
  return null;
}

链表中环的入口结点

题目描述：给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

思路：

public ListNode EntryNodeOfLoop(ListNode pHead){
  if(pHead == null || pHead.next == null) return null;
  ListNode fast = pHead;
  ListNode slow = pHead;
  do{
    fast = fast.next.next;
    slow = slow.next;
  }while(slow != fast);

  fast = pHead;
  while(fast != slow){
    fast = fast.next;
    slow = slow.next;
  }
  return fast;
}

字符流中第一个不重复的字符

题目描述：请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符”go”时，第一个只出现一次的字符是”g”。当从该字符流中读出前六个字符“google”时，第一个只出现一次的字符是”l”。

如果当前字符流没有存在出现一次的字符，返回 # 字符。

思路：用数组统计字符出现的次数，并将字符按顺序加入队列，如果队列中字符出现的次数大于1，则出队；如果最后队列不为空，则出队的字符就是第一个出现的字符。

public class Solution {
  //Insert one char from stringstream
  int[] counts = new int[256];
  private Queue queue = new LinkedList<>();

  public void Insert(char ch){
    counts[ch]++;
    queue.add(ch);
    while(!queue.isEmpty() && counts[queue.peek()] > 1){
      queue.poll();
    }
  }

  //return the first appearence once char in current stringstream
  public char FirstAppearingOnce(){
    return queue.isEmpty() ? '#' : queue.peek();
  }
}

表示数值的字符串

题目描述：请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串”+100”,”5e2”,”-123”,”3.1416”和”-1E-16”都表示数值。但是”12e”,”1a3.14”,”1.2.3”,”+-5”和”12e+4.3”都不是。

思路：用法JDK方法：Double.parseDouble()

public boolean isNumeric(char[] str) {
  //String string = String.valueOf(str);
  //return string.matches("[\\+-]?[0-9]*(\\.[0-9]*)?([eE][\\+-]?[0-9]+)?");
  try{
    double res = Double.parseDouble(new String(str));  
  }
  catch(NumberFormatException e){
    return false;
  }
  return true;
}

数组中重复的数字

题目描述：在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

思路：

public boolean duplicate(int numbers[],int length,int [] duplication){
  if(numbers == null || numbers.length == 1) return false;
 for(int i = 0;i
    while(numbers[i] != i){
      if(numbers[i] == numbers[numbers[i]]){
        duplication[0] = numbers[i];
        return true;
      }
      swap(numbers, i, numbers[i]);
    }
  }
  return false;
}

public static void swap(int numbers[],int i,int j){
  int temp = numbers[i];
  numbers[i] = numbers[j];
  numbers[j] = temp;
}

求1+2+3+…+n

题目描述：求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

思路：利用逻辑与得短路特性做为递归的终止条件。

public int Sum_Solution(int n) {
  int sum = n;
  boolean flag = n > 0 && (sum += Sum_Solution(n-1)) > 0;
  return sum;
}

孩子们的游戏(圆圈中最后剩下的数)

题目描述：让小朋友们围成一个大圈。然后，随机指定一个数 m，让编号为 0 的小朋友开始报数。每次喊到 m-1 的那个小朋友要出列唱首歌，然后可以在礼品箱中任意的挑选礼物，并且不再回到圈中，从他的下一个小朋友开始，继续 0…m-1 报数 …. 这样下去 …. 直到剩下最后一个小朋友，可以不用表演。

思路：约瑟夫环，用链表来模拟游戏过程；

public int LastRemaining_Solution(int n, int m) {
  if(n == 0) return -1;
LinkedList list = new LinkedList<>();
  for(int i = 0; i
    list.add(i);
  }
  
  int beginIndex = 0;
  while(list.size() > 1){
    beginIndex = (beginIndex + m-1)%list.size();//循环
    list.remove(beginIndex);
  }
  return list.get(0);
}

扑克牌顺子

题目描述：LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…..LL不高兴了,他想了想,决定大\小王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何，如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

思路：先统计大小王的个数，当成赖子，通过对抽到的牌进行排序，判断是否能组成顺子。

public boolean isContinuous(int [] numbers) {
  if(numbers.length == 0) return false;
  int count = 0;
  Arrays.sort(numbers);
  //统计大小王个数
while(numbers[count] == 0){
    count++;
  }

  //判断是否能组成顺子
for(int i = count; i1; i++){
    //如果重复的牌，则一定不能组成顺子
    if(numbers[i+1] == numbers[i]){
      return false;
    }
    count = count - (numbers[i+1]-numbers[i]-1); 
  }
  
  return count >= 0;
}

左旋转字符串

题目描述：汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

思路：1.先分别反转字符串；2.再整体反转；

public String LeftRotateString(String str,int n) {
if(str == null || str.length() <= n) return str;
  char[] chars = str.toCharArray();
  swapString(chars, 0, n-1);
  swapString(chars, n, chars.length-1);
  swapString(chars, 0, chars.length-1);
  return new String(chars);
}

//反转从 i 到 j 的字符串
public void swapString(char[] str,int i,int j){
while(i < j){
    char temp = str[i];
    str[i] = str[j];
    str[j] = temp;
    i++;
    j--;
  }
}

和为S的两个数字

题目描述：输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。对应每个测试案例，输出两个数，小的先输出。

思路：利用双指针，从头和尾分别进行遍历判断（和相同时，两数差距越大，乘积越小）

public ArrayList FindNumbersWithSum(int [] array,int sum) {
  ArrayList res = new ArrayList();
int i = 0;
  int j = array.length-1;
  while(i < j){
    if(array[i] + array[j] == sum){
      res.add(array[i]);
      res.add(array[j]);
      return res;
    }else if(array[i] + array[j] < sum){
      i++;
    }else{
      j--;
    }
  }
  return res;
}

和为S的连续正数序列

题目描述：小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

思路：

public ArrayList > FindContinuousSequence(int sum) {
  ArrayList > res = new ArrayList >();
int L = 1;
  int R = 2;
  int curSum = 0;
  while(L < R){
    curSum = (L + R)*(R - L + 1)/2;
    if(curSum == sum){
      ArrayList list = new ArrayList();
      for(int i = L; i<=R; i++){
        list.add(i);
      }
      res.add(list);
      L++;
    }else if(curSum < sum){
      R++;
    }else{
      L++;
    }
  }
  return res;
}

数组中只出现一次的数字

题目描述：一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

思路：把所有的数异或，得到的结果即两个不同的数异或的结果，这个结果的二进制中的1，表现的是这两个不同的数的不同位。就按照这个结果中为1的位的位置划分，该位为1划分为一组，为0划分为一组。这样两个不同的数就被划分开了，再分别对这两组做异或操作，就找到了两个不同的数。

public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
int binaryRes = 0;
  for(int i = 0; i
    binaryRes = binaryRes ^ array[i];
  }
  
  int index = getIndex1(binaryRes);
  for(int num : array){
    if(is1Index(num, index)){
      num1[0] = num1[0] ^ num;
    }else{
      num2[0] = num2[0] ^ num;
    }
  }
}

/**
* 返回 binaryRes 中第一位为1的位置
*/
private int getIndex1(int binaryRes){
  int index = 0;
  while(((binaryRes & 1) == 0) && index < 32){
    binaryRes = binaryRes>> 1;
    index++;
  }
  return index;
}

/**
* 判断 num 的 index 位置是否为1
*/
private boolean is1Index(int num, int index){
  //index 位为1，则返回true
  return ((num >> index) & 1) == 1;
}

平衡二叉树

题目描述：输入一棵二叉树，判断该二叉树是否是平衡二叉树。

在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

思路:递归得到二叉树的高度，判断左子树与右子树的高度差，如果高度差超过1，则返回false

public class Solution {
  private boolean isBalanced = true;
  public boolean IsBalanced_Solution(TreeNode root) {
    depth(root);
    return isBalanced;
  }

  private int depth(TreeNode root){
    if(root == null) return 0;
    int leftDepth = depth(root.left);
    int rightDepth = depth(root.right);
    if(Math.abs(leftDepth - rightDepth) > 1){
      isBalanced = false;
    }
return Math.max(leftDepth,rightDepth)+1;
  }
}

数字在排序数组中出现的次数

题目描述：统计一个数字在排序数组中出现的次数。

思路：有序数组，可以利用二分法

public int GetNumberOfK(int [] array , int k) {
  //int res = 0;
  //for(int num : array){
  //  if(num == k) res++;
  // }
  // return res;
  if(array.length == 0) return 0;
  int left = binarySearch(array, k);
  int right = binarySearch(array,  k+1);
  if(array[array.length-1] == k){
    return right-left+1;
  }else{
    return right-left;
  }
}

//返回数组中target中最左边的位置索引
public int binarySearch(int[] nums, int target) {
  int i = 0;
  int j = nums.length - 1;
  int mid = 0;
  while(i < j){
    mid = i + (j-i)/2;
    if(nums[mid] < target){
      i = mid + 1;
    }else{
      j = mid;
    }
  }
  return i;
}

两个链表的第一个公共结点

题目描述：输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

思路：路程相等思想：当访问链表 A 的指针访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问链表 B 的指针访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。

public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
  ListNode a = pHead1;
  ListNode b = pHead2;
  
  while(a != b){
    a = a == null ? pHead2 : a.next;
    b = b == null ? pHead1 : b.next;
  }
  
  return a;
}

整数中1出现的次数（从1到n整数中1出现的次数）

题目描述：求出1~~13的整数中1出现的次数,并算出100~~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

思路：

个位

我们知道在个位数上，1会每隔10出现一次，例如1、11、21等等，我们发现以10为一个阶梯的话，每一个完整的阶梯里面都有一个1，例如数字22，按照10为间隔来分三个阶梯，在完整阶梯0-9，10-19之中都有一个1，但是19之后有一个不完整的阶梯，我们需要去判断这个阶梯中会不会出现1，易推断知，如果最后这个露出来的部分小于1，则不可能出现1（这个归纳换做其它数字也成立）。

我们可以归纳个位上1出现的个数为：

n/10 * 1+(n%10!=0 ? 1 : 0)

十位

现在说十位数，十位数上出现1的情况应该是10-19，依然沿用分析个位数时候的阶梯理论，我们知道10-19这组数，每隔100出现一次，这次我们的阶梯是100，例如数字317，分析有阶梯0-99，100-199，200-299三段完整阶梯，每一段阶梯里面都会出现10次1（从10-19），最后分析露出来的那段不完整的阶梯。我们考虑如果露出来的数大于19，那么直接算10个1就行了，因为10-19肯定会出现；如果小于10，那么肯定不会出现十位数的1；如果在10-19之间的，我们计算结果应该是k - 10 + 1。例如我们分析300-317，17个数字，1出现的个数应该是17-10+1=8个。

那么现在可以归纳：十位上1出现的个数为：

设k = n % 100，即为不完整阶梯段的数字
归纳式为：(n / 100) * 10 + (if(k > 19) 10 else if(k < 10) 0 else k - 10 + 1)

百位

现在说百位1，我们知道在百位，100-199都会出现百位1，一共出现100次，阶梯间隔为1000，100-199这组数，每隔1000就会出现一次。这次假设我们的数为2139。跟上述思想一致，先算阶梯数 * 完整阶梯中1在百位出现的个数，即n/1000 * 100得到前两个阶梯中1的个数，那么再算漏出来的部分139，沿用上述思想，不完整阶梯数k199，得到100个百位1，100<=k<=199则得到k - 100 + 1个百位1。

那么继续归纳百位上出现1的个数：

设k = n % 1000
归纳式为：(n / 1000) * 100 + (if(k >199) 100 else if(k < 100) 0 else k - 100 + 1)

后面的依次类推….

完美！归纳式看起来已经很规整了。来一个更抽象的归纳，设i为计算1所在的位数，i=1表示计算个位数的1的个数，10表示计算十位数的1的个数等等。

k = n % (i * 10)
count(i) = (n / (i * 10)) * i + (if(k > i * 2 - 1) i else if(k < i) 0 else k - i + 1)

好了，这样从10到10的n次方的归纳就完成了。

public int NumberOf1Between1AndN_Solution(int n) {
  if(n <= 0) return 0;
  int count = 0;
  for(int i = 1; i <= n; i *= 10){
    int div = i * 10;
    int k = n % div;
    if(k > 2*i-1){
      count = count + n/div*i + i;
    }else if(k < i){
      count = count + n/div*i + 0;
    }else{
      count = count + n/div*i + (k-i+1);
    }
  }
  return count;
}

连续子数组的最大和

题目描述：HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

思路：

public int FindGreatestSumOfSubArray(int[] array) {
  int dp = array[0];
  int res = array[0];
  for(int i = 1; i
    dp = Math.max(dp + array[i], array[i]);
    res = Math.max(res, dp); 
  }
  return res;
}

数组中出现次数超过一半的数字

题目描述：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

思路：
法1：对数组进行排序，中间的数一定是出现次数超过数组长度一般的数，否则返回0；
法2：用HashMap统计每个数字出现的次数；

//方法一，时间复杂度nlogn
public int MoreThanHalfNum_Solution(int [] array) {
  Arrays.sort(array);

  int mid = array[array.length/2];

  int count = 0;
  for(int i = 0;i
    if(array[i] == mid){
      count++;
    }
  }

  return count>(array.length/2) ? mid : 0;
}

//方法二，时间复杂度n
public int MoreThanHalfNum_Solution(int [] array) {
  HashMap map = new HashMap();
  for(int i = 0; i
    if(!map.containsKey(array[i])){
      map.put(array[i],1);
    }else{
      int count = map.get(array[i]);
      map.put(array[i],++count);
    }
  }

  for(int key : map.keySet()){
    int count = map.get(key);
    if(count > array.length/2){
      return key;
    }
  }
  return 0;
}

二叉搜索树与双向链表

题目描述：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

思路：中序遍历结果就是排序结果；中序递归；

private TreeNode pre = null;
private TreeNode head = null;
public TreeNode Convert(TreeNode root) {
  inOrder(root);
  return head;
}

private void inOrder(TreeNode node) {
  if (node == null) return;
  inOrder(node.left);

  node.left = pre;
  if (pre != null) pre.right = node;
  pre = node;
  if (head == null) head = node;

  inOrder(node.right);
}

栈的压入、弹出序列

题目描述：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

思路：用栈来模拟题目描述的过程；

public boolean IsPopOrder(int [] pushA,int [] popA) {
  if(pushA.length == 0 || popA.length == 0) return false;
  Stack stack = new Stack<>();
  
  int index = 0;
  for(int i = 0; i < pushA.length; i++ ){
    stack.push(pushA[i]);
    while(!stack.isEmpty() && stack.peek() == popA[index]){
      stack.pop();
      index++;
    }
  }
  return stack.isEmpty();
}

合并两个排序的链表

题目描述：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

思路：

public ListNode Merge(ListNode list1,ListNode list2) {
  ListNode newHead = new ListNode(-1);
  ListNode temp = newHead;
  
  while(list1 != null && list2 != null){
    if(list1.val < list2.val){
      temp.next = list1;
      temp = temp.next;
      list1 = list1.next;
    }else{
      temp.next = list2;
      temp = temp.next;
      list2 = list2.next;
    }
  }
  //如果 后续还有节点，直接接在新链表的末尾即可
  if(list1 != null) temp.next = list1;
  if(list2 != null) temp.next = list2;
  
  return newHead.next;
}

反转链表

题目描述：输入一个链表，反转链表后，输出新链表的表头。

思路：头插法：

public ListNode ReverseList(ListNode head) {
  //头插法
  ListNode newHead = new ListNode(-1);
  
  while(head != null){
    ListNode next = head.next;
    head.next = newHead.next;
    newHead.next = head;
    head = next;
  }
  return newHead.next;
}

数值的整数次方

题目描述：给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

保证base和exponent不同时为0。

思路：
法1：暴力法；
法2：递归法，时间复杂度logN；

public double Power(double base, int exponent) {
  double res = 1;
  if(exponent>0){
    for(double i = 0;i
      res = res*base;
    }
  }else{
    for(double i = exponent;i<0;i++){
      res = res*base;
    }
    res = 1/res;
  }
  return res;
}

1
2
3

public double Power(double base, int exponent) {
  
}

二进制中1的个数

题目描述：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

思路：n&(n-1)：相当于把n二进制最后的1变为0

1
2
3

n       : 10110100
n-1     : 10110011
n&(n-1) : 10110000

public int NumberOf1(int n) {
  int res = 0;
  while(n != 0){
    res++;
    n = n&(n-1);
  }
  return res;
}

矩形覆盖

题目描述：我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

比如n=3时，2*3的矩形块有3种覆盖方法：

思路：斐波那契数列

public int RectCover(int target) {
  int pre = 0;
  int cur = 1;
  int res = 0;
  for(int i = 1; i<=target; i++){
    res = pre + cur;
    pre = cur;
    cur = res;
  }
  return res;
}

跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

思路：斐波那契数列：跳 n 阶台阶，可以先跳 1 阶台阶，再跳 n-1 阶台阶；或者先跳 2 阶台阶，再跳 n-2 阶台阶，故有递推公式f(n) = f(n-1) + f(n-2)

public int JumpFloor(int target) {
  int pre = 0;
  int cur = 1;
  int res = 0;
  for(int i = 1; i<=target; i++){
    res = pre + cur;
    pre = cur;
    cur = res;
  }
  return res;
}

斐波那契数列

题目描述：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。

思路：斐波那契数列：f(n) = f(n-1) + f(n-2)

public int Fibonacci(int n) {
  if(n <= 1) return n;
  int res = 0;
  int pre = 0;
  int cur = 1;
  for(int i = 2;i<=n;i++){
    res = pre + cur;
    pre = cur;
    cur = res;
  }
  return res;
}

旋转数组的最小数字

题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

思路：采用二分法；若中间的元素大于 j 指针的元素，说明旋转点在 mid 和 j 之间；否则在 i 和 mid 之间；

特例：如果数组元素允许重复，会出现一个特殊的情况：nums[l] == nums[m] == nums[h]，此时无法确定解在哪个区间，需要切换到顺序查找。例如对于数组 {1,1,1,0,1}，l、m 和 h 指向的数都为 1，此时无法知道最小数字 0 在哪个区间。

public int minNumberInRotateArray(int [] array) {
  if(array.length == 0) return 0;
  int i = 0;
  int j = array.length - 1;
  while(i < j){
    int mid = i + (j - i)/2;
    if(array[mid] == array[i] && array[mid] == array[j]){
      for(int k = 0; k1; k++){
        if(array[k] > array[k+1] ) {
          return array[k+1];
        }
      }
      return array[0];
    }
    
    if(array[mid] > array[j]){
      i = mid + 1;
    }else{
      j = mid;
    }
  }
  return array[i];
}

重建二叉树

题目描述：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

思路：

剑指offer-简单篇

2020-06-07T09:02:50.000Z

构建乘积数组

题目描述：给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…A[i-1]A[i+1]…A[n-1]。不能使用除法。（注意：规定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）

思路：1.//从左向右累乘A[0]A[1]…A[i-1]；2.//从右向左累乘A[i+1]…A[n-1]

public int[] multiply(int[] A) {
//从左向右累乘A[0]A[1]...A[i-1]
  int n = A.length;
  int[] B = new int[n];
  int temp = 1;
  for(int i = 0;i
    B[i] = temp;
    temp = temp*A[i];
  }
  
//从右向左累乘A[i+1]...A[n-1]
  temp = 1;
  for(int i = n-1;i>=0;i--){
    B[i] = B[i]*temp;
    temp = temp*A[i];
  } 
  return B;
}

不用加减乘除做加法

题目描述：写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

思路：1.不考虑进位：异或操作：^ ；例如：101^111 = 010;
2.计算进位值：与操作：&，再左移一位；例如：101&111<<1 = 101<<1 = 1010；
3.重复上述两步，直到进位值全为0，返回结果；

public int Add(int num1,int num2) {
  while(num2 !=  0) {
int temp = num1 ^ num2;
int carry =  (num1 & num2) << 1;
num1 = temp;
num2 = carry;
}
return num1;
}

二叉树的深度

题目描述：输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

思路：递归：结束条件：根节点位空

public int TreeDepth(TreeNode root) {
if(root == null) return 0;
  int left = TreeDepth(root.left);
  int right = TreeDepth(root.right);
  
  return Math.max(left,right)+1;
}

二叉树的镜像

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

思路：递归：结束条件：根节点位空

public void Mirror(TreeNode root) {
    if(root == null) return;
    if(root.left != null) Mirror(root.left);
  if(root.right != null) Mirror(root.right);
    TreeNode temp = root.left;
    root.left = root.right;
    root.right = temp;      
}

变态跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

思路：推导：

跳上 n-1 级台阶，可以从 n-2 级跳 1 级上去，也可以从 n-3 级跳 2 级上去…，那么:
1
f(n-1) = f(n-2) + f(n-3) + ... + f(0)
同样，跳上 n 级台阶，可以从 n-1 级跳 1 级上去，也可以从 n-2 级跳 2 级上去… ，那么:
1
f(n) = f(n-1) + f(n-2) + ... + f(0)

两式相减得到：

1	f(n) = 2f(n-1) = 22f(n-2) =...= 2^(n-1)f(1) = 2^(n-1)

public int JumpFloorII(int target) {
if(target == 0){
    return -1;
  }else{
    return (int)Math.pow(2,target-1);
  }
}

用两个栈实现队列

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

思路：注意：stack2中有元素时，不能入栈，直接pop出元素即可；
必须stack2为空时，才能入栈；

public class Solution {
  Stack stack1 = new Stack();
  Stack stack2 = new Stack();

  public void push(int node) {
    stack1.push(node);
  }

  public int pop() {
    if(stack2.isEmpty()){
      while(!stack1.isEmpty()){
        int node = stack1.pop();
      stack2.push(node);
      } 
    }
    return stack2.pop();   
  }
  
}

SpringBoot

2020-06-02T07:43:35.000Z

日志

SLF4J + logback

如何让系统中所有的日志都统一到slf4j；

1、将系统中其他日志框架先排除出去；

2、用中间包来替换原有的日志框架；

3、我们导入slf4j其他的实现；

Leetcode 167.两数之和 II - 输入有序数组

2020-05-27T14:52:47.000Z

167：给定一个已按照升序排列的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:

返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        if(numbers.length < 2) return null;
        int[] res = new int[2];
        int i = 0;
        int j = numbers.length-1;
        while(i < j){
            if(numbers[i] + numbers[j] == target){
                res[0] = i+1;
                res[1] = j+1;
                i++;
                j--;
            }else if(numbers[i] + numbers[j] < target){
                i++;
            }else{
                j--;
            }
        }
        return res;
    }
}

设计模式-观察者模式

2020-05-21T07:37:11.000Z

适用于广播场景机制：
• 聊天室程序的创建。服务器创建好后，A,B,C三个客户端连上来公开聊天。A向服务器发送数据，服务器端聊天数据改变。我们希望将这些聊天数据分别发给其他在线的客户。也就是说，每个客户端需要更新服务器端得数据。
• 网站上，很多人订阅了”java主题”的新闻。当有这个主题新闻时，就会将这些新闻发给所有订阅的人。
• 玩CS游戏时，服务器需要将每个人的方位变化发给所有的客户。

我们可以把多个订阅者、客户称之为观察者；需要同步给多个订阅者的数据封装到对象中，称之为目标。

核心：观察者模式主要用于1：N的通知。当一个对象(目标对象Subject，消息发布)的状态变化时，他需要及时告知一系列对象(观察者对象Observer，消息订阅)，令他们做出响，通知观察者的方式主要是推和拉：
• 推：每次都会把通知以广播方式发送给所有观察者，所有观察者只能被动接收。
• 拉：观察者只要直到有情况即可。至于什么时候获取内容，获取什么内容，都可以自主决定。

代码实现：

public interface Observer {
    void update(Subject subject);
}


public class ObserverA implements Observer{
    private int myState;
    @Override
    public void update(Subject subject) {
        myState = ((ConcreteSubject)subject).getState();
    }

    public void setMyState(int myState) {
        this.myState = myState;
    }

    public int getMyState() {
        return myState;
    }
}

public class Subject {
    protected List list = new ArrayList<>();

    public void registerObserver(Observer observer){
        list.add(observer);
    }

    public void deletObserver(Observer observer){
        list.remove(observer);
    }

    //通知 所有观察者更新状态
    public void notifyAllObservers(){
        for (Observer o : list) {
            o.update(this);
        }
    }
}

/**
*具体目标类
*/
public class ConcreteSubject extends Subject{
    private int state;

    public void setState(int state) {
        this.state = state;
        //目标值发生变换，通知所有的观察者
        this.notifyAllObservers();
    }

    public int getState() {
        return state;
    }

}

public class test {
    public static void main(String[] args) {
        ConcreteSubject  concreteSubject = new ConcreteSubject();

        //创建多个观察者
        ObserverA o1 = new ObserverA();
        ObserverA o2 = new ObserverA();
        ObserverA o3 = new ObserverA();

        //添加到subject的观察者队伍中
        concreteSubject.registerObserver(o1);
        concreteSubject.registerObserver(o2);
        concreteSubject.registerObserver(o3);

      //一次更新，所有观察者都改变状态！！！
        concreteSubject.setState(300);
        System.out.println(o1.getMyState());
        System.out.println(o2.getMyState());
        System.out.println(o3.getMyState());
    }
}

• 开发中常见的场景：

聊天室程序的，服务器转发给所有客户端
网络游戏(多人联机对战)场景中，服务器将客户端的状态进行分发
邮件订阅
Servlet中，监听器的实现
Android中，广播机制
JDK的AWT中事件处理模型,基于观察者模式的委派事件模型(Delegation Event Model)
事件源—————-目标对象
事件监听器————观察者
京东商城中，群发某商品打折信息

设计模式-模版方法模式

2020-05-20T14:22:50.000Z

模板方法模式也叫方法回调或钩子方法，是编程中经常用得到模式。它定义了一个操作中的算法骨架，将某些步骤延迟到子类中实现。这样，新的子类可以在不改变一个算法结构的前提下重新定义该算法的某些特定步骤。

核心：处理步骤父类中定义好，具体实现延迟到子类中定义。

public abstract class BankTemplateMethod {
    //具体方法
    public void takeNumber(){
        System.out.println("取号排队");
    }

    public abstract void transact(); //办理具体的业务//钩子方法

    public void evaluate(){
        System.out.println("反馈评分");
    }

    public final void process(){
        this.takeNumber();

        this.transact();

        this.evaluate();
    }
}

public class test {
    public static void main(String[] args) {
        //采用匿名内部类
        BankTemplateMethod btm = new BankTemplateMethod(){
            @Override
            public void transact() {
                System.out.println("取钱：2000！！！");
            }
        };
        btm.process();

        BankTemplateMethod btm2 = new BankTemplateMethod(){
            @Override
            public void transact() {
                System.out.println("我要存钱：2000000！！！");
            }
        };
        btm2.process();
    }
}

• 什么时候用到模板方法模式：实现一个算法时，整体步骤很固定。但是，某些部分易变。易变部分可以抽象成出来，供子类实现。

• 开发中常见的场景：非常频繁。各个框架、类库中都有他的影子。比如常见的有：
1.数据库访问的封装；
2.Junit单元测试；
3.servlet中关于doGet/doPost方法调用；
4.Hibernate中模板程序；
5.spring中JDBCTemplate、HibernateTemplate等；

设计模式-策略模式

2020-05-20T06:56:40.000Z

某个市场人员接到单后的报价策略(CRM系统中常见问题)。报价策略很复杂，可以简单作如下分类：
• 普通客户小批量报价
• 普通客户大批量报价
• 老客户小批量报价
• 老客户大批量报价
具体选用哪个报价策略，这需要根据实际情况来确定。这时候，我们采用策略模式即可。

我们先可以采用条件语句处理：

public double getPrice(String type, double price){
if(type.equals("普通客户小批量")){
System.out.println("不打折,原价");
return price;
}else if(type.equals("普通客户大批量")){
System.out.println("打九折");
return price*0.9;
}else if(type.equals("老客户小批量")){
System.out.println("打八五折");
return price*0.85;
}else if(type.equals("老客户大批量")){
System.out.println("打八折");
return price*0.8;
}
return price;
}

但类型特别多，算法比较复杂时，整个条件控制代码会变得很长，难于维护。

策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一个算法解决某一问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法。

//策略接口
public interface Strategy {
    double getPrice(double standardPrice);
}

//新客户小批量
public class NewCustomerFew implements Strategy{
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("不打折原价");
        return standardPrice;
    }
}


//新客户大批量
public class NewCustomerLarge implements Strategy{
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("打九折！");
        return standardPrice*0.9;
    }
}

//老客户小批量
public class OldCustomerFew implements Strategy{
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("打85折");
        return standardPrice*0.85;
    }
}

//老客户大批量
public class OldCustomLarge implements Strategy{
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("打8折");
        return standardPrice*0.8;
    }
}

//上下文类
//负责和具体的策略类交互，是的客户端和算法独立
public class Context {
    private Strategy strategy; //当前采用的算法对象

    //通过构造器注入
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    //通过set方法注入
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void printPrice(double s){
        System.out.println("价格："+strategy.getPrice(s));
    }
}

//测试
public class test {
    public static void main(String[] args) {
        Strategy s1 = new OldCustomerFew();
        Strategy s2 = new OldCustomLarge();
        Context ctx = new Context(s1);
        Context  ctx2 = new Context(s2);
        int standardPrice = 1000;

        ctx.printPrice(standardPrice);
        ctx2.printPrice(standardPrice);
    }
}

• 本质：分离算法，选择实现。
• 开发中常见的场景：JAVASE中GUI编程中，布局管理；Spring框架中，Resource接口，资源访问策略；javax.servlet.http.HttpServlet#service()

应用层

2020-05-18T09:33:32.000Z

概述

• 每个应用层协议都是为了解决某一类应用问题，而问题的解决又往往是通过位于不同主机中的多个应用进程之间的通信和协同工作来完成的。应用层的具体内容就是规定应用进程在通信时所遵循的协议。

• 应用层的许多协议都是基于客户服务器方式。客户(client)和服务器(server)都是指通信中所涉及的两个应用进程。客户服务器方式所描述的是进程之间服务和被服务的关系。客户是服务请求方，服务器是服务提供方。

• 常用端口：

域名系统 DNS

DNS 是一个分布式数据库，提供了主机名和 IP 地址之间相互转换的服务。这里的分布式数据库是指，每个站点只保留它自己的那部分数据。

域名具有层次结构，从上到下依次为：根域名、顶级域名、二级域名…

动态主机配置协议DHCP

DHCP (Dynamic Host Configuration Protocol) 提供了即插即用的连网方式，用户不再需要手动配置 IP 地址(DHCP 配置的内容不仅是 IP 地址，还包括子网掩码、网关 IP 地址)等信息。

DHCP 服务器分配给 DHCP 客户的 IP 地址的临时的，因此 DHCP 客户只能在一段有限的时间内使用这个分配到的 IP 地址。DHCP 协议称这段时间为租用期。

• DHCP 服务器被动打开 UDP 端口 67，等待客户端发来的报文。
• DHCP 客户从 UDP 端口 68发送 DHCP发现报文(DHCPDISCOVER)。该报文被放入 UDP 中，广播到同一个子网的所有主机上。如果客户端和 DHCP 服务器不在同一个子网，就需要使用中继代理。
• 凡收到 DHCP 发现报文的 DHCP 服务器都发出 DHCP 提供报文(DHCPOFFER)，因此 DHCP 客户可能收到多个 DHCP 提供报文。
• DHCP 客户从几个 DHCP 服务器中选择其中的一个，并向所选择的 DHCP 服务器发送 DHCP 请求报文(DHCPREQUEST)。
• 被选择的 DHCP 服务器发送确认报文DHCPACK，进入已绑定状态，并可开始使用得到的临时 IP 地址了。

文件传送协议 FTP

文件传送协议 FTP (File Transfer Protocol) 是因特网上使用得最广泛的文件传送协议， FTP使用两个TCP连接：TCP控制链接、TCP数据连接：

控制连接：标准端口为21，在整个会话期间一直保持打开，FTP 客户发出的传送请求通过控制连接发送给服务器端的控制进程，但控制连接不用来传送文件。
数据连接：标准端口为20，实际用于传输文件。

根据数据连接是否是服务器端主动建立，FTP 有主动和被动两种模式：

主动模式：服务端从20端口主动向客户端发起连接。
被动模式：服务端在指定范围内的某个端口被动等待客户端发起连接

注意：主动模式要求客户端开放端口号给服务器端，需要去配置客户端的防火墙(需要在防火墙上开放20和21端口)。被动模式只需要服务器端开放端口号即可，无需客户端配置防火墙。但是被动模式会导致服务器端的安全性减弱，因为开放了过多的端口号。

按远程终端协议 TELNET

TELNET 是一个简单的远程终端协议，也是因特网的正式标准。

• TELNET 用于登录到远程主机上，并且远程主机上的输出也会返回。
• TELNET 可以适应许多计算机和操作系统的差异，例如不同操作系统系统的换行符定义。

电子邮件协议(SMTP, POP3, IMAP)

发送邮件的协议：SMTP使用TCP 25端口。
读取邮件的协议：POP3 使用110端口和 IMAP使用的端口是143。

• SMTP：SMTP 只能发送 ASCII 码，而互联网邮件扩充 MIME 可以发送二进制文件。MIME 并没有改动或者取代 SMTP，而是增加邮件主体的结构，定义了非 ASCII 码的编码规则。

• POP3：POP3 的特点是只要用户从服务器上读取了邮件，就把该邮件删除。但最新版本的 POP3 可以不删除邮件。

• IMAP：IMAP 协议中客户端和服务器上的邮件保持同步，如果不手动删除邮件，那么服务器上的邮件也不会被删除。IMAP 这种做法可以让用户随时随地去访问服务器上的邮件。

超文本传送协议 HTTP

在万维网客户程序与万维网服务器程序之间进行交互所使用的协议，是超文本传送协议 HTTP (HyperText Transfer Protocol)。

HTTP 是一个应用层协议，它使用 TCP 连接进行可靠的传送。

URL

使用统一资源定位符 URL (Uniform Resource Locator)来标志万维网上的各种文档。URL有如下一般形式：

<协议>://<主机>:<端口>/<路径>

• <协议> ftp、http、News…
• <主机> 是存放资源的主机在因特网中的域名;
• <端口>/<路径> 有时可省略；

请求web服务的过程：

HTTP的报文结构：

HTTP 有两类报文：

• 请求报文——从客户向服务器发送请求报文。
• 响应报文——从服务器到客户的回答。
• 由于 HTTP 是面向正文的(text-oriented)，因此在报文中的每一个字段都是一些 ASCII 码串，因而每个字段的长度都是不确定的。

报文由三个部分组成，即开始行、首部行和实体主体。在请求报文中，开始行就是请求行。包含了方法字段。

响应报文的开始行是状态行。状态行包括三项内容，即 HTTP 的版本，状态码，以及解释状态码的简单短语。

• 1xx ：Informational（信息性状态码），表示通知信息的，如请求收到了或正在进行处理。

100 Continue ：表明到目前为止都很正常，客户端可以继续发送请求或者忽略这个响应。

• 2xx ：Success（成功状态码），表示成功，如接受或知道了。

200 OK
204 No Content ：请求已经成功处理，但是返回的响应报文不包含实体的主体部分。一般在只需要从客户端往服务器发送信息，而不需要返回数据时使用。
206 Partial Content ：表示客户端进行了范围请求，响应报文包含由 Content-Range 指定范围的实体内容。

• 3xx ：Redirection（重定向状态码），表示重定向，表示要完成请求还必须采取进一步的行动。

301 Moved Permanently ：永久性重定向
302 Found ：临时性重定向
303 See Other ：和 302 有着相同的功能，但是 303 明确要求客户端应该采用 GET 方法获取资源。
注：虽然 HTTP 协议规定 301、302 状态下重定向时不允许把 POST 方法改成 GET 方法，但是大多数浏览器都会在 301、302 和 303 状态下的重定向把 POST 方法改成 GET 方法。
304 Not Modified ：如果请求报文首部包含一些条件，例如：If-Match，If-Modified-Since，If-None-Match，If-Range，If-Unmodified-Since，如果不满足条件，则服务器会返回 304 状态码。
307 Temporary Redirect ：临时重定向，与 302 的含义类似，但是 307 要求浏览器不会把重定向请求的 POST 方法改成 GET 方法。

• 4xx ：Client Error（客户端错误状态码），表示客户的差错，如请求中有错误的语法或不能完成。

400 Bad Request ：请求报文中存在语法错误。
401 Unauthorized ：该状态码表示发送的请求需要有认证信息（BASIC 认证、DIGEST 认证）。如果之前已进行过一次请求，则表示用户认证失败。
403 Forbidden ：请求被拒绝。
404 Not Found

• 5xx ：Server Error（服务器错误状态码），表示服务器的差错，如服务器失效无法完成请求。

500 Internal Server Error ：服务器正在执行请求时发生错误。
503 Service Unavailable ：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求。

传输层

2020-05-17T08:06:11.000Z

概述

进程之间的通信:

网络层只把分组发送到目的主机，但是真正通信的并不是主机而是主机中的进程。传输层提供了进程间的逻辑通信，传输层向高层用户屏蔽了下面网络层的核心细节，使应用程序看起来像是在两个传输层实体之间有一条端到端的逻辑通信信道。
传输层向它上面的应用层提供通信服务，它属于面向通信部分的最高层，同时也是用户功能中的最低层。
当网络的边缘部分中的两个主机使用网络的核心部分的功能进行端到端的通信时，只有位于网络边缘部分的主机的协议栈才有运输层，而网络核心部分中的路由器在转发分组时都只用到下三层的功能。

TCP和UDP:

运输层需要有两种不同的运输协议，即面向连接的 TCP 和无连接的 UDP。

用户数据报协议 UDP (User Datagram Protocol)：是无连接的，尽最大可能交付，没有拥塞控制，面向报文（对于应用程序传下来的报文不合并也不拆分，只是添加 UDP 首部），支持一对一、一对多、多对一和多对多的交互通信。
传输控制协议 TCP (Transmission Control Protocol)：是面向连接的，提供可靠交付，有流量控制，拥塞控制，提供全双工通信，面向字节流（把应用层传下来的报文看成字节流，把字节流组织成大小不等的数据块），每一条 TCP 连接只能是点对点的（一对一）。

传输层的端口:

运行在计算机中的进程是用进程标识符来标志的，为了使运行不同操作系统的计算机的应用进程能够互相通信，就必须用统一的方法对 TCP/IP 体系的应用进程进行标志。解决这个问题的方法就是在运输层使用协议端口号(protocol port number)，或通常简称为端口(port)。

端口用一个 16 位端口号进行标志。
端口号只具有本地意义，即端口号只是为了标志本计算机应用层中的各进程。在因特网中不同计算机的相同端口号是没有联系的。
三类端口：
1.熟知端口，数值一般为 0-1023；
2.登记端口号，数值为1024-49151，为没有熟知端口号的应用程序使用的；
3.客户端口号，数值为49152-65535，留给客户进程选择暂时使用；
常用应用层协议与传输层端口：
http = TCP + 80；
https = TCP + 443；
ftp = TCP + 21；
SMTP = TCP + 25；
POP3 = TCP + 101；
RDP = TCP + 3389；
SQL = TCP + 1433；
DNS = UDP + 53 or TCP + 53(极少情况)
计算机服务(对外的服务)运行后在TCP或UDP的某个端口侦听客户端请求。

UDP

UDP 只在 IP 的数据报服务之上增加了很少一点的功能，即端口的功能和差错检测的功能。

UDP 是无连接的，即发送数据之前不需要建立连接(主要针对短包，实时性要求不高的数据)。
UDP 使用尽最大努力交付，即不保证可靠交付，同时也不使用拥塞控制。
UDP 是面向报文的。UDP 没有拥塞控制，很适合多媒体通信的要求。
UDP 支持一对一、一对多、多对一和多对多的交互通信。
UDP 的首部开销小，只有 8 个字节。

面向报文：送方 UDP 对应用程序交下来的报文，在添加首部后就向下交付 IP 层。UDP 对应用层交下来的报文，既不合并，也不拆分，而是保留这些报文的边界。应用层交给 UDP 多长的报文，UDP 就照样发送，即一次发送一个报文。接收方 UDP 对 IP 层交上来的 UDP 用户数据报，在去除首部后就原封不动地交付上层的应用进程，一次交付一个完整的报文。应用程序必须选择合适大小的报文。

UDP首部格式：首部字段只有 8 个字节，包括源端口、目的端口、长度、检验和。12 字节的伪首部是为了计算检验和临时添加的。

TCP

TCP 概述：

主要特点:
1.TCP是面向连接的运输层协议；
2.每一条 TCP 连接只能有两个端点，每一条 TCP 连接只能是点对点的(一对一)；
3.TCP 提供可靠交付的服务；
4.TCP 提供全双工通信；
5.面向字节流；

面向字节流的传输过程：

注意：
1.TCP 连接是一条虚连接而不是一条真正的物理连接。
2.TCP 连接的端点不是主机，不是主机的IP 地址，不是应用进程，也不是运输层的协议端口。TCP 连接的端点叫做套接字(socket)，端口号拼接到 IP 地址即构成了套接字。
套接字 socket = (IP地址: 端口号)；
3.每一条 TCP 连接唯一地被通信两端的两个端点（即两个套接字）所确定。即：
TCP 连接 ::= {socket1, socket2} = {(IP1: port1), (IP2: port2)}；

TCP 报文首部格式：

源端口和目的端口字段——各占 2 字节，端口传输层与应用层的服务接口。传输层的复用和分用功能都要通过端口才能实现。
序号字段——占 4 字节，TCP 连接中传送的字节流中的每一个数据段都编上一个序号。序号字段的值则指的是本报文段所发送的数据的第一个字节的序号。
确认号字段——占 4 字节，是期望收到对方的下一个报文段的数据的第一个字节的序号。
数据偏移(即首部长度)——占 4 位，它表示首部长度，最长60个字节，故可变长度最长40个字节。
保留字段——占 6 位，保留为今后使用，但目前应置为 0。
紧急 URG —— 当 URG = 1 时，表明紧急指针字段有效。它告诉系统此报文段中有紧急数据，应尽快传送。
确认 ACK —— 只有当 ACK = 1 时确认号字段才有效。当 ACK = 0 时，确认号无效。
推送 PSH —— 接收 TCP 收到 PSH = 1 的报文段，就尽快地交付接收应用进程，而不再等到整个缓存都填满了后再向上交付。
复位 RST —— 当 RST = 1 时，表明 TCP 连接中出现严重差错(如由于主机崩溃或其他原因)，必须释放连接，然后再重新建立运输连接。
同步 SYN —— 同步 SYN = 1 表示这是一个连接请求或连接接受报文。
终止 FIN —— 用来释放一个连接。FIN = 1 表明此报文段的发送端的数据已发送完毕，并要求释放运输连接。
窗口字段 —— 占 2 字节，用来让对方设置发送窗口的依据，单位为字节。
检验和 —— 占 2 字节，检验和字段检验的范围包括首部和数据这两部分。在计算检验和时，要在 TCP 报文段的前面加上 12 字节的伪首部。
紧急指针字段 —— 占 16 位，指出在本报文段中紧急数据共有多少个字节（紧急数据放在本报文段数据的最前面）。
选项字段 —— 长度可变，TCP 最初只规定了一种选项，即最大报文段长度 MSS。MSS 告诉对方 TCP：“我的缓存所能接收的报文段的数据字段的最大长度是 MSS 个字节。”

TCP 可靠传输：

停止等待协议：

使用上述的确认和重传机制，我们就可以在不可靠的传输网络上实现可靠的通信，这种可靠传输协议常称为自动重传请求ARQ(Automatic Repeat reQuest) 。

TCP 滑动窗口：

停止等待协议的优点是简单，但缺点是信道利用率太低。

针对这一缺点，一般采用滑动窗口(流水线传输)和累积确认(接收窗口)的方法提高信道利用率。
滑动窗口：发送方可连续发送多个分组，不必每发完一个分组就停顿下来等待对方的确认。
1.如下图所示，根据 B 给出的窗口值A构造出自己的发送窗口；
2.A 发送了 11 个字节的数据；
3.A 收到新的确认号后，发送窗口向前滑动；
4.若A 的发送窗口内的序号都已用完，但还没有再收到确认，必须停止发送；
累积确认：接收方一般采用累积确认的方式。即不必对收到的分组逐个发送确认，而是对按序到达的最后一个分组发送确认，这样就表示：到这个分组为止的所有分组都已正确收到了。

TCP 流量控制：

一般说来，我们总是希望数据传输得更快一些。但如果发送方把数据发送得过快，接收方就可能来不及接收，这就会造成数据的丢失。流量控制(flow control)就是让发送方的发送速率不要太快，既要让接收方来得及接收，也不要使网络发生拥塞。利用滑动窗口机制可以很方便地在 TCP 连接上实现流量控制。

接收方发送的确认报文中的窗口字段可以用来控制发送方窗口大小，从而影响发送方的发送速率。将窗口字段设置为 0，则发送方不能发送数据。

TCP 拥塞控制：

拥塞控制：所要做的都有一个前提，就是网络能够承受现有的网络负荷。拥塞控制是一个全局性的过程，涉及到所有的主机、所有的路由器，以及与降低网络传输性能有关的所有因素。

流量控制：往往指在给定的发送端和接收端之间的点对点通信量的控制。主要是抑制发送端发送数据的速率，以便使接收端来得及接收。

几种拥塞控制方法：慢开始、拥塞避免、快重传、快恢复

慢开始和拥塞避免算法：

1.发送的最初执行慢开始，令 cwnd = 1，发送方只能发送 1 个报文段；当收到确认后，将 cwnd 加倍，因此之后发送方能够发送的报文段数量为：2、4、8 …

2.注意到慢开始每个轮次都将 cwnd 加倍，这样会让 cwnd 增长速度非常快，从而使得发送方发送的速度增长速度过快，网络拥塞的可能性也就更高。设置一个慢开始门限 ssthresh，当 cwnd >= ssthresh 时，进入拥塞避免，每个轮次只将 cwnd 加 1。

3.如果出现了超时，则令 ssthresh = cwnd / 2，然后重新执行慢开始。

注意：发送方需要维护一个叫做拥塞窗口（cwnd）的状态变量，注意拥塞窗口与发送方窗口的区别：拥塞窗口只是一个状态变量，实际决定发送方能发送多少数据的是发送方窗口。

快重传和快恢复：

快重传：在接收方，要求每次接收到报文段都应该对最后一个已收到的有序报文段进行确认。例如已经接收到 M1 和 M2，此时收到 M4，应当发送对 M2 的确认。
在发送方，如果收到三个重复确认，那么可以知道下一个报文段丢失，此时执行快重传，立即重传下一个报文段。例如收到三个 M2，则 M3 丢失，立即重传 M3。

快恢复：在这种情况下，只是丢失个别报文段，而不是网络拥塞。因此执行快恢复，令 ssthresh = cwnd / 2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。

注意：慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。

TCP 链接管理：

运输连接就有三个阶段，即：连接建立、数据传送和连接释放。运输连接的管理就是使运输连接的建立和释放都能正常地进行。

TCP建立连接的三次握手：
TCP 连接的建立都是采用客户服务器方式：
• 主动发起连接建立的应用进程叫做客户(client)
• 被动等待连接建立的应用进程叫做服务器(server)

三次握手：

A 的 TCP 向 B 发出连接请求报文段，其首部中的同步位 SYN = 1，并选择序号 seq = x，表明传送数据时的第一个数据字节的序号是 x。
B 的 TCP 收到连接请求报文段后，如同意，则发回确认. B 在确认报文段中应使 SYN = 1，使 ACK = 1，其确认号ack = x + 1，自己选择的序号 seq = y。
A 收到此报文段后向 B 给出确认，其 ACK = 1，确认号 ack = y + 1。
A 的 TCP 通知上层应用进程，连接已经建立。

注意：三次握手的原因：第三次握手是为了防止失效的连接请求到达服务器，让服务器错误打开连接。如果不进行三次握手，那么服务器就会打开两个连接。导致连接失败，如果有第三次握手，客户端会忽略服务器之后发送的对滞留连接请求的连接确认。

TCP连接释放的四次挥手：

四次挥手：

A 把连接释放报文段首部的 FIN = 1，其序号seq = u，等待 B 的确认。
B 发出确认，确认号 ack = u + 1，而这个报文段自己的序号 seq = v。TCP 服务器进程通知高层应用进程。从 A 到 B 这个方向的连接就释放了，TCP 连接处于半关闭状态。B 若发送数据，A 仍要接收。
若 B 已经没有要向 A 发送的数据，其应用进程就通知 TCP 释放连接。
A 收到连接释放报文段后，必须发出确认。在确认报文段中 ACK = 1，确认号 ack = w + 1，自己的序号 seq = u + 1。
TCP 连接必须经过时间 2MSL(最大报文存活时间)后才真正释放掉。

注意：客户端A的TIME-WAIT状态必须等待2MSL的原因：
第一，为了保证 A 发送的最后一个 ACK 报文段能够到达 B。
第二，防止 “已失效的连接请求报文段”出现在本连接中。A 在发送完最后一个 ACK 报文段后，再经过时间 2MSL，就可以使本连接持续的时间内所产生的所有报文段，都从网络中消失。这样就可以使下一个新的连接中不会出现这种旧的连接请求报文段。

网络层

2020-05-15T13:55:05.000Z

概述

因为网络层是整个互联网的核心，因此应当让网络层尽可能简单。网络层向上只提供简单灵活的、无连接的、尽最大努力交互的数据报服务。使用 IP 协议，可以把异构的物理网络连接起来，使得在网络层看起来好像是一个统一的网络。

TCP/IP协议栈

IP地址编址

点分十进制记法：

划分子网：

通过在主机号字段中拿一部分作为子网号，把两级 IP 地址划分为三级 IP 地址。划分子网纯属一个单位内部的事情。单位对外仍然表现为没有划分子网的网络。
IP 地址 ::= {< 网络号 >, < 子网号 >, < 主机号 >}
要使用子网，必须配置子网掩码。例如：一个 C 类地址的默认子网掩码为 255.255.255.0，如果 B 类地址的子网占两个比特，那么子网掩码为11111111 11111111 11111111 11000000，也就是 255.255.255.192。

注意：外部网络看不到子网的存在。

构造超网(无分类CIDR)：

CIDR 消除了传统的 A 类、B 类和 C 类地址以及划分子网的概念，因而可以更加有效地分配 IPv4 的地址空间。
CIDR使用各种长度的“网络前缀”(network-prefix)来代替分类地址中的网络号和子网号。从三级编址（使用子网掩码）又回到了两级编址。
IP地址 ::= {<网络前缀>, <主机号>}
一个 CIDR 地址块可以表示很多地址，这种地址的聚合常称为路由聚合，它使得路由表中的一个项目可以表示很多个（例如上千个）原来传统分类地址的路由。路由聚合也称为构成超网(supernetting)。
CIDR 虽然不使用子网了，但仍然使用“掩码”这一名词（但不叫子网掩码）。
在路由表中的项目由“网络前缀”和“下一跳地址”组成，在查找时可能会得到不止一个匹配结果，应当采用最长前缀匹配来确定应该匹配哪一个。

计算机A到B的通信过程：

ARP协议

不管网络层使用的是什么协议，在实际网络的链路上传送数据帧时，最终还是必须使用硬件地址。
每一个主机都设有一个 ARP 高速缓存(ARP cache)，里面有所在的局域网上的各主机和路由器的 IP 地址到硬件地址的映射表。
当主机 A 欲向本局域网上的某个主机 B 发送 IP 数据报时，就先在其 ARP 高速缓存中查看有无主机 B 的 IP 地址。如有，就可查出其对应的硬件地址，再将此硬件地址写入 MAC 帧，然后通过局域网将该 MAC 帧发往此硬件地址。

注意：ARP 是解决同一个局域网上的主机或路由器的 IP 地址和硬件地址的映射问题。如果所要找的主机和源主机不在同一个局域网上，那么就要通过 ARP 找到一个位于本局域网上的某个路由器的硬件地址，然后把分组发送给这个路由器，让这个路由器把分组转发给下一个网络。剩下的工作就由下一个网络来做。

IP数据包

一个 IP 数据包由首部和数据两部分组成。
首部的前一部分是固定长度，共 20 字节，是所有 IP 数据报必须具有的。
在首部的固定部分的后面是一些可选字段，其长度是可变的。

版本——占 4 位：指 IP 协议的版本：4（IPv4）和 6（IPv6）
首部长度——占 4 位：可表示的最大数值，是 15 个单位(一个单位为 4 字节)，因此 IP 的首部长度的最大值是 60 字节。
区分服务——占 8 位：用来获得更好的服务，在一般的情况下都不使用这个字段。
总长度——占 16 位：指首部和数据之和的长度，单位为字节，因此数据报的最大长度为 65535 字节。总长度必须不超过最大传送单元 MTU。
标识——占 16 位：它是一个计数器，用来产生数据报的标识。
标志——占 3 位：目前只有前两位有意义。
生存时间——占 8 位：记为 TTL (Time To Live)，数据报在网络中可通过的路由器个数的最大值。
协议——占 8 位：该字段指出此数据报携带的数据使用何种协议以便目的主机的 IP 层将数据部分上交给哪个处理过程。
首部检验和——占 16 位：因为数据报每经过一个路由器，都要重新计算检验和，因此检验和不包含数据部分可以减少计算的工作量(简单计算)。
源地址和目的地址——占 32 位：都各占 4 字节。
片偏移——占 312位：较长的分组在分片后某片在原分组中的相对位置。片偏移以 8 个字节为偏移单位。

注意：IP 首部的可变部分就是一个选项字段，用来支持排错、测量以及安全等措施，内容很丰富。选项字段的长度可变，从 1 个字节到 40 个字节不等，取决于所选择的项目。增加首部的可变部分是为了增加 IP 数据报的功能，但这同时也使得 IP 数据报的首部长度成为可变的。这就增加了每一个路由器处理数据报的开销。实际上这些选项很少被使用。

IP转发分组

路由就是路由器从一个网段到另外一个网段转发数据包的过程，即数据包通过路由器转发，就是数据路由。
网络畅通条件，要求数据包必须能够到达目标地址，同时数据包必须能够返回发送地址。(有去有回)
这就要求沿途经过的路由器必须知道到目标网络如何转发数据包，即到达目的网络下一跳转发给哪个路由器，也就是必须有到达目标网络的路由，沿途的路由器还必须有数据包返回所需的路由。

注意：IP 数据报的首部中没有地方可以用来指明“下一跳路由器的 IP 地址”。当路由器收到待转发的数据报，不是将下一跳路由器的 IP 地址填入 IP 数据报，而是送交下层的网络接口软件。网络接口软件使用 ARP 负责将下一跳路由器的 IP 地址转换成硬件地址，并将此硬件地址放在链路层的 MAC 帧的首部，然后根据这个硬件地址找到下一跳路由器。

网际控制报文协议 ICMP

ICMP 是为了更有效地转发 IP 数据报和提高交付成功的机会。它封装在 IP 数据报中，ICMP 报文作为 IP 层数据报的数据，加上数据报的首部，组成 IP 数据报发送出去。ICMP 不是高层协议，而是 IP 层的协议。
ICMP 报文的种类有两种，即 ICMP 差错报告报文和 ICMP 询问报文。
ICMP 报文的前 4 个字节是统一的格式，共有三个字段：即类型、代码和检验和。接着的 4 个字节的内容与 ICMP 的类型有关。

几种常见的ICMP报文类型：

Ping：用来测试两个主机之间的连通性；是应用层直接使用网络层 ICMP 的例子，它没有通过运输层的 TCP 或UDP；
Traceroute： 是 ICMP 的另一个应用，用来跟踪一个分组从源点到终点的路径，发送的 IP 数据报封装的是无法交付的 UDP 用户数据报，并由目的主机发送终点不可达差错报告报文；

路由选择协议

基本概念：

从路由算法的自适应性考虑可分为：静态路由选择策略和动态路由选择策略：

静态路由选择策略——即非自适应路由选择，其特点是简单和开销较小，但不能及时适应网络状态的变化。
动态路由选择策略——即自适应路由选择，其特点是能较好地适应网络状态的变化，但实现起来较为复杂，开销也比较大。

路由选择协议都是自适应的，能随着网络通信量和拓扑结构的变化而自适应地进行调整。互联网可以划分为许多较小的自治系统 AS，一个 AS 可以使用一种和别的 AS 不同的路由选择协议。可以把路由选择协议划分为两大类：

自治系统内部的路由选择：RIP 和 OSPF；
自治系统间的路由选择：BGP

内部网关协议 RIP：

RIP是一种分布式的基于距离向量的路由选择协议，RIP 协议中的距离即为跳数，RIP允许一条路径最多只能包含 15 个路由器。跳数的最大值为16 时相当于不可达。可见RIP只适用于小型互联网。
RIP协议的三个要点：
1.仅和相邻路由器交换信息；
2.交换的信息是当前本路由器所知道的全部信息，即自己的路由表；
3.按固定的时间间隔(30秒)交换路由信息；
优缺点：
优点：RIP 协议实现简单，开销小。
缺点：但是 RIP 能使用的最大距离为 15，限制了网络的规模；并且当网络出现故障时，要经过比较长的时间才能将此消息传送到所有路由器；同时仅基于跳数选择最佳路由也不够合理；

内部网关协议 OSPF(Open Shortest Path First)

基本特点：
1.“开放”表明 OSPF 协议不是受某一家厂商控制，而是公开发表的;
2.“最短路径优先”是因为使用了 Dijkstra 提出的最短路径算法SPF;
三个要点 :
1.向本自治系统中所有路由器发送信息，使用的方法是洪泛法。
2.发送的信息就是与本路由器相邻的所有路由器的链路状态，但这只是路由器所知道的部分信息。
3.只有当链路状态发生变化时，路由器才用洪泛法向所有路由器发送此信息。
OSPF 能够用于规模很大的网，的更新过程收敛得快;

外部网关协议 BGP

BGP 是不同自治系统的路由器之间交换路由信息的协议。

因特网的规模太大，使得自治系统之间路由选择非常困难；
边界网关协议 BGP 只能是力求寻找一条能够到达目的网络且比较好的路由（不能兜圈子），而并非要寻找一条最佳路由；

每个 AS 都必须配置 BGP 发言人，通过在两个相邻 BGP 发言人之间建立 TCP 连接来交换路由信息。

虚拟专用网VPN

专用网段：
10.0.0.0 到 10.255.255.255
172.16.0.0 到 172.31.255.255
192.168.0.0 到 192.168.255.255

这些地址只能用于一个机构的内部通信，而不能用于和因特网上的主机通信。

下图中，场所 A 和 B 的通信经过互联网，如果场所 A 的主机 X 要和另一个场所 B 的主机 Y 通信，IP 数据报的源地址是 10.1.0.1，目的地址是 10.2.0.3。数据报先发送到与互联网相连的路由器 R1，R1 对内部数据进行加密，然后重新加上数据报的首部，源地址是路由器 R1 的全球地址 125.1.2.3，目的地址是路由器 R2 的全球地址 194.4.5.6。路由器 R2 收到数据报后将数据部分进行解密，恢复原来的数据报，此时目的地址为 10.2.0.3，就交付给 Y。

网络地址转换NAT

需要在专用网连接到因特网的路由器上安装 NAT 软件。装有 NAT 软件的路由器叫做 NAT路由器，它至少有一个有效的外部全球地址 IP。

所有使用本地地址的主机在和外界通信时都要在 NAT 路由器上将其本地地址转换成 IP才能和因特网连。

在以前，NAT 将本地 IP 和全球 IP 一一对应，这种方式下拥有 n 个全球 IP 地址的专用网内最多只可以同时有 n 台主机接入互联网。为了更有效地利用全球 IP 地址，现在常用的 NAT 转换表把传输层的端口号也用上了，使得多个专用网内部的主机共用一个全球 IP 地址。使用端口号的 NAT 也叫做网络地址与端口转换 NAPT。

Internet组播管理协议 IGMP

当某个主机加入新的多播组时，该主机应向多播组的多播地址发送IGMP 报文，声明自己要成为该组的成员。本地的多播路由器收到 IGMP 报文后，将组成员关系转发给因特网上的其他多播路由器。
因为组成员关系是动态的，因此本地多播路由器要周期性地探询本地局域网上的主机，以便知道这些主机是否还继续是组的成员。

数据链路层

2020-05-15T07:05:33.000Z

基本问题

基本概念：

1.主机H1向H2发送数据：
层次上来看：

仅从数据链路层观察帧的流动：

注意：可以看到路由器只到网络层(三层协议)，没有应用层，和传输层；

2.数据链路层传输的是帧：

数据链路层的三个基本点：

1.封装成帧
2.透明传输
3.差错控制

封装成帧：封装成帧(framing)就是在一段数据的前后分别添加首部和尾部，然后就构成了一个帧。确定帧的界限。首部和尾部的一个重要作用就是进行帧定界。

透明传输：发送端的数据链路层在数据中出现控制字符“SOH”或“EOT”的前面插入一个转义字符“ESC”。如果转义字符也出现数据当中，那么应在转义字符前插入一个转义字符。在接收端进行处理之后可以还原出原始数据。这个过程透明传输的内容是转义字符，用户察觉不到转义字符的存在。

差错控制：在数据链路层传送的帧中，广泛使用了循环冗余检验 (CRC) 的检错技术：CRC是一种无比特差错，而不是无传输差错的检测机制。将得到的FCS(帧检验序列 )添加在原序列后面，在接收端检验：若得出的余数 R = 0，则判定这个帧没有差错，就接受(accept)；若余数 R != 0，则判定这个帧有差错，就丢弃，在高层进行重传指令。

数据链路层的信道类型

点对点信道：

使用一对一的点对点通信方式，不会发生碰撞，因此也比较简单，使用 PPP 协议进行控制。PPP 协议是用户计算机和 ISP 进行通信时所使用的数据链路层协议，支持身份验证，支持多个网络层协议。
PPP协议帧格式：
1.A、C：在点到点信道没有实际意义，固定为：FF、03；
2.协议字段(2字节)：用于标识信息部分是什么内容；
3.FCS(2字节)：表示CRC得到的帧检验序列；

广播信道：

这种信道使用一对多的广播通信方式，因此过程比较复杂。广播信道上连接的主机很多，因此必须使用专用的共享信道协议来协调这些主机的数据发送(随机接入)：CSMA/CD(载波监听多点接入/碰撞检测) 协议：
多点接入：表示许多计算机以多点接入的方式连接在一根总线上。
载波监听：是指每一个站在发送数据之前先要检测一下总线上是否有其他计算机在发送数据，如果有，则暂时不要发送数据，以免发生碰撞。
碰撞检测：在发送中，如果监听到信道已有其它主机正在发送数据，就表示发生了碰撞。虽然每个主机在发送数据之前都已经监听到信道为空闲，但是由于传播时延的存在，还是有可能会发生碰撞。

记端到端的传播时延为 τ，最先发送的站点最多经过 2τ 就可以知道是否发生了碰撞，称 2τ 为争用期 。只有经过争用期之后还没有检测到碰撞，才能肯定这次发送不会发生碰撞。以太网中经过计算，最短有效帧长为512bit，也就是64个字节，规定凡是长度小于64字节的帧都是无效帧。
当发生碰撞时，站点要停止发送，等待一段时间再发送。这个时间采用 截断二进制指数退避算法 来确定。从离散的整数集合 {0, 1, .., (2k-1)} 中随机取出一个数，记作 r，然后取 r 倍的争用期作为重传等待时间。
注意：该协议只能(只能进行半双工通信)。

以太局域网

概述：

以太网是一种星型拓扑结构局域网。早期使用集线器(hub)进行连接，集线器是一种物理层设备，作用于比特而不是帧。目前以太网使用交换机替代了集线器，交换机是一种链路层设备，它不会发生碰撞，能根据 MAC 地址进行存储转发。
以太网提供的服务是不可靠的交付，即尽最大努力的交付。当接收站收到有差错的数据帧时就丢弃此帧，其他什么也不做。差错的纠正由高层来决定。如果高层发现丢失了一些数据而进行重传，但以太网并不知道这是一个重传的帧，而是当作一个新的数据帧来发送。

信道利用率：

一个帧从开始发送，经可能发生的碰撞后，将再重传数次，到发送成功且信道转为空闲时为止，是发送一帧所需的平均时间。信道利用率可以表示为：T0/发送一帧所需的平均时间。

MAC层(数据链路层的子层)：

在局域网中，硬件地址又称为物理地址，或 MAC 地址。MAC 地址是链路层地址，长度为 6 字节（48 位），用于唯一标识网络适配器（网卡）。一台主机拥有多少个网络适配器就有多少个 MAC 地址。例如笔记本电脑普遍存在无线网络适配器和有线网络适配器，因此就有两个 MAC 地址。
以太网MAC帧格式：

扩展以太网

网桥(淘汰)：

在数据链路层扩展局域网是使用网桥。网桥工作在数据链路层，它根据 MAC 帧的目的地址对收到的帧进行转发。网桥具有过滤帧的功能。当网桥收到一个帧时，并不是向所有的接口转发此帧，而是先检查此帧的目的 MAC 地址，然后再确定将该帧转发到哪一个接口。

交换机：

交换机具有自学习能力，学习的是交换表的内容，交换表中存储着 MAC 地址到接口的映射。正是由于这种自学习能力，因此交换机是一种即插即用设备，不需要网络管理员手动配置交换表内容。
1.端口独享带宽；
2.比集线器安全，可以设置固定MAC地址；
3.接口到计算机全双工；
4.全双工模式不再使用CSMA/CD协议；
5.接口可以工作在不同的速率；
6.广播帧会转发到全部端口；

虚拟局域网(VLAN):

虚拟局域网可以建立与物理位置无关的逻辑组，只有在同一个虚拟局域网中的成员才会收到链路层广播信息。例如：在研发部某台主机广播的消息只能住研发部收到，销售部和人力资源部则收不到消息。
使用 VLAN 干线连接来建立虚拟局域网，每台交换机上的一个特殊接口被设置为干线接口，以互连 VLAN 交换机。IEEE 定义了一种扩展的以太网帧格式 802.1Q，它在标准以太网帧上加进了 4 字节首部 VLAN 标签，用于表示该帧属于哪一个虚拟局域网。

计算机网络概述

2020-05-15T06:26:57.000Z

OSI七层参考模型:
1.应用层：能够产生网络流量能够和用户交互的应用程序；
2.表示层：加密，压缩，开发人员；
3.会话层：服务和客户建立的会话：netstat -n；
4.传输层：可靠传输建立会话，不可靠传输，流量控制；
5.网络层：IP地址编址，选择最佳路径；
6.数据链路层：数据如何封装，添加物理层地址(MAC)；
7.物理层：电压，借口标准；

网络排错：从底层到高层

五层参考模型:
传输的过程：

设计模式-工厂模式

2020-05-14T07:56:13.000Z

核心：实现了创建者和调用者的分离，用工厂方法代替new操作。将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。
三种类型的工厂模式：
1.简单工厂（使用较多）：又叫静态工厂模式，就是工厂类一般是使用静态方法，通过不同的方法(或是通过传递不同的参数)来返回不同的对象实例；
2.工厂方法：为了避免简单工厂模式的缺点，不完全满足OCP（开闭原则）。工厂方法模式和简单工厂模式最大的不同：简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。根据设计理论建议：工厂方法模式，但实际上，我们一般都用简单工厂模式；
3.抽象工厂：用来生产不同产品族的全部产品：在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式；

不使用工厂模式的情况：

public class Audi implements Car{
    @Override
    public void run() {
        System.out.println("Audi跑！！！");
    }
}

public class Byd implements Car{
    @Override
    public void run() {
        System.out.println("Byd跑！！！");
    }
}

public class test01 { //调用者
  public static void main(String[] args) {
    Car c1 = new Audi();
    Car c2 = new Byd();
    c1.run();
    c2.run();
  }
}

简单工厂：

public class CarFactory {
    public static Car createAudi(){
        return new Audi();
    }
    public static Car createByd(){
        return new Byd();
    }
}

public class test01 {//调用者
    public static void main(String[] args) {
        Car car1 = CarFactory.createAudi();
        Car car2 = CarFactory.createByd();
        car1.run();
        car2.run();
    }
}

工厂方法：
增加两个实现类：

public interface CarFactory {
    Car createCar();
}

public class AudiFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Audi();
    }
}

public class BydFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Byd();
    }
}

public class test01 {//调用者
    public static void main(String[] args) {
        Car car1 = new AudiFactory().createCar();
        Car car2 = new BydFactory().createCar();
        car1.run();
        car2.run();
    }
}

抽象工厂：

设计模式-单例模式

2020-05-13T09:12:28.000Z

核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点,减少了系统性能开销。
常见应用场景：Windows的任务管理器就是很典型的单例模式；数据库连接池的设计一般也是采用单例模式…
常见的五种单例模式实现方式：
1.饿汉式：线程安全，调用效率高。但是，不能延时加载；
2.懒汉式：线程安全，调用效率不高，可以延时加载；
3.静态内部类式：线程安全，调用效率高，可以延时加载；
4.枚举式：线程安全，调用效率高，不能延时加载。并且可以天然的防止反射和反序列化创建对象的漏洞！
5.~~双重检测锁式~~：JVM底层内部模型原因，偶尔会出问题。不建议使用；

饿汉式：

//饿汉式：
public class SingletonDemo01 {
    //类初始化时，上来先创建对象（没有延时加载的优势），加载类时，天然线程安全
    private static SingletonDemo01 instance = new SingletonDemo01();
    //构造器私有
    private  SingletonDemo01(){}
    //优点：方法没有同步调用效率高
    public static SingletonDemo01 getInstance(){
        return  instance;
    }
}

懒汉式：

//懒汉式：
public class SingletonDemo02 {
    //类初始化时，不创建对象（延时加载，真正用的时候再创建）
    private static SingletonDemo02 instance;
    //构造器私有
    private SingletonDemo02(){}
    //需要加同步，保证单例模式，效率较低
    public static synchronized SingletonDemo02 getInstance(){
        if(instance == null) instance = new SingletonDemo02();
        return  instance;
    }
}

静态内部类式:

//静态内部类方式：线程安全，调用效率高，实现延时加载
public class SingletonDemo03 {
    private static class SingletonInnerClass{
        private static final SingletonDemo03 instance = new SingletonDemo03();
    }
    //构造器私有
    private SingletonDemo03(){}
    //优点：方法没有同步调用效率高
    public static SingletonDemo03 getInstance(){
        return  SingletonInnerClass.instance;
    }
}

枚举式:

//枚举类方式：线程安全，但没有延时加载；同时能够避免反射和反序列的漏洞
public enum SingletonDemo04 {
    INSTANCE;
    //可以自己添加一些操作方法
    public static void instanceOper(){
    }
}

如何选用合适的单例模式：
单例对象占用资源少，不需要延时加载：枚举式 > 饿汉式;
单例对象占用资源大，需要延时加载：静态内部类式 > 懒汉式;

JVM核心机制-类加载过程

2020-05-13T06:38:30.000Z

类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口：

类加载器的层次结构(树状结构):

引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库)，是用C来实现的，并不继承自 java.lang.ClassLoader；
扩展类加载器（extensions class loader）：用来加载 Java 的扩展库，Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java类，由ExtClassLoader实现；
应用程序类加载器（application class loader）：它根据 Java 应用的类路径来加载 Java 类，一般来说，Java 应用的类都是由它来完成加载的，由AppClassLoader实现；
自定义类加载器：开发人员可以通过继承 java.lang.ClassLoader类的方式，实现自己的类加载器，以满足一些特殊的需求。

注意：类加载器加载类的时候是线程安全的

双亲委托机制：

就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次追溯，直到最高的爷爷辈的，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。
双亲委托机制是为了保证 Java 核心库的类型安全，这种机制就保证不会出现用户自己能定义java.lang.Object类的情况。
类加载器除了用于加载类，也是安全的最基本的屏障。
双亲委托机制是代理模式的一种，但并不是所有的类加载器都采用双亲委托机制：tomcat服务器类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器，这与一般类加载器的顺序是相反的。