Java---刷题03

发布于:2022-11-09 ⋅ 阅读:(10) ⋅ 点赞:(0) ⋅ 评论:(0)

1、136. 只出现一次的数字 - 力扣(LeetCode)

2、138. 复制带随机指针的链表 - 力扣(LeetCode)

3、实现哈希表代码, 使用哈希桶方式解决哈希冲突

public class HashBucket {
    private static class Node {
        private int key;
        private int value;
        Node next;
 
        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
 
    private Node[]  array;
    private int size;   // 当前的数据个数
	private static final double LOAD_FACTOR = 0.75;
    private static final int DEFAULT_SIZE = 8;//默认桶的大小
	
	public HashBucket() {
        array = new Node[DEFAULT_SIZE ];
        size = 0;
    }
 
    public int put(int key, int value) {
        // key => int
        // int 合法的下标
        int index = key % array.length;
 
        // 2. 在链表中查找 key 所在的结点    长度一般是固定的 所以认为这里也是O(1)
        //      如果找到了,更新
        //      所有结点都不是 key,插入一个新的结点
        for (Node cur = array[index]; cur != null; cur = cur.next) {
            if (key == cur.key) {
                int oldValue = cur.value;
                cur.value = value;
                return oldValue;
            }
        }
		//头插法
        Node node = new Node(key, value);
        node.next = array[index];
        array[index] = node;
        size++;
 
        if (loadFactor() >= LOAD_FACTOR ) {
            resize();
        }
 
        return -1;
    }
	
	private double loadFactor() {
        return size * 1.0 / array.length;
    }
 
    private void resize() {
        Node[] newArray = new Node[array.length * 2];
        for (int i = 0; i < array.length; i++) {
            Node next;
            for (Node cur = array[i]; cur != null; cur = next) {
                next = cur.next;
				//每个节点都要进行重新计算index
                int index = cur.key % newArray.length;
				//头插法  第一次插入的时候newArray[index]为空
                cur.next = newArray[index];
                newArray[index] = cur;
            }
        }
        array = newArray;
    }
	
	public int get(int key) {
        // 1. key =》 int 类型
        // 2. 保证下标是合法的
        int index = key % array.length;
 
        Node head = array[index];
        for (Node cur = head; cur != null; cur = cur.next) {
            if (key == cur.key) {
                return cur.value;
            }
        }
 
        return -1;
    }
}
  
 

4、217. 存在重复元素 - 力扣(LeetCode)

5、219. 存在重复元素 II - 力扣(LeetCode)

6、设计一张商品表,包含以下字段:商品名称、商品价格、商品库存、商品描述

drop table if exists product;
create table product(
	name varchar(20),
	price decimal(11,2),
	storage int,
	description varchar(100)
);

7、设计一张老师表,包含以下字段:姓名、年龄、身高、体重、性别、学历、生日、身份证号

drop table if exists teacher;
create table teacher(
	name varchar(20),
	age int,
	height double,
	weight double,
	sex bit,
	birthday TIMESTAMP,
	id_number varchar(18)
);

8、设计一张图书表,包含以下字段:图书名称,图书作者、图书价格、图书分类

drop table if exists book;
create table book(
	name varchar(20),
	author varchar(20),
	price decimal(11,2),
	category varchar(20)
);

9、在图书表中新增一条记录:Java核心技术、作者“Cay S. Horstman”,价格56.43,分类为“计算机技术”

insert into book values('Java核心技术','Cay S.Horstman',56.43,'计算机技术');

 全列都有值,直接全列插入就行了。

10、在以上创建的商品表中插入一条数据:名称为“学生书包”、价格18.91、库存101、描述为空

insert into product(name,price,storage) values('学生书包',18.91,101);

可以全列插入,也可以直插需要的三列。全列插入就是写成('学生书包',18.91,101, null)。 

11、student学生表中,字段有姓名name,年龄age,要求查询姓张,并且年龄在18到25岁之间的学生

select * from student where name like '张%' and age between 18 and 25;

姓张那么就是like '张%',年龄要某个区间内,用between...and...即可

12、查询article文章表中,发表日期create_date在2019年1月1日上午10点30分至2019年11月10日下午4点2分的文章

select * from article where create_date between '2019-01-01 10:30:00' and '2019-11-10 16:02:00';

时间信息也是可以用between...and...的。

13、查询article文章表中,文章标题title为空,或者满足发表日期create_date在2019年1月1日之后

select * from article where title is null or create_date > '2019-01-01 00:00:00';

判空可以用is null或者<=> null,发表日期可以直接用大于号比较。

14、查询book图书表中,作者author列不为空,或者满足条件:价格price在50元以上且出版日期publish_date在2019年之后的图书信息

select * from book where author is not null or (price >50 and publish_date>'2019-01-01 00:00:00');

不为空用is not null或者not ... <=> null。这个条件跟后面是或关系,后两个是且关系。

15、查询用户user表中,满足以下条件的用户数据:

1. ID在1至200或300至500,且账号accout列不为空

2. 充值金额amount在1000以上。

select * from user where (id between 1 and 200 or id between 300 and 500) and accout is not null or amount>1000;

条件1两个between...and...间是或关系,跟“accout列不为空”这个条件是且关系。条件1与条件2间是或关系。

16、修改“Java核心技术”的图书信息,将价格修改为61

update book set price=61 where name='Java核心技术';

17、删除商品表中,价格大于60,或者是库存小于200的记录

delete from product where price>60 or storage<200;

18、修改所有库存大于30的商品记录,将价格增加50块

update product set price=price+50 where storage>30;

19、设计一个考勤系统

考勤系统,包含员工表,考勤记录表

-- 主要考虑记录表中的记录信息,是如何关联到员工表,员工与记录关系为1:m。

create table emp(
id int primary key,
  name varchar(20)
);
create table info(
id int primary key,
  emp_id int,
  info_date timestamp,
  foreign key (emp_id) references emp(id)
);

20、设计一个学校宿舍管理系统 

学校宿舍管理系统,要求包含宿舍信息,学生信息,每日的宿舍查房记录。

-- 主要考虑学生与宿舍的关系:m:1,宿舍的查房记录是根据宿舍来查的,与宿舍有关系,一个宿舍可以多次查房,宿舍与查房记录是1:m的关系

create table dormitory(
id int primary key,
  number varchar(20)
);

create table student(
id int primary key,
  name varchar(20),
  dormitory_id int,
  foreign key (dormitory_id) references dormitory(id)
);


create table info(
id int primary key,
  dormitory_id int,
  status bit,
  info_date timestamp,
  foreign key (dormitory_id) references dormitory(id)

);

21、设计一个车辆违章系统

车辆违章系统,包含用户表,车辆表,违章信息表。违章信息表中包含用户和车辆的违章信息

 -- 用户可以拥有多辆车,关系为1:m,题目已经说明违章信息包括用户和车辆,说明违章信息表中要记录用户和车辆,一个用户可以有多次违章记录,用户与违章记录关系为1:m,一辆车也可以有多次违章记录,车辆与违章记录关系也为1:m

create table user(
id int primary key,
  name varchar(20)
);
create table cars(
id int primary key,
  name varchar(20),
  user_id int,
  foreign key (user_id) references user(id)
);

create table info(
id int primary key,
  user_id int,
  cars_id int,
  foreign key (user_id) references user(id),
  foreign key (cars_id) references cars(id)
);

22、设计一个学校食堂管理系统 

学校食堂管理系统,包含食堂表,食堂仓口表,仓口收费记录表

-- 一个食堂有多个仓口卖饭,关系为1:m,每个仓口卖饭可以有很多次,仓口与收费记录也是1:m

create table hall(
id int primary key,
  name varchar(20)
);
create table hall_opening(
id int primary key,
  name varchar(20),
  hall_id int,
  foreign key (hall_id) references hall(id)
);
create table info(
id int primary key,
  price int,
  info_date timestamp,
  hall_opening_id int,
  foreign key (hall_opening_id) references hall_opening(id)
);

23、有一张员工表emp,字段:姓名name,性别sex,部门depart,工资salary。查询以下数据:

1、查询男女员工的平均工资

2、查询各部门的总薪水

3、查询总薪水排名第二的部门

4、查询姓名重复的员工信息

5、查询各部门薪水大于10000的男性员工的平均薪水

1:select sex,avg(salary) from emp group by sex;

说明:平均值使用聚合函数avg,并且按照性别男女分组,group by 性别字段

2:select depart,sum(salary) from emp group by depart;

说明:总薪水使用聚合函数sum取薪水字段求和,并且按照部门字段分组,group by 部门字段

3:select depart,sum(salary) from emp group by depart order by sum(salary) desc limit 1,1;

说明:order by语句先按照总薪水排序,之后取第二条数据,可以使用分页,每一页1条数据,第二页就是该结果

4:select name from emp group by name having count(name)>1;

说明:名字重复,说明同一个名字有多条数据,可以先按照名字分组,分组之后再过滤行数大于1的,就表示同一个名字至少有2条记录,重复了

5:select depart,avg(salary) from emp where salary>10000 and sex='男' group by depart;

说明:这里需要注意题目要求是查询薪水大于10000的男性员工,这个是在按部门分组前就过滤,在过滤后的结果集中再查询各个部门的平均薪水

24、写出以下数据库的查询条件【交大思诺2020届校招笔试题】

有两个表分别如下:

表A(varchar(32) name, int grade)

数据:zhangshan 80, lisi 60, wangwu 84

表B(varchar(32) name, int age)

数据:zhangshan 26, lisi 24, wangwu 26, wutian 26

写SQL语句得到如下查询结果:

| NAME   | GRADE | AGE |

| --------- | ----- | ---- |

| zhangshan | 80  | 26  |

| lisi   | 60  | 24  |

| wangwu  | 84  | 26  |

| wutian  | null | 26  |

SELECT
B.NAME,
A.grade,
B.age 
FROM
B left join A
ON
A.NAME = B.NAME

 说明:主要考察使用关联查询时需要使用内联还是外联,这里wutian再A表中没有记录,但还是需要返回结果,所以应该将B表作为外表进行外连接查询

25、有员工表、部门表和薪资表,根据查询条件写出对应的sql【同程艺龙2020届校招笔试题】

现在有员工表、部门表和薪资表。部门表depart的字段有depart_id, name;员工表 staff 的字段有 staff_id, name, age, depart_id;薪资表salary 的字段有 salary_id,staff_id,salary,month。

(问题a):求每个部门'2016-09'月份的部门薪水总额

(问题b):求每个部门的部门人数,要求输出部门名称和人数

(问题c):求公司每个部门的月支出薪资数,要求输出月份和本月薪资总数

(问题a):求每个部门'2016-09'月份的部门薪水总额

SELECT
dep.NAME,
sum( sal.salary ) 
FROM
salary sal
JOIN staff sta ON sal.staff_id = sta.staff_id
JOIN depart dep ON sta.depart_id = dep.depart_id 
WHERE
YEAR ( sal.MONTH ) = 2016 
AND MONTH ( sal.MONTH ) = 9 
GROUP BY
dep.depart_id

说明:
mysql中年和月的函数分别是year(字段),month(字段)
查询要求的是每个部门的信息,所以要按照部门进行分组,部门和员工为1:m,员工与薪水为1:m,查询要求有部门,有薪水,所以必须关联3张表查询

(问题b):求每个部门的部门人数,要求输出部门名称和人数

SELECT
dep.NAME,
count( sta.staff_id ) 
FROM
staff sta
JOIN depart dep ON dep.depart_id = sta.depart_id 
GROUP BY
sta.depart_id

说明:查询要求的信息有部门,有人数,人数只能从员工表中获取,所以关联表为部门表/员工表。按照部门id分组查询员工id的行数

(问题c):求公司每个部门的月支出薪资数,要求输出月份和本月薪资总数

SELECT
dep.NAME,
sal.MONTH,
sum( sal.salary ) 
FROM
depart dep
JOIN staff sta ON dep.depart_id = sta.depart_id
JOIN salary sal ON sta.staff_id = sal.staff_id 
GROUP BY
dep.depart_id,
sal.MONTH

说明:按照题目要求,查询信息有部门/月/每个部门每月薪资总额,其中薪水信息再薪水表中,每个员工可以有多条薪资记录(不同时间)。所以需要按照部门分组,再按照月份分组,查询分组的部门在不同月份下的总薪水

26、编写一个SQL查询,获取Employee表中第二高的薪水(Salary)

+-----+-------+

| Id | Salary|

+-----+-------+

| 1  | 100 |

+-----+-------+

| 2  | 200 |

+-----+-------+

| 3  | 300 |

+-----+-------+

例如上述Employee表,SQL查询应该返回200作为第二高的薪水。如果不存在第二高的薪水,那么查询应该返回null。

+---------------------+

| SecondHighestSalary |

+---------------------+

|    200     |

+---------------------+

select ifnull((select Salary from Employee order by Salary desc limit 1,1),null ) as SecondHighestSalary;

 说明:先查询最高的薪水,然后适用ifnull,如果没有就返回null

27、使用UNION语句查询

已知T1和T2的字段定义完全相同,T1有5条不同数据,T2有5条不同数据,其中T1有2条数据存在表T2中,使用UNION语句查询这些数据,要求重复数据不出现

SELECT * FROM T1 UNION SELECT * FROM T2

说明:union不能出现重复,union all会出现重复数据。根据题目要求使用union

28、有一个图书管理系统,请根据要求写出对应的sql

有一个图书管理系统,包含学生和图书信息,且图书可以进行分类,学生可以在一个时间范围内借阅图书,并在这个时间范围内归还图书。表和表关系如下:

DROP DATABASE IF EXISTS ebook;

CREATE DATABASE ebook CHARACTER SET 'utf8mb4';

USE ebook;

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

-- Table structure for category

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

DROP TABLE IF EXISTS category;

CREATE TABLE category (

 id int(11) PRIMARY KEY AUTO_INCREMENT,

 name varchar(20)

);

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

-- Records of category

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

INSERT INTO category VALUES (1, '历史');

INSERT INTO category VALUES (2, '艺术');

INSERT INTO category VALUES (3, '计算机');

INSERT INTO category VALUES (4, '数学');

INSERT INTO category VALUES (5, '小说');

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

-- Table structure for student

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

DROP TABLE IF EXISTS student;

CREATE TABLE student (

 id int(11) PRIMARY KEY AUTO_INCREMENT,

 name varchar(20)

);

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

-- Records of student

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

INSERT INTO student VALUES (1, '王昭君');

INSERT INTO student VALUES (2, '李白');

INSERT INTO student VALUES (3, '貂蝉');

INSERT INTO student VALUES (4, '小乔');

INSERT INTO student VALUES (5, '韩信');

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

-- Table structure for book

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

DROP TABLE IF EXISTS book;

CREATE TABLE book (

 id int(11) PRIMARY KEY AUTO_INCREMENT,

 name varchar(20),

 author varchar(20),

 price decimal(10, 2),

 category_id int(11),

 CONSTRAINT fk_book_category_id FOREIGN KEY (category_id) REFERENCES category (id)

);

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

-- Records of book

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

INSERT INTO book VALUES (1, '深入理解Java虚拟机', '周志明', 57.90, 3);

INSERT INTO book VALUES (2, '西游记', '吴承恩', 30.68, 5);

INSERT INTO book VALUES (3, '儒林外史', '吴敬梓', 18.80, 5);

INSERT INTO book VALUES (4, '聊斋志异', '蒲松龄', 21.00, 5);

INSERT INTO book VALUES (5, '史记', '司马迁', 278.20, 1);

INSERT INTO book VALUES (6, '资治通鉴', '司马光', 524.00, 1);

INSERT INTO book VALUES (7, 'Java核心技术 卷I:基础知识', 'Cay S. Horstmann', 92.50, 3);

INSERT INTO book VALUES (8, 'Java核心技术卷II:高级特性', 'Cay S. Horstmann', 111.20, 3);

INSERT INTO book VALUES (9, 'Java多线程编程核心技术', '高洪岩', 47.50, 3);

INSERT INTO book VALUES (10, '诗经', '孔子', 22.00, 2);

INSERT INTO book VALUES (11, '唐诗三百首', '蘅塘居士', 49.30, 2);

INSERT INTO book VALUES (12, '唐诗三百首', '蘅塘居士', 55.00, 2);

INSERT INTO book VALUES (13, '西游记', '吴承恩', 47.50, 5);

INSERT INTO book VALUES (14, '唐诗三百首', '蘅塘居士', 56.50, 2);

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

-- Table structure for borrow_info

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

DROP TABLE IF EXISTS borrow_info;

CREATE TABLE borrow_info (

 id int(11) PRIMARY KEY AUTO_INCREMENT,

 book_id int(11),

 student_id int(11),

 start_time timestamp null,

 end_time timestamp null,

 CONSTRAINT fk_borrow_info_book_id FOREIGN KEY (book_id) REFERENCES book (id),

 CONSTRAINT fk_borrow_info_student_id FOREIGN KEY (student_id) REFERENCES student (id)

);

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

-- Records of borrow_info

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

INSERT INTO borrow_info VALUES (1, 1, 1, '2018-11-07 18:50:43', '2018-12-07 18:51:01');

INSERT INTO borrow_info VALUES (2, 7, 1, '2019-07-10 10:21:00', '2019-09-10 10:21:00');

INSERT INTO borrow_info VALUES (3, 8, 1, '2019-09-10 10:21:00', '2019-10-10 10:21:00');

INSERT INTO borrow_info VALUES (4, 2, 2, '2019-03-02 16:37:00', '2019-04-02 16:37:00');

INSERT INTO borrow_info VALUES (5, 4, 2, '2019-03-12 14:25:00', '2019-04-12 14:25:00');

INSERT INTO borrow_info VALUES (6, 10, 2, '2019-07-13 16:21:00', '2019-10-13 16:21:00');

INSERT INTO borrow_info VALUES (7, 11, 2, '2019-06-09 09:40:00', '2019-07-09 09:40:00');

INSERT INTO borrow_info VALUES (8, 13, 2, '2019-01-03 15:11:00', '2019-04-03 15:11:00');

INSERT INTO borrow_info VALUES (9, 7, 3, '2019-05-15 13:13:00', '2019-06-15 13:13:00');

INSERT INTO borrow_info VALUES (10, 8, 3, '2019-04-27 13:53:00', '2019-05-27 13:53:00');

INSERT INTO borrow_info VALUES (11, 9, 3, '2019-06-01 11:32:00', '2019-07-01 11:32:00');

INSERT INTO borrow_info VALUES (12, 3, 4, '2019-07-01 09:40:00', '2019-08-01 09:40:00');

INSERT INTO borrow_info VALUES (13, 4, 4, '2019-06-19 11:40:00', '2019-07-19 11:40:00');

INSERT INTO borrow_info VALUES (14, 5, 4, '2019-06-25 09:23:00', '2019-09-25 09:23:00');

INSERT INTO borrow_info VALUES (15, 10, 4, '2019-08-27 15:30:00', '2019-09-27 15:30:00');

INSERT INTO borrow_info VALUES (16, 5, 5, '2019-01-23 14:20:00', '2019-04-23 14:20:00');

INSERT INTO borrow_info VALUES (17, 6, 5, '2019-03-09 10:45:00', '2019-04-09 10:45:00');

INSERT INTO borrow_info VALUES (18, 10, 5, '2019-06-17 11:32:00', '2019-09-17 11:32:00');

要求:

1. 新增貂蝉同学的借阅记录:诗经,从2019年9月25日17:50到2019年10月25日17:50

2. 查询计算机分类下的图书借阅信息

3. 修改图书《深入理解Java虚拟机》的价格为61.20

4. 删除id最大的一条借阅记录

 1. 新增貂蝉同学的借阅记录:诗经,从2019年9月25日17:50到2019年10月25日17:50

首先创建数据库JDBC工具类

package com.bit.util;
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
import javax.sql.DataSource;
import java.sql.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class Util {
//使用连接池
  private static final DataSource DATA_SOURCE    = new MysqlDataSource();
  static {
    ((MysqlDataSource) DATA_SOURCE).setUrl("jdbc:mysql://localhost:3306/book");
    ((MysqlDataSource) DATA_SOURCE).setUser("root");
    ((MysqlDataSource) DATA_SOURCE).setPassword("root");
  }
  public static void main(String[] args) {
    System.out.println(getConnection());
  }
// 获取数据库连接
  public static Connection getConnection(){
    try {
      return DATA_SOURCE.getConnection();
    } catch (SQLException e) {
      throw new RuntimeException("获取数据库连接失败", e);
    }
  }
// 释放资源
  public static void close(ResultSet resultSet, Statement statement,
               Connection connection){
      try {
        if(resultSet != null) {
          resultSet.close();
        }
       if(statement != null){
          statement.close();
        }
        if(connection != null){
          connection.close();
        }
      } catch (SQLException e) {
       throw new RuntimeException("数据库操作异常", e);
      }
  }

//日期字符串转Java日期类Date和sql时间戳Timestamp
  public static Timestamp getTimestamp(String dateString){
    try {
     // 年-月-日 小时:分钟:秒
      java.util.Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateString);
      return new java.sql.Timestamp(date.getTime());
    } catch (ParseException e) {
     throw new RuntimeException("日期格式化错误:"+dateString, e);
    }
  }
}
package com.bit.book;
import com.bit.util.Utill
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class AddBorrow {
  /**
   * 新增貂蝉同学的借阅记录:诗经,从2019年9月25日17:50到2019年10月25日17:50
   */
  public static void main(String[] args) {
   //1.创建数据库连接对象
    Connection connection = null;
    //2.创建操作命令对象
    PreparedStatement preparedStatement = null;
    try {
      connection = Util.getConnection();
      String sql = "insert into borrow_info(book_id, student_id," +
          " start_time, end_time) select b.id,s.id,?,?" +
          " from book b,student s where b.name=? and s.name=?";
      preparedStatement = connection.prepareStatement(sql);
      preparedStatement.setTimestamp(1, Util.getTimestamp("2019-09-25 17:50:00"));
      preparedStatement.setTimestamp(2, Util.getTimestamp("2019-10-25 17:50:00"));
      preparedStatement.setString(3, "诗经");
      preparedStatement.setString(4, "貂蝉");
      System.out.println(preparedStatement);
      //3.执行sql
      int result = preparedStatement.executeUpdate();
      System.out.println(result);
    } catch (SQLException e) {
      e.printStackTrace();
    } finally {
     //4.释放资源
      Util.close(null, preparedStatement, connection);
    }
  }
}

2. 查询计算机分类下的图书借阅信息

package com.bit.book;
import com.bit.util.Util;
import java.sql.*;
public class QueryBorrow {
  /**
   * 查询计算机分类下的图书借阅信息
   * @param args
   */
  public static void main(String[] args) {
    Connection    connection    = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    try {
      connection = Util.getConnection();
      String sql = "SELECT bk.NAME book_name,bk.author book_author," +
          "s.NAME student_name,bi.start_time,bi.end_time" +
          " FROM borrow_info bi JOIN book bk ON bi.book_id = bk.id" +
          " JOIN category c ON bk.category_id = c.id" +
          " JOIN student s ON bi.student_id = s.id" +
          " WHERE c.NAME = ?";
      preparedStatement = connection.prepareStatement(sql);
      preparedStatement.setString(1, "计算机");
      resultSet = preparedStatement.executeQuery();
      while(resultSet.next()){
        String  bookName  = resultSet.getString("book_name");
        String  bookAuthor = resultSet.getString("book_author");
        String  studentName = resultSet.getString("student_name");
        Timestamp startTime  = resultSet.getTimestamp("start_time");
        Timestamp  endTime   = resultSet.getTimestamp("end_time");
        System.out.println(String.format("书名:%s,作者:%s,借阅者:%s," +
            "借阅起始日期:%s,结束日期:%s",
            bookName, bookAuthor, studentName, startTime, endTime));
      }
    } catch (SQLException e) {
      e.printStackTrace();
    } finally {
      Util.close(resultSet, preparedStatement, connection);
    }
  }
}

3. 修改图书《深入理解Java虚拟机》的价格为61.20

package com.bit.book;



import com.bit.util.Util;



import java.math.BigDecimal;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;



public class UpdateBook {



  /**

   * 修改图书《深入理解Java虚拟机》的价格为61.20

   */

  public static void main(String[] args) {

    Connection    connection    = null;

    PreparedStatement preparedStatement = null;

    try {

      connection = Util.getConnection();

      String sql = "update book set price=? where name =?";

      preparedStatement = connection.prepareStatement(sql);

      preparedStatement.setBigDecimal(1, new BigDecimal("61.20"));

      preparedStatement.setString(2, "深入理解Java虚拟机");

      System.out.println(preparedStatement);

      int result = preparedStatement.executeUpdate();

      System.out.println(result);

    } catch (SQLException e) {

      e.printStackTrace();

    } finally {

      Util.close(null, preparedStatement, connection);

    }

  }

}

4. 删除id最大的一条借阅记录

package com.bit.book;



import com.bit.util.Util;



import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;



public class DeleteBorrow {



  /**

   * 删除id最大的一条借阅记录

   */

  public static void main(String[] args) {

    Connection    connection    = null;

    PreparedStatement preparedStatement = null;

    try {

      connection = Util.getConnection();

      String sql = "delete from borrow_info where id =" +

          "(select r.id from (select max(id) id from borrow_info) r)";

      preparedStatement = connection.prepareStatement(sql);

      int result = preparedStatement.executeUpdate();

      System.out.println(result);

    } catch (SQLException e) {

      e.printStackTrace();

    } finally {

      Util.close(null, preparedStatement, connection);

    }

  }

}

29、编写代码, 实现创建线程的五种写法

  1. 继承 Thread, 重写 run
  2. 实现 Runnable, 重写 run
  3. 继承 Thread, 重写 run, 使用匿名内部类
  4. 实现 Runnable, 重写 run, 使用匿名内部类
  5. 使用 lambda 表达式

通过继承Thread类并实现run方法创建一个线程

// 定义一个Thread类,相当于一个线程的模板
class MyThread01 extends Thread {
    // 重写run方法// run方法描述的是线程要执行的具体任务@Overridepublic void run() {
        System.out.println("hello, thread.");
    }
}
 
/**
 * 继承Thread类并重写run方法创建一个线程
 * @author  比特就业课
 * @created 2022-06-20
 */
public class Thread_demo01 {
    public static void main(String[] args) {
        // 实例化一个线程对象
        MyThread01 t = new MyThread01();
        // 真正的去申请系统线程,参与CPU调度
        t.start();
    }
}

通过实现Runnable接口,并实现run方法的方法创建一个线程

// 创建一个Runnable的实现类,并实现run方法
// Runnable主要描述的是线程的任务
class MyRunnable01 implements Runnable {
    @Overridepublic void run() {
        System.out.println("hello, thread.");
    }
}
/**
 * 通过继承Runnable接口并实现run方法
 * @author  比特就业课
 * @created 2022-06-20
 */
public class Thread_demo02 {
    public static void main(String[] args) {
        // 实例化Runnable对象
        MyRunnable01 runnable01 = new MyRunnable01();
        // 实例化线程对象并绑定任务
        Thread t = new Thread(runnable01);
        // 真正的去申请系统线程参与CPU调度
        t.start();
    }
}

通过Thread匿名内部类创建一个线程

/**
 * 通过Thread匿名内部类的方法创建一个线程
 * @author 比特就业课
 * @created 2022-06-20
 */
public class Thread_demo03 {public static void main(String[] args) {
        Thread t = new Thread(){
            // 指定线程任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        // 真正的申请系统线程参与CPU调度
        t.start();
    }
}

通过Runnable匿名内部类创建一个线程

/**
 * 通过Runnable匿名内部类创建一个线程
 * @author 比特就业课
 * @created 2022-06-20
 */
public class Thread_demo04 {public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            // 指定线程的任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());                
            }
        });
        // 申请系统线程参与CPU调度
        t.start();
    }
}

通过Lambda表达式的方式创建一个线程

/**
 * 通过Lambda表达式的方式创建一个线程
 * @author 比特就业课
 * @created 2022-06-20
 */
public class Thread_demo05 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // 指定任务:任务是循环打印当前线程名
            while (true) {
                System.out.println(Thread.currentThread().getName());
                try {
                    // 休眠1000ms
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 申请系统线程参与CPU调度
        t.start();
    }
}

30、编写代码, 实现多线程数组求和.

  1. 给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.
  2. 实现代码, 能够创建两个线程, 对这个数组的所有元素求和.
  3. 其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.
  4. 最终再汇总两个和, 进行相加
  5. 记录程序的执行时间.

/**
 * 题目名称 :
 * 编写代码, 实现多线程数组求和.
 * 题目内容 :
 * 1. 给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.
 * 2. 实现代码, 能够创建两个线程, 对这个数组的所有元素求和.
 * 3. 其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.
 * 4. 最终再汇总两个和, 进行相加
 * 5. 记录程序的执行时间.
 *
 * @author 比特就业课
 * @created 2022-06-20
 *
 */
public class Thread_2533 {
    public static void main(String[] args) throws InterruptedException {
        // 记录开始时间
        long start = System.currentTimeMillis();
 
        // 1. 给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.
        int total = 1000_0000;
        int [] arr = new int[total];
        // 构造随机数,填充数组
        Random random = new Random();
        for (int i = 0; i < total; i++) {
            int num = random.nextInt(100) + 1;
            arr[i] = num;
        }
 
 
        // 2. 实现代码, 能够创建两个线程, 对这个数组的所有元素求和.
        // 3. 其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.
        // 实例化操作类
        SumOperator operator = new SumOperator();
        // 定义具体的执行线程
        Thread t1 = new Thread(() -> {
            // 遍历数组,累加偶数下标
            for (int i = 0; i < total; i += 2) {
                operator.addEvenSum(arr[i]);
            }
        });
 
        Thread t2 = new Thread(() -> {
            // 遍历数组,累加奇数下标
            for (int i = 1; i < total; i += 2) {
                operator.addOddSum(arr[i]);
            }
        });
 
        // 启动线程
        t1.start();
        t2.start();
        // 等待线程结束
        t1.join();
        t2.join();
 
        // 记录结束时间
        long end = System.currentTimeMillis();
        // 结果
        System.out.println("结算结果为 = " + operator.result());
        System.out.println("总耗时 " + (end - start) + "ms.");
    }
}
 
// 累加操作用这个类来完成
class SumOperator {
    long evenSum;
    long oddSum;
 
    public void addEvenSum (int num) {
        evenSum += num;
    }
 
    public void addOddSum (int num) {
        oddSum += num;
    }
 
    public long result() {
        System.out.println("偶数和:" + evenSum);
        System.out.println("奇数和:" + oddSum);
        return evenSum + oddSum;
    }
}
 
 

31、在子线程执行完毕后再执行主线程代码

有20个线程,需要同时启动。每个线程按0-19的序号打印,如第一个线程需要打印0。请设计代码,在main主线程中,等待所有子线程执行完后,再打印 ok

public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[20];
        for(int i=0; i<20; i++){
            final int n = i;
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {//内部类使用外部的变量,必须是final修饰
                    System.out.println(n);
                }
            });
        }
        for(Thread t : threads){
            t.start();
        }
        for(Thread t : threads){//同时执行20个线程,再等待所有线程执行完毕
            t.join();
        }
        System.out.println("OK");
    }

 32、请说明Thread类中run和start的区别

从方法的区别,及运行结果的区别分别说明

作用功能不同:

  1. run方法的作用是描述线程具体要执行的任务;
  2. start方法的作用是真正的去申请系统线程

运行结果不同:

  1. run方法是一个类中的普通方法,主动调用和调用普通方法一样,会顺序执行一次;
  2. start调用方法后, start方法内部会调用Java 本地方法(封装了对系统底层的调用)真正的启动线程,并执行run方法中的代码,run 方法执行完成后线程进入销毁阶段。

33、

34、

35、

36、

37、

38、

39、

40、

41、

42、

43、

44、

45、

46、

47、

48、

49、

50、