java学习---常用API、Lambda、常见算法

常用API、Lambda、常见算法学习大纲

日期与时间 data

代码使用

package com.peihj.date;



import java.util.Date;

public class Test {
    public static void main(String[] args) {
        // 创建一个时间类获取系统此刻日期时间对象
        Date d = new Date();
        System.out.println(d);  // Sat Feb 12 13:34:18 CST 2022

        // 获取时间毫秒值
        long time = d.getTime();
        System.out.println(time);  // 1644644160693

        long time1 = System.currentTimeMillis();
        System.out.println(time1);  // 1644644160693
        
        
    }
}

案例说明

代码说明

package com.peihj.date;



import java.util.Date;

public class Test {
    public static void main(String[] args) {
        // 创建一个时间类获取系统此刻日期时间对象
        Date d = new Date();
        System.out.println(d);  // Sat Feb 12 13:34:18 CST 2022


        long time2  = System.currentTimeMillis();
        time2 += (60*60 + 121)*1000;
        
        // 方法1
        Date d2 = new Date(time2);
        System.out.println(d2);
        
        // 方法2
        Date d3 = new Date();
        d3.setTime(time2);
        System.out.println(d3);
    }
}

小结

SimpleDateFormat

SimpleDateFormat的作用

格式化时间模板常用时间模板表达式如下

代码演示

package com.peihj.date;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test2 {
    public static void main(String[] args) {
        // 创建日期对象
        Date d = new Date();
        System.out.println(d);

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

        // 格式化日期对象按照我们想的形式输出
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        String rs = sdf.format(d);
        System.out.println(rs);

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

        // 格式化时间毫秒值
        // 需求：求121秒之后的时间是多少
        long times = System.currentTimeMillis() + 121 * 1000;
        String RS = sdf.format(times);
        System.out.println(RS);

    }
}

结果演示

解析字符串成为时间对象

代码演示

package com.peihj.date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test3 {
    public static void main(String[] args) throws ParseException {
        // 目标：学会使用SimpleDateFormat 解析字符串成为日期对象
        // 有一个时间 2021年8月06日 11：11：11 往后 2天14小时49分06秒后的时间为多少
        // 1、把字符串拿到程序中来；
        String dataStr = " 2021年8月06日 11:11:11";
        // 2、把字符串解析成为日期对象：形式必须与字符串相同。否则解析失败
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年M月dd日 HH:mm:ss");

        Date d = sdf.parse(dataStr); // alt + enter  抛出异常
        System.out.println(d);   // Fri Aug 06 11:11:11 CST 2021

        // 3、往后 2天14小时49分06秒后的时间为多少
        long time = d.getTime() +(2L*24*60*60+14*60*60 + 49*60 + 6)*1000;
        String lasttime = sdf.format(time);
        System.out.println(lasttime);  // 2021年8月09日 02:00:17

    }
}

案例演示–秒杀活动

package com.peihj.date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test4 {
    public static void main(String[] args) throws ParseException {
        // 开始时间与结束时间
        String starttime = "2021-11-11 00:00:00";
        String endtime = "2021-11-11 00:10:00";

        // 小贾，小皮
        String xiaojia = "2021-11-11 00:03:47";
        String xiaopi = "2021-11-11 00:10:11";

        // 解析时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = sdf.parse(starttime);
        Date d2 = sdf.parse(endtime);
        Date d3 = sdf.parse(xiaojia);
        Date d4 = sdf.parse(xiaopi);

        if (d3.after(d1) && d3.before(d2)){
            System.out.println("小贾秒杀成功");
        }else {
            System.out.println("小贾秒杀失败");
        }

        if (d4.after(d1) && d4.before(d2)){
            System.out.println("小皮秒杀成功");
        }else {
            System.out.println("小皮秒杀失败");
        }
    }
}

Canlendar

package com.peihj.date;

import java.util.Calendar;

public class test5 {
    public static void main(String[] args) {
        // 拿到系统此时的日历对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        // 获取日历信息
        int year = c.get(Calendar.YEAR);
        System.out.println(year);
    }
}

小结

包装类

代码演示

package com.peihj.date;

public class Test6 {
    public static void main(String[] args) {
        int a = 10;
        Integer a1 = 11;
        Integer a2 = a; // 自动装箱
        System.out.println(a2);

        Integer it = 100;
        int it1 = it; // 自动拆箱
        System.out.println(it1);

        double db = 99.5;
        double db1 = db;  // 自动装箱
        double db2 = db1; // 自动拆箱
        System.out.println(db2);

        // int age = null; // 报错
        Integer age = null;
        int age1 = 0;

        System.out.println("=====================");
        // 包装类可以把基本数据类型转换成字符串形式
        Integer k = 23;
        String rs = k.toString();  // 已经成为字符串了
        System.out.println(rs + 1); // 231

        String rs1 = Integer.toString(k);
        System.out.println(rs1+1);  // 231

        // 可以直接加字符串得到字符串类型
        String rs2 = k + "";
        System.out.println(rs2 +1 ); // 231

    }
}

package com.peihj.date;

public class test6 {
    public static void main(String[] args) {
        String NUM = "123";

        int age = Integer.valueOf(NUM);
        System.out.println(age + 1);  // 124

        String NUM1 = "99.9";
        double age1 = Double.valueOf(NUM1);
        System.out.println(age1+0.1);  // 100.0
    }
}

小结

正则表达式正则表述

代码演示

package com.peihj.regexdemo;

import java.util.Scanner;

public class test1 {
    public static void main(String[] args) {
        // 需求：验证qq号码，必须全部是数字 6--20位
        while (true) {
            Scanner sc  = new Scanner(System.in);
            System.out.println("请输入qq：");
            String QQ = sc.next();
            System.out.println(checkqq(QQ));
        }


    }
    public static boolean checkqq(String qq){
        // 1、判断qq号长度
        if ((qq == null) || (qq.length() < 6 ) || (qq.length() > 20)){
            return false;
        }

        // 判断qq全部是否都是数字
        for (int i = 0; i < qq.length(); i++) {
            char ch = qq.charAt(i);
            if (ch < '0' || ch >'9'){
                return false;
            }
        }

        return true;
    }
}

package com.peihj.regexdemo;

import java.util.Scanner;

public class test1 {
    public static void main(String[] args) {
        // 需求：验证qq号码，必须全部是数字 6--20位
        while (true) {
            Scanner sc  = new Scanner(System.in);
            System.out.println("请输入qq：");
            String QQ = sc.next();
            System.out.println(CHECKQQ(QQ));
        }
    }
    public static boolean CHECKQQ(String qq){
        return qq != null && qq.matches("\d{6,20}");
    }


    public static boolean checkqq(String qq){
        // 1、判断qq号长度
        if ((qq == null) || (qq.length() < 6 ) || (qq.length() > 20)){
            return false;
        }

        // 判断qq全部是否都是数字
        for (int i = 0; i < qq.length(); i++) {
            char ch = qq.charAt(i);
            if (ch < '0' || ch >'9'){
                return false;
            }
        }

        return true;
    }
}

结果演示

正则表达式使用详解

代码说明

package com.peihj.regexdemo;

public class test2 {
    public static void main(String[] args) {
        // 只能是a、b、c
        System.out.println("a".matches("[abc]")); // true
        System.out.println("b".matches("[abc]")); // true
        System.out.println("c".matches("[abc]"));  // true

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

        // 不能出现abc,只能验证单个字符
        System.out.println("a".matches("[^abc]")); // false
        System.out.println("b".matches("[^abc]")); // false
        System.out.println("c".matches("[^abc]"));  // false

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

        System.out.println("a".matches("\d")); //只能是一个数字  false
        System.out.println("123".matches("\d")); // false
        System.out.println("3".matches("\d")); // true
        System.out.println("z".matches("\w"));  //英文数字下划线 true
        System.out.println("3".matches("\w")); // true
        System.out.println("_".matches("\w")); // true
        System.out.println("-".matches("\w")); // false

        System.out.println("你".matches("\w")); // false
        System.out.println("你".matches("\W")); // true 验证除了英文数字下划线之外的所有

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

        // 校验密码
        // 密码：必须是字母、数字、下划线，至少6位
        System.out.println("ssscd3c".matches("\w{6,}")); // true
        System.out.println("ss3c".matches("\w{6,}")); // false
        System.out.println("ssscd3cmm你好".matches("\w{6,}")); // false

        System.out.println("===================================");
        // 验证码，数字、字母，必须是4位数
        System.out.println("25df".matches("[a-zA-Z0-9]{4}")); // true
        System.out.println("2_df".matches("[a-zA-Z0-9]{4}")); // false
        System.out.println("25d00f".matches("[a-zA-Z0-9]{4}")); // false

        System.out.println("23df".matches("[\w&&[^_]]{4}")); // true
        System.out.println("23_f".matches("[\w&&[^_]]{4}"));// false

    }
}

应用案例

package com.peihj.regexdemo;

import java.util.Scanner;

public class test3 {
    public static void main(String[] args) {
        // 目标：手机号码，邮箱，电话号码是否合法
        // checkphone();
        checkmail();

    }

    public static void checkphone(){
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.println("请输入您的手机号：");
            String phone = sc.next();
            // 判断手机号码格式
            if (phone.matches("1[3-9]\d{9}")){
                System.out.println("手机号码格式正确，注册成功");
                break;
            }else {
                System.out.println("格式有误");
            }
        }
    }

    public static void checkmail(){
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.println("请输入邮箱：");
            // 判断邮箱格式是否正确：328884415@qq.com
            // 判断邮箱格式是否正确：328884415@163.com
            // 判断邮箱格式是否正确：328884415@pci.com.cn
            String mail = sc.next();
            if (mail.matches("\w{1,30}@[a-zA-Z0-9]{2,20}\.([a-zA-Z0-9]{2,20}){1,2}")){
                System.out.println("邮箱格式正确");

            }else {
                System.out.println("格式错误");
            }
        }

    }
}

小结

正则表达式在字符串方法中的使用

package com.peihj.regexdemo;

public class test4 {
    public static void main(String[] args) {
        String name = "小路nmsjaikk小样paksks迪奥oookks";

        String[] arr = name.split("\w+");

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        String name2= name.replaceAll("\w+"," ");
        System.out.println(name2);
    }
}

正则表达式爬取信息

package com.peihj.regexdemo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test5 {
    public static void main(String[] args) {
        String rs = "来黑马程序学习Java,电话020-43422424，或者联系邮箱" +
                "itcast@itcast.cn,电话18762832633，0203232323" + "邮箱bozai@itcast.cn，400-100-3233 ，4001003232";
        // 需求：从上面的内容中爬取出 电话号码和邮箱。
        // 1.定义爬取规则
        String regex = "(\w{1,}@\w{2,10}(\.\w{2,10}){1,2})|" +
                "(1[3-9]\d{9})|(0\d{2,5}-?\d{5,15})|400-?\d{3,8}-?\d{3,8}";
        // 2.编译正则表达式成为一个匹配规则对象
        Pattern pattern = Pattern.compile(regex);
        // 3.通过匹配规则对象得到一个匹配数据内容的匹配器对象
        Matcher matcher = pattern.matcher(rs);
        // 4.通过匹配器去内容中爬取出信息
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}

arrays类 arrays类概述

代码演示

package com.peihj.arrays;

import java.util.Arrays;

public class test1 {
    public static void main(String[] args) {

        int[] arr = {10,20,5,25,13,4,50};
        System.out.println(arr);
        System.out.println("-------------------");
        System.out.println(Arrays.toString(arr));

        // 排序的Api
        Arrays.sort(arr);
        System.out.println("-----------------");
        System.out.println(Arrays.toString(arr));

        // 2分搜索技术
        System.out.println("-----------------");
        int index = Arrays.binarySearch(arr,10);
        int index1 = Arrays.binarySearch(arr,14);
        System.out.println(index);
        System.out.println(index1);
    }
}

Arrays类对于Comparator比较器的支持

代码说明

package com.peihj.arrays;

import java.util.Arrays;
import java.util.Comparator;

public class test2 {
    public static void main(String[] args) {
        int[] arr = {20,5,40,30,60,15};
        Arrays.sort(arr); //  默认升序排序
        System.out.println(Arrays.toString(arr));

        Integer[] arr1 = {34,12,15,8,45};

        Arrays.sort(arr1, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 指定比较规则
//                if (o1 > o2){
//                    return 1;
//                }else if (o1 < o2){
//                    return -1;
//                }
//                return 0;
//                return o1-o2; // 默认升序
                return (o2-o1);
            }
        });
        System.out.println(Arrays.toString(arr1));
    }
}

对于不同的数组类型，同时数组内部有许多的不同元素，我们如何对数组进行排序

package com.peihj.arrays;

import java.util.Arrays;
import java.util.Comparator;

public class test3 {
    public static void main(String[] args) {
        student s1 = new student("小王",25,175.5);
        student s2 = new student("小明",15,185.5);
        student s3 = new student("小东",20,195.5);

        student[] s = {s1,s2,s3};

        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }

        System.out.println(Arrays.toString(s));
        Arrays.sort(s, new Comparator() {
            @Override
            public int compare(student o1, student o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println("-----------------");
        System.out.println(Arrays.toString(s));

    }
}

如果比较身高，不可以用加减法，用double.compare，因为身高是double类型，加减法结果有时候不对

常见的算法冒泡排序

选择排序

二分查找

小结

Lambda表达式 lambda概述

代码演示

package com.peihj.lambda;

public class test1 {
    public static void main(String[] args) {

        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师再游泳，游的快");
            }
        };
        
        go(s);
    }

    public static void go(Swimming swimming){
        System.out.println("开始");
        swimming.swim();
        System.out.println("结束");
    }

}

@FunctionalInterface
interface Swimming{
    void swim();
}

代码简化

package com.peihj.lambda;

public class test1 {
    public static void main(String[] args) {

        Swimming s = ()->  System.out.println("老师再游泳，游的快"); ;

        go(s);
    }

    public static void go(Swimming swimming){
        System.out.println("开始");
        swimming.swim();
        System.out.println("结束");
    }

}

@FunctionalInterface
interface Swimming{
    void swim();
}

案例2
简化前

简化后

Lambda实战-简化常见函数式接口

Lambda表达式的省略规则

参考

黑马程序员

java学习---常用API、Lambda、常见算法

Java相关栏目本月热门文章