学习笔记三 2022.11.03~06

别问,问就是搞毕设去了~,本专业不是学java的

1.集合框架复习

* 集合框架复习:
*               Collection接口                     map接口
*         |                   \             |       \          \
*      list接口              set接口      HashMap   HashTable    TreeMap
*   |         \            |       \        |           \
* ArrayList LinkedList  TreeSet  HashSet LinkedHashMap  Properties
*
* ArrayList初始容量是10,我们也可以初始给定长度
* 扩容:1.5倍扩容 10=>15=>22  5=>7=>10
* 1.创建一个新的数组 
* 2.使用Arrays.copyof()方法把旧数组copy过去
* 3.添加新元素
* 底层是Object的数组elementData
*
* LinkedList是维护的是双向链表数据结构
*
* ArrayList和LinkedList区别?
* 1.底层不同.ArrayList是数组 LinkedList是双向链表
* 2.ArrayList增删慢,改查快LinkedList增删快,改查慢
*
* list接口下集合的特点?
* 1.可以存放null,且可以存放多个
* 2.存储元素有序
* 
* list和set区别?
* 1.list集合存储有序,元素可以重复，有索引
* 2.set集合元素不重复,无索引
*
* list接口下还有个Vector集合，线程同步,效率比ArrayList集合低
* 其余基本和ArrayList集合相同,初始容量是10,扩容为原来两倍,底层为elementData()数组

有错误欢迎指正啊~

2022.11.05

开始学瑞吉外卖

创建reggie数据库，建表。

创建maven工程通过导入springboot父工程坐标,和对应依赖建立

坐标:springboot mybatis lombok fastjson commons-lang mysql druid

2022.11.06

补了下lambda表达式

1.lambda表达式,函数式接口

*  java内置四大核心(基本)函数式接口:
 *  1.消费型接口 Consumer<T> void accept(T t)没有返回值
 *  2.供给型接口 Supplier<T> T get() 无参也有返回值
 *  3.函数型接口 Function<T,R> 有参也有返回值而且类型可以不同
 *  4.断定型接口 Predicate<T> boolean test(T t)传入参数返回布尔型
 **/
public class LambdaTest2 {
    public static void main(String[] args) {
        //传统方式
        t1(5.88, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("去消费"+aDouble);
            }
        });

        System.out.println("==============");
        //lambda
        t1(400,money -> System.out.println("消费"+money));

        //传统
        List<String> list = Arrays.asList("北京","天津","南京","普京");
        List<String> list1 = t2(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(list1);

        //lambda
        List<String> list2 = t2(list,s -> s.contains("京"));
        System.out.println(list2);

    }

2.方法引用,构造器引用,数组引用

/**
 * 方法引用:已经有方法实现了接口,且形参和返回值类型相同
 * 1.对象::非静态方法
 * 2.类::静态方法
 *
 * 3.类::非静态方法(*)
 */
Consumer<String> consumer1 = System.out :: println;
consumer1.accept("KunShan");
System.out.println("=================");
PrintStream ps = System.out;
Consumer<String> consumer2 = ps :: println;
consumer2.accept("JiangSu");

new Thread(() ->System.out.println("开启线程...")).start();
System.out.println("主线程...");

User user = new User("张三",20,"四川");
Supplier<String> supplier = user::getName;
System.out.println(supplier.get());

/**
 * 2.对象::静态方法
 * Comparator的compare方法传入俩参数,返回一个int类型
 * Integer的compare方法也是传入俩参数,返回一个int类型
 * 所以Comparator实例可以引用Integer的compare方法(形参列表可以省)
 */
Comparator<Integer> comparator = ((o1, o2) -> Integer.compare(o1,o2));
System.out.println(comparator.compare(11, 12));

Comparator<Integer> comparator1 = Integer::compare;
System.out.println(comparator1.compare(12, 11));

System.out.println("=========");

Function<Double,Long> fun = d -> Math.round(d);
System.out.println(fun.apply(12.1));

Function<Double,Long> fun1 = Math :: round;
System.out.println(fun1.apply(10.6));

/**
 *  3.类::非静态方法(*)
 */
Comparator<String> c1 = (o1, o2) -> o1.compareTo(o2);
System.out.println(c1.compare("abc", "abz"));
Comparator<String> c2 = String::compareTo;
System.out.println(c2.compare("avc", "avz"));

3.瑞吉外卖后台员工登录(MP)

<1>

根据前端传过来的用户名,调用service层对象查询数据库(getOne方法)

注意接收参数为HttpServletRequest request, @RequestBody Employee employee即登录时需要将员工id存入session

<2>

查到的账号为空则返回

<3>

查到的状态为被禁用则返回

<4>

对employee参数密码MD5加密(DigestUtils.md5DigestAsHex方法),并和数据库密码比对,不对则返回

<5>

密码正确,把id存入session,返回正确的响应

/**
 * 员工登录
 *
 * @param request  前端请求
 * @param employee 前端请求携带的employee
 * @return
 */
@PostMapping("/login")
public R<Employee> login(HttpServletRequest request, @RequestBody Employee employee) {
    //1.对传过来的密码MD5加密
    String password = employee.getPassword();
    password = DigestUtils.md5DigestAsHex(password.getBytes());

    //2.对用户名进行校验
    LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(Employee::getUsername, employee.getUsername());
    Employee emp = employeeService.getOne(queryWrapper);

    //3.没有查询到返回登陆失败
    if (emp == null) {
        return R.error("登陆失败");
    }

    //4.密码进行校验
    if (!password.equals(emp.getPassword())) {
        return R.error("登陆失败");
    }

    //5.对账号状态进行校验
    if (emp.getStatus() == 0) {
        return R.error("账号被禁用");
    }

    //6.登录成功,把员工id放入session返回前端
    request.getSession().setAttribute("emp", emp.getId());
    return R.success(emp);
}