javase-day02

aRegex_RegexDemo01

package com.se.aRegex;

import java.util.Arrays;

/**
 * 常用方法:
 *   1.boolean matches(String regex)
 *     作用:用于检验普通字符串是否符合一个正则表达式。符合，返回true，不符合返回false
 *   2.String[] split(String regex)
 *     作用:用于将一个字符串按照一个正则表达式进行分割。
 *     提示： 符合正则表达式的子串，相当于隔板  相当于隔板的子串就无了
 *
 *     "hello123world456welcome"  \d+
 *     "hello,world,welcome"  \d+
 *
 *   3.replaceAll(String regex,String replacement)
 *
 */

public class RegexDemo01 {
    public static void main(String[] args) {
        String username = "micheal123";
        String regex = "[a-zA-Z][\\w]{7,9}$";
        //检查用户名是否匹配正则表达式
        boolean flag = username.matches(regex);
        if (flag) {
            System.out.println("用户名合法");
        } else {
            System.out.println("用户名不合法.首字符是子母，总长度是8~10");
        }

        /*
           测试 split方法
         */
        String str = "hello123world456welcome789";
        //使用数字将其切分为字符串数组
        String regex1= "\\d+";
        String[] arr = str.split(regex1);
        System.out.println(Arrays.toString(arr));
        System.out.println(arr.length);

        str = "2323aaa323aaa32ccc";
        arr = str.split(regex1);
        System.out.println(Arrays.toString(arr));
        System.out.println(arr.length);

        str = "123abc234def235hhh";
        arr = str.split("3");
        System.out.println(Arrays.toString(arr));
        System.out.println(arr.length);

        /*
            replaceAll(String regex,String replacement)
             作用：使用replacement这个串替换掉所有符合正则表达式的子串
         */
        String info = "no zuo no die";
        info = info.replaceAll("no","yes");
        System.out.println(info);

        info = "https://www.baidu123.com.cn.com234";
        //将所有子母换成#
        info = info.replaceAll("[a-zA-Z]","#");
        System.out.println(info);





    }
}

bPattern_PatternDemo01

package com.se.bPattern;

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

/**
 *   正则表达式只能完成简单的校验工作，想要进一步做复杂的工作，需要使用
 *    Pattern和Matcher类型
 *     1. Pattern类型的介绍
 *        字符串在真正校验时，底层实际上维护了一个Pattern对象，使用其相关方法进行的校验。
 *         因此，我们可以直接使用Pattern进行校验
 *        Pattern类的构造器私有化了，因此不能调用构造器来创建对象，但是其提供了一个工厂方法
 *        来获取对象
 *        static compile(String regex);
 *
 *      案例演示:
 *           正则表达式真正执行的校验步骤，
 */

public class PatternDemo01 {
    public static void main(String[] args) {
        String regex = "[a-zA-Z][$a-zA-z0-9]{7,9}";
        //获取一个Pattern对象
        Pattern p1 = Pattern.compile(regex);
        //和普通字符串进行校验,会得到一个Matcher类的对象
        //该对象里封装的是匹配的结果，并且提供了各种操作
        Matcher matcher =p1.matcher("michael12_");
        //想要得到是否匹配成功，需要调用Matcher里的matches()，该方法的作用是从头到尾严格匹配
        //如果匹配成功，返回true，否则返回false
        boolean matches = matcher.matches();
        System.out.println(matches);
    }
}

bPattern_PatternDemo02

package com.se.bPattern;

import java.util.Arrays;
import java.util.regex.Pattern;

/**
 * Pattern other demo
 */

public class PatternDemo02 {
    public static void main(String[] args) {
        String regex =  "\\d+";
        String str = "aaa111bbb222ccc";
        //获取一个Pattern对象
        Pattern p1 = Pattern.compile(regex);
        /*
          String pattern()
           作用： 返回Pattern的正则表达式，即特殊的字符串
         */
        String str2 = p1.pattern();
        System.out.println(str2);

        /*
          String[] split(String str )
           作用： 对字符串进行划分，使用符合正则表达式的子串进行划分
           返回字符电数组。符合正则表达式的子串，就相当于隔板，不要了。
         */
        String[] arr = p1.split(str);
        System.out.println(Arrays.toString(arr));
    }
}

bPattern_PatternDemoMatcher01

package com.se.bPattern;

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

/**
 * tips：
 *   pattern对象--->匹配对象
 *   Matcher对象--->匹配结果对象
 * Matcher类：
 *   1. 该类的构造器私有化，不能直接new。而是通过Pattern类的Matcher()方法来获取该类的对象
 *   2. 该类的对象里面，封装的就是正则表达式和普通字符申匹配的结果。
 *   3. 该类里提供了多个方法，对封装的结果进行操作。
 *   matches()、lookingAt()、find()、start()、
 *   end()、group()、groupCount()、reset()等
 */

public class PatternDemo03Matcher01 {
    public static void main(String[] args) {
        /*
            matches方法 com.se.bPattern.PatternDemo01

            研究lookingAt()方法：
             1.用于匹配普通字符串的开头部分是否符合正则表达式。符合返回true.
             2. 内部含有一个类似于指针的操作，当匹配成功后，指针指向了匹配成功的子串
                匹配前位于普通字符串前面

         */
        String regex = "\\d+";
        String info = "1234abcd";
        Pattern pattern = Pattern.compile(regex);  //获取匹配对象
        Matcher matcher = pattern.matcher(info);  //获取匹配结果对象

        //调用lookingAt()方法
        boolean  result = matcher.lookingAt();
        System.out.println(result);

        /*
          boolean find()：
           1. 用于匹配普通字符串里是否有符合正则表达式的子串，检索到最后一个，如果有，返回true,
           2. 该方法也有一个指针操作，当匹配成功后，指针向后移动
             注意： 匹配前，指针还是在字符串前
         */
        regex = "\\d+";
        info = "abc123eee345fff555ggg";
        pattern = Pattern.compile(regex);
        matcher = pattern.matcher(info);
        //循环的次数，表示了find()找到的符合要求的子串的个数
        while (matcher.find()){
            System.out.println("匹配成功");
        }

    }
}

bPattern_PatternDemoMatcher02

package com.se.bPattern;

import com.sun.javaws.IconUtil;

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

/**
 * 测试： group() groupCount() reset() start() end()
 *
 * 注意： 上面的方法必须基于matches() lookingAt find()方法，才能使用
 *   即： matches() lookingAt find()用于匹配工作
 *    剩下的方法用于匹配成功进行的操作
 */

public class PatternDemo04Matcher02 {
    public static void main(String[] args) {
        /*
          group()
          作用： 用于返回指针指向的符合正则表达式的那一部分
         */
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher("abc123ouih567o259xxx");
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
        //使用find()后，指针已经移动到符合正则表达式的最后一个部分，
        // 因此再次使用find会继续向后检索，没有符合group()的值，因此需要使用reset()方法
        // 重置指针
        matcher.reset();
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}

bPattern_PatternDemoMatcher03

package com.se.bPattern;
/**
 * 研究一下start()和end()方法
 *  int start()： 用于返回正则表达式子串的起始位置。
 *  int end()： 用于返回正则表达式子串的结束位置+1。
 */

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

public class PatternDemo05Matcher03 {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher("abc123uih259xxx");

        int count = 1;
        while(matcher.find()){
            int start = matcher.start();
            int end = matcher.end();
            System.out.println("第"+count+"start+end："+start+"-"+end);
            count++;
        }
    }
}

bPattern_PatternDemoMatcher04

package com.se.bPattern;

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

/**
 * lookingAt()和find()在一起使用时，可能会影响指针的操作
 */

public class PatternDemo06Matcher04 {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher("111aaa333bbb555");
        System.out.println("数字开头：" + matcher.lookingAt());
        /*因为在使用lookingAt时候，指针已经指向了第一个数字，
         所以使用find()方法时，指针就不是从字符串前开始移动的，而是紧随着lookingAt()方法的位置移动的

           注意 指针重置
         */
        matcher.reset();
        while(matcher.find()){
            System.out.println(matcher.group());
        }
    }
}

bPattern_PatternDemoMatcher05

package com.se.bPattern;

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

/**
 * 研究groupCount()
 */

public class PatternDemo07Matcher05 {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("((ca)(t))s");
        Matcher matcher = pattern.matcher("one cat, two cats in the yard");
        System.out.println(matcher.groupCount());
        /*
          int groupCount():
           作用:用于获取正则表达式中的小括号的个数。()用于分组。
         */
        while (matcher.find()) {
            //打印符合正则表达式的子串，因此循环次数是两次
            System.out.println(matcher.group());
        }

        /*使用小括号的个数来循环
          使用group的重载方法 String group(int group)

          注意 想要使用()的个数进行遍历，需要重置指针

          group(0) 是对组进行拆分括号的整体的样子
          group(1) 是对组进行拆分括号的第一部分
          group(2) 是对组进行拆分括号的第二部分
         */
        matcher.reset();
        matcher.find();
        for (int i = 0; i <= matcher.groupCount(); i++) {
            System.out.println(matcher.group(i));
        }


    }
}

cWrapperClass_WrapperDemo01

package com.se.cWrapperClass;

/**
 * 包装类的学习：
 * 1. 因为基本数据类型没有面向对象的特征，因此java专门为这八个类型，设计了具有面向对象特征的类
 * 实际上就是对基本数据类型做的类的封装，即里面有一个基本数据类型的成员变量+各种方法，常量等。
 * 2. 除了int char 剩下的都是首字母大写的形式
 * int-->Integer    char-->Character
 * 3. 装箱和拆箱
 * 装箱： 调用包装类的构造器或者valueOf方法，获取一个包装类的对象
 * 拆箱： 调用包装类的xxxValue()，返回获取基本数据类型的值
 */

public class WrapperDemo01 {
    public static void main(String[] args) {
        //装箱:获取一个包装类对象。
        // 思考：num里面储存的是什么？  存储的是对象  int a = 1; a存的是值。
        Integer num = new Integer(1);
        Integer num2 = Integer.valueOf(1);
        System.out.println(num == num2); //false 不同的对象 只不过对象的成员变量的值一样
        System.out.println(num.equals(num2)); //true

        //拆箱: 其他包装类，想要拆箱，就调用自己的xxxValue()方法
        int i = num.intValue();

        Integer result = calculate(num, num2);
        System.out.println("result:" + result);
        // 形参是包装类，因此可以赋值为null.编译器不会报错。
        result = calculate(null, num2);
        System.out.println("result:" + result);
    }

    //定义方法，形参是包装类型
    public static Integer calculate(Integer num, Integer num2) {
        return num + num2;
    }
}

cWrapperClass_WrapperDemo02

package com.se.cWrapperClass;

/**
 * 包装类的自动拆装箱：
 *    1. jdk1.5开始，引入操作
 *    2. 自动装箱：
 *       把基本数据类型火变量赋值给包装类对象
 *       本质是编译器在编译期间调用了类的valueOf方法进行包装
 *    3. 自动拆箱：
 *       把包装类对象的地址赋值给基本数据类型变量
 *       本质是编译器在编译期间调用了类的xxxValue方法进行拆箱
 */

public class WrapperDemo02 {
    public static void main(String[] args) {
        Integer num = 1; // 自动装箱 底层调用Integer.valueOf(1)

        int a = 10;
        Integer num2 = a; // 自动装箱

        //自动拆箱
        int x = num; // 底层调用num.intValue()
        int y = new Integer(100);
    }
}

cWrapperClass_WrapperDemo03

package com.se.cWrapperClass;

/**
 * 包装类的常量池：
 *  1. 自动装箱的，或者是手动调用valueOf()方法生成的，包装类对象，会有常量池
 *  2. Byte Short Integer Long 四种类型的常量池范围是[-128,127]
 *  3. Character类型的常量池范围是[0,127]
 *  4. Boolean类型的常量池范围是[true,false]
 *  5. 浮点数类型没有常量池
 */

public class WrapperDemo03 {
    public static void main(String[] args) {
        Integer n1 = 10;
        Integer n2 = 10;
        System.out.println(n1 == n2); // true

        Integer n3 = Integer.valueOf(10);
        System.out.println(n3 == n2); // true

        Integer n4 = new Integer(10);
        System.out.println(n4 == n2); // false

        //范围
        Integer n5 = 128;
        Integer n6 = 128;
        System.out.println(n5 == n6); // false

        Boolean b1 = true;
        Boolean b2 = true;
        System.out.println(b1 == b2); // true

        Boolean b3 = true;
        //调用常量也是使用了常量池
        Boolean b4 = Boolean.TRUE;
        System.out.println(b3 == b4);// true

        Character c1 = 'a';
        Character c2 = 'a';
        System.out.println(c1 == c2); // true

    }
}

cWrapperClass_WrapperDemo04

package com.se.cWrapperClass;

/**
 * 包装类的其他常用方法或常量
 */

public class WrapperDemo04 {
    public static void main(String[] args) {
        System.out.println(Short.MAX_VALUE); //32767
        System.out.println(Short.MIN_VALUE); //-32768
        //找出两个数中的较大值
        System.out.println(Integer.max(10, 20)); //20
        System.out.println(Integer.min(10, 20)); //10

        /*
          static parseInt(String str)
          1. 静态方法
          2. 将字符串类型转换为int类型的值
          3. 该方法声明了一个运行时异常，NumberFormatException异常(数字格式异常类型)
              当传入的不是纯数字型字符串时
         */
//        String str = "10a";
        String str = "10";
        int n1 = Integer.parseInt(str);
        System.out.println(n1);

        int n2 = 10;
        System.out.println(Integer.toString(n2)); //十六进制
        System.out.println(Integer.toBinaryString(n2)); //二进制
        System.out.println(Integer.toOctalString(n2)); //八进制

    }
}

dBigDecimal_BigDecimal01

package com.se.dBigDecimal;

import java.math.BigDecimal;

/**
 *  当运算时，尤其是对浮点数类型数据做超过15.6位的精确运算时，建议使用BigDecimal类型
 *    1. 常用的构造器
 *       BigDecimal(int i)
 *       BigDecimal(double d): 该构造器不推荐使用，因为double类型在传入的时候可能发生精度损失
 *       BigDecimal(long l)
 *       BigDecimal(String s): 如何想要使用浮点数，建议使用形参是字符串的构造器
 *    2. 加减乘除运算
 *       add
 *       subtract
 *       multiply
 *       divide  -除数不能为零，对象不能为null  除不尽的情况报错
 */

public class BigDecimal01 {
    public static void main(String[] args) {
//        BigDecimal bg1 = new BigDecimal(3);
//        BigDecimal bg2 = new BigDecimal(2.9);
        BigDecimal bg1 = new BigDecimal("3");
        BigDecimal bg2 = new BigDecimal("2.9");

        BigDecimal r1 = bg1.add(bg2);
        System.out.println(r1);
        BigDecimal r2 = bg1.subtract(bg2);
        System.out.println(r2);
        BigDecimal r3 = bg1.multiply(bg2);
        System.out.println(r3);
        BigDecimal r4 = bg1.divide(bg2);
        System.out.println(r4);
    }
}

dBigDecimal_BigDecimal02

package com.se.dBigDecimal;

import java.math.BigDecimal;

/**
 * 建议使用形参是字符串类型的构造器
 *
 *  tips: 除法运算时，除不尽就是会发生异常。
 *       因此，一般在做除法运算时，都会进行try-catch处理，避免出现异常。
 */

public class BigDecimal02 {
    public static void main(String[] args) {
        BigDecimal bg1 = new BigDecimal("3");
        BigDecimal bg2 = new BigDecimal("2.9");

        try {
            System.out.println(bg1.divide(bg2));
        } catch (Exception e) {
            e.printStackTrace();
        }
        //减法
        System.out.println(bg1.subtract(bg2));
    }
}

eDate_CalenderDemo01

package com.se.eDate;

import java.util.Calendar;
import java.util.Date;

/**
 * calender: 日历类型，封装了日历信息，以及提供了各个时间分量的方法和常量
 *  1. 是一个抽象类，提供了工厂方法getInstance()获取最常用的子类格力高日历对象
 *  2. 常量:
 *       static int YEAR  指定年份的字段数字
 *       static int MONTH  指定月份的字段数字，0为一月
 *       static int DATE 指示一个月份中的第几天
 *       static int DAY_0F_WEEK  指定一个星期中的某天，1为星期日
 *       static int WEEK_OF_MONTH 指定一个月中的第几周
 *       static int WEEK OF_YEAR  指定一年中的第几周
 *  3. get/set方法配合常量，就可以对时间分量进行操作
 */

public class CalenderDemo01 {
    public static void main(String[] args) {
        // 获取日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
        /*
          调用get方法，获取时间日期分量
         */
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH)+1; //日历月份是0~11，因此要加一
        int day = cal.get(Calendar.DAY_OF_MONTH);
        int date = cal.get(Calendar.HOUR_OF_DAY);
        int minute = cal.get(Calendar.MINUTE);
        int second = cal.get(Calendar.SECOND);
        System.out.println("year="+year);
        System.out.println("month="+month);
        System.out.println("day="+day);
        System.out.println("date="+date);
        System.out.println("date="+date);
        System.out.println("minute="+minute);
        System.out.println("second="+second);

        System.out.println("星期："+(cal.get(Calendar.DAY_OF_WEEK)-1));//默认周日为1，故星期减一
        System.out.println("一年中的第几天："+cal.get(Calendar.DAY_OF_YEAR));

        /*
          set方法的测试： 也需要配合常量
         */
        Calendar cal2 = Calendar.getInstance();
        //将其修改北京奥运会日期信息
        cal2.set(Calendar.YEAR,2008);
        cal2.set(Calendar.MONTH,7); //因为月份系统是0~11，设置的时候要减一
        cal2.set(Calendar.DAY_OF_MONTH,8);
        cal2.set(Calendar.HOUR_OF_DAY,8);
        cal2.set(Calendar.MINUTE,8);
        cal2.set(Calendar.SECOND,8);
        System.out.println(cal2);

        //将日历类型转成日期类型
        Date date1 = cal2.getTime();
        System.out.println(date1);
    }
}

eDate_CalenderDemo02

package com.se.eDate;

import java.util.Calendar;

/**
 * 练习：获取2024年每月的天数
 */

public class CalenderDemo02 {
    public static void main(String[] args) {
        //获取日历对象
        Calendar calendar = Calendar.getInstance();
        for (int i = 0; i < 12; i++) {
            //将日历对象设置成相对的月份
            calendar.set(Calendar.MONTH, i);
            //获取该月最大天数
            int days = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
            System.out.println(i + 1 + "月有" + days + "天");

        }

    }
}

eDate_DateDemo01

package com.se.eDate;

import java.util.Date;

/**
 * Date类型的学习：
 *   1. java.uitl包下的类型
 *   2. 用于日期和时间的描述
 *   3. 实际上是具体是个固定时间点1970年1月1日00:00:00的毫秒数
 *   4. 常用的是格林威治时间：GMT   UTC：世界协调时间
 *   5. 固定时间点： 说的是本初子午线格林威治时间 北京时间 1970年1月1日08:00:00
 */

public class DateDemo01 {
    public static void main(String[] args) {
        /*
          常用构造器：
           1. Date()：获取的是当前系统的时间点
           2. Date(long time)：获取距离纪元知道毫秒数的时间点

           CST 中国标准时间：1970年1月1日00:00:00  UT+8:00 (东八区)
         */
        //Fri Aug 02  15:53:06  CST   2024
        //星期 月  日  时 分 秒  标准时间 年
        Date now = new Date();
        System.out.println(now);

        //格林威治时间：1970年1月1日00:00:00
        //北京时间1970年1月1日08:00:00
        Date t1 = new Date(1000*60+60*24);
        System.out.println(t1);

        /*
          getTime()：获取日期时间对象距离纪元的毫秒数
          void setTime(long time)：设置距离纪元的毫秒数
         */
        long time = now.getTime();
        System.out.println("当前时间距离纪元的毫秒数"+time);

        now.setTime(1000*60*60*12);
        System.out.println(now);

    }
}

eDate_DateDemo02

package com.se.eDate;

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

/**
 * 1. Date的toString方法转成的字符串不是我们想要的格式
 *     因此需要使用SimpleDateFormat类型来自定义格式
 *     --format(Date date)：格式化城我们需要的字符串类型
 * 2. 另外一个功能就是可以将一个字符串按照制定格式转成我们需要的日期类型
 *     --parse(String str)： 解析转变，将字符串类型转成日期类型
 */

public class DateDemo02 {
    public static void main(String[] args) throws ParseException {
        Date now = new Date();
        //使用SimpleDateFormat来定义你需要的格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm：ss");
        //调用格式化方式，转成字符串
        String format = sdf.format(now);
        System.out.println(format);

        /*
          将字符串转成日期
          出生日期字符串转成日期，并获取距离纪元北京时间早八点的毫秒数据
         */
        String birth = "1998-2-10 5:25:25";
        //一旦字符串的格式确定，那么构造器的时间格式必须与其一致，否则异常
        sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //调用parse方法，将字符串转成日期类型
        Date birthday = sdf.parse(birth);
        System.out.println(birthday);
        //获取距离纪元的北京时间毫秒数
        long time = birthday.getTime();
        System.out.println(time);
    }
}