黑马java学习笔记5 时间类和正则表达式

原创 已于 2022-08-18 10:02:52 修改 · 348 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
java前后端

当前文章被收录于：

java前后端
32 篇文章 0 人学习

java前后端

订阅专栏 查看详情
于 2021-12-21 21:55:50 首次发布
本文介绍Java中日期时间处理及正则表达式的应用，包括Date、SimpleDateFormat、Calendar类的使用方法，以及如何利用正则表达式进行数据验证和信息爬取。

1、DATE

 

package com.itheima.d1_data;

import java.util.Date;

/**
 * 目标：学会使用Data类处理事件，获取时间的信息
 */
public class DataDemo1 {
    public static void main(String[] args) {
        //1、创建一个Data类的对象：代表系统此刻日期时间对象
        Date d = new Date();
        System.out.println(d);

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

        System.out.println("-------------------------");
        //1、得到当前时间
        Date d1 = new Date();
        System.out.println(d1);

        //2、当前时间往后走1小时 121s
        long time2 = System.currentTimeMillis();
        time2 += (60*60+121)*1000;
        
        Date d3 = new Date();
        d3.setTime(time2);
        System.out.println(d3);

    }
}

2、SimpleDateFormat类作用

 

package d2_date;

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

/**
 * 目标：simpledateformat简单日期格式化类的使用
 * 格式化时间
 * 解析时间
 */
public class SimpleDateformat1 {
    public static void main(String[] args) {
        //1、日期对象
        Date d = new Date();
        System.out.println(d);

        //2.格式化这个日期对象（指定最终格式化的形式）
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");

        //3.开始格式化日期对象成为喜欢的字符串形式
        String rs = sdf.format(d);
        System.out.println(rs);

        //4、格式化时间毫秒值
        long time1 = System.currentTimeMillis() + 121*1000;
        String rs2 = sdf.format(time1);
        System.out.println(rs2);
    }
}

重要功能:解析字符串时间为日期对象

alt加 回车 快速修正错误

package d2_date;

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

public class SimpleDateformat2 {
    public static void main(String[] args) throws ParseException {
        //目标：学会使用SimpleDateFormat解析字符串时间成为日期对象
        //有一个时间2021年08月06日11:11:11往后2天14小时49分B6秒后的时间是多少
        //1、把字符时间拿到程序中来
        String dateStr = "2021年08月06日 11:11:11";

        //2、把字符时间解析成日期对象（本节的重点）：形式必须与被解析时同的形式完全一样，否则运行时解析报错
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date d = sdf.parse(dateStr);

        //3、往后走2天14小时49分06秒
        long time = d.getTime() + (2L*24*60*60 + 14*60*60 + 49*60 + 6) * 1000;

        //4、格式化这个时间毫秒值就是结果
        System.out.println(sdf.format(time));
    }
}

 

3、Calendar类作用-日历

 

//1、拿到系统此刻日历对象
Calendar cal =Calendar. getinstanceo
System. out. println(cal)
//2、获取日历的信思： public Int get( int field):取日期中的某个字段信息。
int year cal get(Calendar.YEAR);
System.out. println(year);
int mm cal get(Calendar.MONTH)+ 1;//系统从0开始记
System. out. println(mm);
int days cal get(Calendar.DAY_OF_YEAR);
ystem outprintln(days);

4、LocalDate、LocalTime、LocalDateTime

 

 

 

 period 算活了多长时间

 

 

 

5、包装类（重点）-八种基本数据类型对应的引用类型

 

int a = 10;
Integer a1 = 11;
Integer a2 = a;//自动装箱
int a3 = a1；//自动拆箱

//包装类可以把基本类型的数据转换成字符串形式

Integer i = 23;
String rs = i.toString();
System.out.println(rs+1);

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

//最后都会输出 231 这个字符串

//----------------------------------------
//（重要）可以把字符串类型的数值转换成真实的数据类型，进而参与运算
String number="23”;
//转换成整数
// int age Integer.parseInt(number);//字符串转化为整数
int age = Integer.valueOf(number);//valueOf搞定一切（整数+小数）
System.out.println(age + 1);

String number1 = "99.9";
//转换成小数

//double score = Double.parseDouble(number1);//字符串转化为小数
double score =Double.valueOf(number1);
System.out.println(score + 0.1);

6、正则表达式 校验用户名 身份证号等格式的合法性         

//正则表达式初体验 判断qq号是否全是数字
public static boolean checkQQ2(String qq){
    return qq != null && qq.matches("\\d{6,20}");
}

正则表达式匹配规则

 

//Ctrl + alt + T 设置各类循环

正则表达式校验 手机号码 邮箱 电话号码

package com.itheima.d6_regex;

import java.util.Arrays;
import java.util.Scanner;

public class RegexTest3 {
    public static void main(String[] args) {
        // 目标：校验 手机号码 邮箱  电话号码
        // checkPhone();
        // checkEmail();
        // checkTel();

        // 同学可以完成校验金额是否格式金额： 99  0.5  99.5  019   | 0.3.3

        int[] arr = {10, 4, 5,3, 4,6,  2};
        System.out.println(Arrays.binarySearch(arr, 2));

    }

    public static void checkTel(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的电话号码：");
            String tel = sc.next();
            // 判断邮箱格式是否正确   027-3572457  0273572457
            if(tel.matches("0\\d{2,6}-?\\d{5,20}")){
                System.out.println("格式正确，注册完成！");
                break;
            }else {
                System.out.println("格式有误！");
            }
        }
    }

    public static void checkEmail(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的注册邮箱：");
            String email = sc.next();
            // 判断邮箱格式是否正确   3268847878@qq.com
            // 判断邮箱格式是否正确   3268847dsda878@163.com
            // 判断邮箱格式是否正确   3268847dsda878@pci.com.cn
            if(email.matches("\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2}")){
                System.out.println("邮箱格式正确，注册完成！");
                break;
            }else {
                System.out.println("格式有误！");
            }
        }
    }

    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("格式有误！");
            }
        }
    }
}

//正则表达式 分割字符串获取指定的内容 按正则表达式匹配的内容进行替换

package com.itheima.d6_regex;
/**
    目标：正则表达式在方法中的应用。
        public String[] split(String regex)：
            -- 按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。
        public String replaceAll(String regex,String newStr)
            -- 按照正则表达式匹配的内容进行替换
 */
public class RegexDemo04 {
    public static void main(String[] args) {
        String names = "小路dhdfhdf342蓉儿43fdffdfbjdfaf小何";

        String[] arrs = names.split("\\w+");
        for (int i = 0; i < arrs.length; i++) {
            System.out.println(arrs[i]);
        }

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

正则表达式爬取信息（爬虫技术）

package com.itheima.d6_regex;

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

/**
    拓展：正则表达式爬取信息中的内容。(了解)
 */
public class RegexDemo05 {
    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,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2})|(1[3-9]\\d{9})" +
                "|(0\\d{2,6}-?\\d{5,20})|(400-?\\d{3,9}-?\\d{3,9})";

        // 2、把这个爬取规则编译成匹配对象。
        Pattern pattern = Pattern.compile(regex);

        // 3、得到一个内容匹配器对象
        Matcher matcher = pattern.matcher(rs);

        // 4、开始找了
        while (matcher.find()) {
            String rs1 = matcher.group();
            System.out.println(rs1);
        }

    }
}

7、Arrays类 

package com.itheima.d7_arrays;

import java.util.Arrays;

public class ArraysDemo1 {
    public static void main(String[] args) {
        // 目标：学会使用Arrays类的常用API ,并理解其原理
        int[] arr = {10, 2, 55, 23, 24, 100};
        System.out.println(arr);

        // 1、返回数组内容的 toString(数组)
//        String rs = Arrays.toString(arr);
//        System.out.println(rs);

        System.out.println(Arrays.toString(arr));

        // 2、排序的API(默认自动对数组元素进行升序排序)
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        // 3、二分搜索技术（前提数组必须排好序才支持，否则出bug）
        int index = Arrays.binarySearch(arr, 55);
        System.out.println(index);

        // 返回不存在元素的规律： - （应该插入的位置索引 + 1）
        int index2 = Arrays.binarySearch(arr, 22);
        System.out.println(index2);


        // 注意：数组如果么有排好序，可能会找不到存在的元素，从而出现bug!!
        int[] arr2 = {12, 36, 34, 25 , 13,  24,  234, 100};
        System.out.println(Arrays.binarySearch(arr2 , 36));
    }

}


package com.itheima.d7_arrays;

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

public class ArraysDemo2 {
    public static void main(String[] args) {
        // 目标：自定义数组的排序规则：Comparator比较器对象。
        // 1、Arrays的sort方法对于有值特性的数组是默认升序排序
        int[] ages = {34, 12, 42, 23};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));

        // 2、需求：降序排序！(自定义比较器对象，只能支持引用类型的排序！！)
        Integer[] ages1 = {34, 12, 42, 23};
        /**
           参数一：被排序的数组 必须是引用类型的元素
           参数二：匿名内部类对象，代表了一个比较器对象。
         */
        Arrays.sort(ages1, new Comparator<Integer>() {
            @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(ages1));

        System.out.println("-------------------------");
        Student[] students = new Student[3];
        students[0] = new Student("吴磊",23 , 175.5);
        students[1] = new Student("谢鑫",18 , 185.5);
        students[2] = new Student("王亮",20 , 195.5);
        System.out.println(Arrays.toString(students));//toString写在类中

        // Arrays.sort(students);  // 直接运行奔溃
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自己指定比较规则
                // return o1.getAge() - o2.getAge(); // 按照年龄升序排序！
                // return o2.getAge() - o1.getAge(); // 按照年龄降序排序！！
                // return Double.compare(o1.getHeight(), o2.getHeight()); // 比较浮点型可以这样写 升序
                return Double.compare(o2.getHeight(), o1.getHeight()); // 比较浮点型可以这样写  降序
            }
        });
        System.out.println(Arrays.toString(students));


    }
}

8、常见算法

1）选择排序

package com.itheima.d8_sort_binarysearch;

import java.util.Arrays;

/**
    目标：学会使用选择排序的方法对数组进行排序。
 */
public class Test1 {
    public static void main(String[] args) {
        // 1、定义数组
        int[] arr = {5, 1, 3, 2};
        //           0  1  2  3

        // 2、定义一个循环控制选择几轮： arr.length - 1
        for (int i = 0; i < arr.length - 1; i++) {
            // i = 0   j =  1  2  3
            // i = 1   j =  2  3
            // i = 2   j =  3
            // 3、定义内部循环，控制选择几次
            for (int j = i + 1; j < arr.length; j++) {
                // 当前位：arr[i]
                // 如果有比当前位数据更小的，则交换
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

2）二分查找

package com.itheima.d8_sort_binarysearch;

/**
    目标：理解二分搜索的原理并实现。
 */
public class Test2 {
    public static void main(String[] args) {
        // 1、定义数组
        int[] arr = {10, 14, 16, 25, 28, 30, 35, 88, 100};
        //                                            r
        //                                                l
        //
        System.out.println(binarySearch(arr , 35));
        System.out.println(binarySearch(arr , 350));
    }
    /**
     * 二分查找算法的实现
     * @param arr  排序的数组
     * @param data 要找的数据
     * @return  索引，如果元素不存在，直接返回-1
     */
    public static int binarySearch(int[] arr, int data){
        // 1、定义左边位置  和 右边位置
        int left = 0;
        int right = arr.length - 1;

        // 2、开始循环，折半查询。
        while (left <= right){
            // 取中间索引
            int middleIndex = (left + right) / 2;
            // 3、判断当前中间位置的元素和要找的元素的大小情况
            if(data > arr[middleIndex]) {
                // 往右边找，左位置更新为 = 中间索引+1
                left = middleIndex + 1;
            }else if(data < arr[middleIndex]) {
                // 往左边找，右边位置 = 中间索引 - 1
                right = middleIndex - 1;
            }else {
                return middleIndex;
            }
        }
        return -1; // 查无此元素
    }

}

7、Lambda表达式 简化匿名内部类的代码写法

 

 

 

 

标签
#java #开发语言 #后端
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值