0%

Day4

前言

最近这几天忙着毕业设计的中期答辩和一些形式工作,昨天和今天刚刚抽出时间来学习进厂知识,昨天刷了力扣的几道数组题,今天继续刷了链表的部分题,还有就是看了看外卖项目内容,感觉进度艰难,一些地方听不懂,而且学习的不系统,所以打算写完上次课的项目内容,从下次开始先暂停一下项目内容,先把基础的框架学一下,在JavaWeb开发篇中学习基础框架包括但不限于:SpringBoot、MySQL、Mybatis等,先把基础的框架弄明白,可能再去看项目会收获更大。

项目开发

接着上次,写完了新增员工,该写员工分页查询了

员工分页查询

产品原型

查询员工原型:

image-20221111215309289

业务规则:

  • 根据页码展示员工信息
  • 每页展示10条数据
  • 分页查询时可以根据需要,输入员工姓名进行查询

代码开发

1.设置数据类型——DTO类(主要是数据类型,类的参数),封装PageResult,后面所有的分页查询,统一都封装为PageResult对象

根据请求参数进行封装,在sky-pojo模块中

在sky-common模块,封装PageResult对象,参数为

1
2
private long total; //总记录数
private List records; //当前页数据集合

员工信息分页查询后端返回的对象类型为: Result

2.Controller、Service、Mapper层实现

在sky-server模块中,com.sky.controller.admin.EmployeeController中添加分页查询方法。

1
2
3
4
5
6
7
8
9
10
11
12
/**
* 员工分页查询
* @param employeePageQueryDTO
* @return
*/
@GetMapping("/page")
@ApiOperation("员工分页查询")
public Result<PageResult> page(EmployeePageQueryDTO employeePageQueryDTO){
log.info("员工分页查询,参数为:{}", employeePageQueryDTO);
PageResult pageResult = employeeService.pageQuery(employeePageQueryDTO);//后续定义
return Result.success(pageResult);
}

在EmployeeService接口中声明pageQuery方法:

1
2
3
4
5
6
/**
* 分页查询
* @param employeePageQueryDTO
* @return
*/
PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO);

接口声明以后要实现:

在EmployeeServiceImpl中实现pageQuery方法:

在EmployeeServiceImpl中实现pageQuery方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* 分页查询
*
* @param employeePageQueryDTO
* @return
*/
public PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO) {
// select * from employee limit 0,10
//开始分页查询
PageHelper.startPage(employeePageQueryDTO.getPage(), employeePageQueryDTO.getPageSize());

Page<Employee> page = employeeMapper.pageQuery(employeePageQueryDTO);//后续定义

long total = page.getTotal();
List<Employee> records = page.getResult();

return new PageResult(total, records);
}

注意:此处使用 mybatis 的分页插件 PageHelper 来简化分页代码的开发(在pom.xml文中添加依赖),底层基于 mybatis 的拦截器实现。

Mapper层:

在 EmployeeMapper 中声明 pageQuery 方法:

1
2
3
4
5
6
/**
* 分页查询
* @param employeePageQueryDTO
* @return
*/
Page<Employee> pageQuery(EmployeePageQueryDTO employeePageQueryDTO);

在 src/main/resources/mapper/EmployeeMapper.xml 中编写SQL:

1
2
3
4
5
6
7
8
9
<select id="pageQuery" resultType="com.sky.entity.Employee">
select * from employee
<where>
<if test="name != null and name != ''">
and name like concat('%',#{name},'%')
</if>
</where>
order by create_time desc
</select>

代码完善

发现问题:

  1. 在前后端联调和Swagger测试(接口文档)时,发现操作时间格式不正确,

解决方式:

1). 方式一

在属性上加上注解,对日期进行格式化

image-20221112103501581

但这种方式,需要在每个时间属性上都要加上该注解,使用较麻烦,不能全局处理。

2). 方式二(推荐 )

在WebMvcConfiguration中扩展SpringMVC的消息转换器,统一对所有的日期类型进行格式处理

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 扩展Spring MVC框架的消息转化器
* @param converters
*/
protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
log.info("扩展消息转换器...");
//创建一个消息转换器对象
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
//需要为消息转换器设置一个对象转换器,对象转换器可以将Java对象序列化为json数据
converter.setObjectMapper(new JacksonObjectMapper());
//将自己的消息转化器加入容器中,设置index为0,优先级很高
converters.add(0,converter);
}

添加后,再次测试,发现日期正常

启用/禁用员工账号

代码开发

启禁用员工原型:

image-20221112112359233

业务规则:

  • 可以对状态为“启用” 的员工账号进行“禁用”操作
  • 可以对状态为“禁用”的员工账号进行“启用”操作
  • 状态为“禁用”的员工账号不能登录系统

1.Controller层

在sky-server模块中,根据接口设计中的请求参数形式对应的在 EmployeeController 中创建启用禁用员工账号的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 启用禁用员工账号
* @param status
* @param id
* @return
*/
@PostMapping("/status/{status}")
@ApiOperation("启用禁用员工账号")
public Result startOrStop(@PathVariable Integer status,Long id){
log.info("启用禁用员工账号:{},{}",status,id);
employeeService.startOrStop(status,id);//后绪步骤定义
return Result.success();
}

2.Service层接口和实现类

在 EmployeeService 接口中声明启用禁用员工账号的业务方法:

1
2
3
4
5
6
/**
* 启用禁用员工账号
* @param status
* @param id
*/
void startOrStop(Integer status, Long id);

在 EmployeeServiceImpl 中实现启用禁用员工账号的业务方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
* 启用禁用员工账号
*
* @param status
* @param id
*/
public void startOrStop(Integer status, Long id) {
Employee employee = Employee.builder()
.status(status)
.id(id)
.build();

employeeMapper.update(employee);
}

3.Mapper层

在 EmployeeMapper 接口中声明 update 方法:

1
2
3
4
5
/**
* 根据主键动态修改属性
* @param employee
*/
void update(Employee employee);

在 EmployeeMapper.xml 中编写SQL:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<update id="update" parameterType="Employee">
update employee
<set>
<if test="name != null">name = #{name},</if>
<if test="username != null">username = #{username},</if>
<if test="password != null">password = #{password},</if>
<if test="phone != null">phone = #{phone},</if>
<if test="sex != null">sex = #{sex},</if>
<if test="idNumber != null">id_Number = #{idNumber},</if>
<if test="updateTime != null">update_Time = #{updateTime},</if>
<if test="updateUser != null">update_User = #{updateUser},</if>
<if test="status != null">status = #{status},</if>
</set>
where id = #{id}
</update>

编辑员工信息

代码开发

修改页面原型:

注:点击修改时,数据应该正常回显到修改页面。

image-20221112144842825

1.回显员工信息功能

1). Controller层

在 EmployeeController 中创建 getById 方法:

1
2
3
4
5
6
7
8
9
10
11
/**
* 根据id查询员工信息
* @param id
* @return
*/
@GetMapping("/{id}")
@ApiOperation("根据id查询员工信息")
public Result<Employee> getById(@PathVariable Long id){
Employee employee = employeeService.getById(id);
return Result.success(employee);
}

通过id查询

2). Service层接口和实现类

在 EmployeeService 接口中声明 getById 方法:

1
2
3
4
5
6
/**
* 根据id查询员工
* @param id
* @return
*/
Employee getById(Long id);

在 EmployeeServiceImpl 中实现 getById 方法:

1
2
3
4
5
6
7
8
9
10
11
/**
* 根据id查询员工
*
* @param id
* @return
*/
public Employee getById(Long id) {
Employee employee = employeeMapper.getById(id);
employee.setPassword("****");
return employee;
}

3). Mapper层

在 EmployeeMapper 接口中声明 getById 方法:通过注解实现

1
2
3
4
5
6
7
/**
* 根据id查询员工信息
* @param id
* @return
*/
@Select("select * from employee where id = #{id}")
Employee getById(Long id);

2 修改员工信息功能

1). Controller层

在 EmployeeController 中创建 update 方法:

1
2
3
4
5
6
7
8
9
10
11
12
/**
* 编辑员工信息
* @param employeeDTO
* @return
*/
@PutMapping
@ApiOperation("编辑员工信息")
public Result update(@RequestBody EmployeeDTO employeeDTO){
log.info("编辑员工信息:{}", employeeDTO);
employeeService.update(employeeDTO);
return Result.success();
}

2). Service层接口

在 EmployeeService 接口中声明 update 方法:

1
2
3
4
5
/**
* 编辑员工信息
* @param employeeDTO
*/
void update(EmployeeDTO employeeDTO);

3). Service层实现类

在 EmployeeServiceImpl 中实现 update 方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* 编辑员工信息
*
* @param employeeDTO
*/
public void update(EmployeeDTO employeeDTO) {
Employee employee = new Employee();
//因为是DTO类型的,需要把参数赋给employee
BeanUtils.copyProperties(employeeDTO, employee);

employee.setUpdateTime(LocalDateTime.now());
employee.setUpdateUser(BaseContext.getCurrentId());

employeeMapper.update(employee);
}

在实现启用禁用员工账号功能时,已实现employeeMapper.update(employee),在此不需写Mapper层代码,只需要传进去参数。

算法

数组篇

代码随想录 (programmercarl.com)

704.二分查找

力扣题目链接(opens new window)

给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。

思路

这道题目的前提是数组为有序数组,同时题目还强调数组中无重复元素,因为一旦有重复元素,使用二分查找法返回的元素下标可能不是唯一的,这些都是使用二分法的前提条件,当大家看到题目描述满足如上条件的时候,可要想一想是不是可以用二分法了。

对于二分法,需要定义mid的前后两个区间,区间的定义就是不变量。要在二分查找的过程中,保持不变量,就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作,这就是循环不变量规则。

写二分法,区间的定义一般为两种,左闭右闭即[left, right],或者左闭右开即[left, right)

  1. 区间的定义这就决定了二分法的代码应该如何写,因为定义target在[left, right]区间,所以有如下两点:
  • while (left <= right) 要使用 <= ,因为left == right是有意义的,所以使用 <=
  • if (nums[middle] > target) right 要赋值为 middle - 1,因为当前这个nums[middle]一定不是target,那么接下来要查找的左区间结束下标位置就是 middle - 1
  1. 如果说定义 target 是在一个在左闭右开的区间里,也就是[left, right) ,那么二分法的边界处理方式则截然不同。
  • while (left < right),这里使用 < ,因为left == right在区间[left, right)是没有意义的
  • if (nums[middle] > target) right 更新为 middle,因为当前nums[middle]不等于target,去左区间继续寻找,而寻找区间是左闭右开区间,所以right更新为middle,即:下一个查询区间不会去比较nums[middle]

代码

版本一:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public int search(int[] nums, int target) {
// 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
if (target < nums[0] || target > nums[nums.length - 1]) {
return -1;
}
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + ((right - left) >> 1);
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
left = mid + 1;
else if (nums[mid] > target)
right = mid - 1;
}
return -1;
}
}

版本二:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
public int search(int[] nums, int target) {
int left = 0, right = nums.length;
while (left < right) {
int mid = left + ((right - left) >> 1);
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
left = mid + 1;
else if (nums[mid] > target)
right = mid;
}
return -1;
}
}

27.移除元素

思路

力扣题目链接(opens new window)

给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。

不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

要知道数组的元素在内存地址中是连续的,不能单独删除数组中的某个元素,只能覆盖。

暴力破解:两层循环,一个for循环遍历数组元素 ,第二个for循环更新数组

双指针法:

双指针法(快慢指针法): 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

  • 快指针:寻找新数组的元素 ,新数组就是不含有目标元素的数组
  • 慢指针:指向更新 新数组下标的位置

很多同学这道题目做的很懵,就是不理解 快慢指针究竟都是什么含义,所以一定要明确含义,后面的思路就更容易理解了。

删除过程如下:

27.移除元素-双指针法

很多同学不了解

双指针法(快慢指针法)在数组和链表的操作中是非常常见的,很多考察数组、链表、字符串等操作的面试题,都使用双指针法。

代码

快慢指针法

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
public int removeElement(int[] nums, int val) {
// 快慢指针
int slowIndex = 0;
for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
if (nums[fastIndex] != val) {
nums[slowIndex] = nums[fastIndex];
slowIndex++;
}
}
return slowIndex;
}
}

相向指针法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//相向双指针法
class Solution {
public int removeElement(int[] nums, int val) {
int left = 0;
int right = nums.length - 1;
while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置
while(left <= right) {
if(nums[left] == val) { //left位置的元素需要移除
//将right位置的元素移到left(覆盖),right位置移除
nums[left] = nums[right];
right--;
}
left++;
while(right >= 0 && nums[right] == val) right--;
}
return left;
}
}

27.有序数组的平方

思路

力扣题目链接(opens new window)

给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。

暴力:每个数平方之后,排个序,代码如下:

双指针法:

数组其实是有序的, 只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端,不是最左边就是最右边,不可能是中间。此时可以考虑双指针法了,i指向起始位置,j指向终止位置。

定义一个新数组result,和A数组一样的大小,让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

从两端开始,太妙了

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
public int[] sortedSquares(int[] nums) {
int l = 0;
int r = nums.length - 1;
int[] res = new int[nums.length];
int j = nums.length - 1;
while(l <= r){
if(nums[l] * nums[l] > nums[r] * nums[r]){
res[j--] = nums[l] * nums[l++];
}else{
res[j--] = nums[r] * nums[r--];
}
}
return res;
}
}

若不从两端开始,从中间开始,找到第一个负数在哪里,向两端逐渐把最小的平方数放进结果数组,然后再把剩下的数组内容平方加到result中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Solution {
public int[] sortedSquares(int[] nums) {
//找到负数的第一个坐标
int n = nums.length;
int negative = -1;
for (int i = 0; i < n; ++i) {
if (nums[i] < 0) {
negative = i;
} else {
break;
}
}

int[] ans = new int[n];
int index = 0, i = negative, j = negative + 1;
while (i >= 0 || j < n) {
//理论上处理完一个指针,直接将剩下未处理的指针全部赋值即可,分两步
//以下思路是合并处理两步
if (i < 0) {
ans[index] = nums[j] * nums[j];
++j;
} else if (j == n) {
ans[index] = nums[i] * nums[i];
--i;
} else if (nums[i] * nums[i] < nums[j] * nums[j]) {
ans[index] = nums[i] * nums[i];
--i;
} else {
ans[index] = nums[j] * nums[j];
++j;
}
++index;
}

return ans;
}
}

34.在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums,和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target,返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

思路代码

直接解法:直接遍历所有内容,记录start和end,如果找到了目标值,找到第一个为此值的index为start值,一直遍历直到记最后一个为此value的index为end值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
public int[] searchRange(int[] nums, int target) {
int start = -1, end = -1;
//不能先使用nums[0],因为nums=[]就已经越界了
if(nums.length == 0 || nums[0] > target || nums[nums.length-1]< target)
return new int[]{start,end};
for (int i = 0; i < nums.length; i++) {
if(nums[i] == target){
end = i;
if(start == - 1){
start = i;
}
}
}
return new int[]{start,end};
}
}

二分:两次二分法分别寻找start和end,第一次二分寻找start,找到target以后,记此次index为start,同时,右端区间变成此时index左边的(右端向左缩),即区间右端不断向左缩达到二分,继续找左边有target的位置,一直到找到第一个;

第二次二分找end,因为是要找最左区间向右缩,找到任何一个target,将左区间继续向右走,一直到找到最后一个target

没找到target时与二分处理步骤一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class Solution {
public int[] searchRange(int[] nums, int target) {
int start = -1, end = -1;
//不能使用nums[0],因为nums=[]就已经越界了
if (nums.length == 0 || nums[0] > target || nums[nums.length - 1] < target)
return new int[]{start, end};
//寻找第一个位置,左区间不变,右区间一直在向左缩
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] == target) {
start = mid;
right = mid - 1;//核心,一直向左缩,直到找到第一个target位置
} else if (nums[mid] > target) {
right = mid - 1;
} else if (nums[mid] < target) {
left = mid + 1;
}
}
//寻找第二个位置,左区间一直向右靠
left = 0;
right = nums.length-1;
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] == target) {
end = mid;
left = mid + 1;//核心
} else if (nums[mid] > target) {
right = mid - 1;
} else if (nums[mid] < target) {
left = mid + 1;
}
}
return new int[]{start, end};
}
}

27.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组,并返回其长度。如果不存在符合条件的子数组,返回 0。

示例:

  • 输入:s = 7, nums = [2,3,1,2,4,3]
  • 输出:2
  • 解释:子数组 [4,3] 是该条件下的长度最小的子数组。

思路

暴力解法:这道题目暴力解法当然是 两个for循环,然后不断地寻找符合条件的子序列,时间复杂度很明显是O(n^2)。

双指针:(又为滑动窗口)

只用一个for循环,那么这个循环的索引,一定是表示 滑动窗口的终止位置。

  • 窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

  • 窗口的起始位置如何移动:如果当前窗口的值大于s了,窗口就要向0前移动了(也就是该缩小了)。

  • 窗口的结束位置如何移动:窗口的结束位置就是遍历数组的指针00,也就是for循环里的索引。

即看作是队列:

[2,3,1,2,4,3] 举例

image.png
image.png

数组内的一直入队出队:

起初一直入队,直到队列中的元素大于目标值了,记录此时的num数,才能出队

出队以后如果总和小于目标值了,继续入队下一个数组元素,直到大于目标值,取此时num和之前num较小者

直到所有数组元素完成,此时num就是最小长度的子数组

代码

快慢指针思想,是连续子数组,不是任意的数都可以

1
2
3
4
5
6
7
8
9
10
11
12
13
  class Solution {
public int minSubArrayLen(int target, int[] nums) {
int len = nums.length, slowIndex = 0, sum = 0, minLen = Integer.MAX_VALUE;
for (int fastIndex = 0; fastIndex < len; fastIndex++) {
sum += nums[fastIndex];
while (sum >= target) {
minLen = Math.min(minLen, fastIndex - slowIndex + 1);
sum -= nums[slowIndex++];
}
}
return minLen == Integer.MAX_VALUE ? 0 : minLen;
}
}