Math

import java.lang.Math;
import java.sql.SQLOutput;

public class Math_Test {

    public static void main(String[] args) {
        int a = 2;
        int b = 3;
        int c = -8;
        //取绝对值 abs()
        System.out.println(Math.abs(c));
       //向上取整 ceil()
        System.out.println(Math.ceil(10.1));
        //向下取整
        System.out.println(Math.floor(10.1));
        //求次幂
        System.out.println(Math.pow(a,b));
        //四舍五入round()
        System.out.println(Math.round(10.56));
        //取最大值
        System.out.println(Math.max(a,b));
        //生成[0.0,1.0)的随机数
        System.out.println(Math.random());
    }

}

System

通过这个方法能计算一个程序运行的时长

import java.lang.Math;
//import java.lang.System;


public class Math_Test {
    public static void test(){
        long start = System.currentTimeMillis();
        long sum = 0;
        for (int i = 0; i < 10000000; i++) {
              sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

    }
    public static void main(String[] args) {
        test();
    }
}

当arraycope拷贝类时，可以把子类拷贝到父类中，就是多态
多态的特征：有继承关系，方法的重写，向上型
student s1 = new student(10,"zhangsan");
        student s2 = new student(12,"lishi");
        student s3 = new student(14,"wangwu");
        student[] arr1 = {s1,s2,s3};
        Person[] arr2 = new Person[3];

        System.arraycopy(arr1,0,arr2,0,3);

        for (int i = 0; i < arr2.length; i++) {
            student s = (student) arr2[i];
            System.out.println(s.getAge()+","+s.getName());
        }

Runtime

package Runtimedemo;

import java.io.IOException;

public class Runtimedemo {

    public static void main(String[] args) throws IOException {


        //获取runtime对象
        Runtime r = Runtime.getRuntime();
        //exit.停止虚拟机
//        r.exit(0);
        //cup的线程数
        System.out.println(r.availableProcessors());
        // 总内存大小，单位byte
        System.out.println(r.maxMemory() / 1024 / 1024);
        //总共获取的内存大小，单位byte
        System.out.println(r.totalMemory() / 1024 / 1024);
        // 剩余内存大小
        System.out.println(r.freeMemory() / 1024 / 1024);

        //执行cmd命令
        Runtime.getRuntime().exec("shutdown -s -t 1800");// 电脑会在1800秒后关机
        Runtime.getRuntime().exec("shutdowm -a");//取消关机
    }


}

Object

toString() Object的toString会返回字符串，@后面相当与地址值，一般会重写这个方法
equal:是比较两个对象是否相等 就是==符号

clone()：对象克隆
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制
浅克隆：把不管对象是基本数据类型或者引用数据类型，都完全拷贝过了，引用数据类型拷贝的是地址值，所以改变一个对象，另一个对象也会跟着改变
深拷贝：基本数据类型就直接拷贝过来，如果是字符串就会复用（直接复制的字符串是储存在串池中的，如果有一样的就会复用），引用数据类型会重新创建一个新的；
object的clone是浅克隆，如果想深克隆，需要使用第三方工具
Gson或者重写clone方法
深拷贝

package Objectdemo;

import com.google.gson.Gson;

public class test {
    public static void main(String[] args) throws CloneNotSupportedException {

        Objectdemo1 obj1 = new Objectdemo1();
        //虽然所有类都是object的子类，但是protect的挎包访问只允许在子类的内部使用，不能通过实例直接调用
        Gson gson = new Gson();
        String s = gson.toJson(obj1);
        Objectdemo1 obj2 = gson.fromJson(s,Objectdemo1.class);
        obj1.data[0] = 100;
        System.out.println(gson.toJson(obj1));
        System.out.println(gson.toJson(obj2));
    }
}

浅拷贝

package Objectdemo;

public class Objectdemo1 implements Cloneable{

    int id = 1;
    String name = "侯圆圆";
    String addr ="安仁";
    int[] data ={1,2,3,4,5,0};

    @Override
    public String toString(){
        return id + " " + name + " " + addr + " " + data[0];
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return (Objectdemo1)super.clone();
    }

}

objects

BigInteger和BigDecimal

package BigInterDemo;
import java.math.BigInteger;
import java.util.Random;
public class BigInterDemo1 {

    public static void main(String[] args) {
        // 通过构造方法创建对象
        //把val转化为radix进制的数
        BigInteger big1 = new BigInteger("123",10);
        System.out.println(big1);
        //可以看成无限大的整数 但是val字符串中只能是整数 不能是字符串和小数
        BigInteger big2 = new BigInteger("9999999999999999");
        System.out.println(big2);
        //随机生成一个在[0,2^numBits-1]的数
        BigInteger big3 = new BigInteger(10,new Random());
        System.out.println(big3);
        //通过静态方法创建一个BigInter对象
        //这个方法的特点：只能是long范围之内的数，然后就是对-16-16之间的数有优化 他们是已经创好的对象，不需要重复调用创建对象
        BigInteger big4 = BigInteger.valueOf(100);
        System.out.println(big4);
    }

}

// 注:对象一旦创建，里面的值就不能被改变

BigInterger类的常用方法

package BigInterDemo;
import java.math.BigInteger;
public class BigInterDemo2 {
    public static void main(String[] args) {
        BigInteger big1 = new BigInteger("123445");
        BigInteger big2 = new BigInteger("123445");
        //这里的equals是比较里面的值是否相等
        System.out.println(big2.equals(big1));
        BigInteger temp = big2.add(big1);
        System.out.println(temp);
        System.out.println(big2.subtract(big1));
        System.out.println(big2.max(big1));
        System.out.println(big2.min(big1));
        System.out.println(big1.multiply(big1));
        System.out.println(big1.divide(big2));
        System.out.println( big1.divideAndRemainder(big2)[0] + " " + big1.divideAndRemainder(big2)[1]);
        System.out.println(big1.pow(2));
        System.out.println(big2.intValue());
    }
}

BigInter在内部是把字符串中的数转化为二进制的补码，没32为二进制用一个数表示，然后存储在数组中

BigDecimal

// 如果是大于double的存储访问，就要使用这种构造方法获取对象
 BigDecimal big1 = new BigDecimal("0.22");
//如果小于建议使用这种静态方法获取对象
 BigDecimal big2 = BigDecimal.valueOf(10.1);

在BigDecimal的底层是把每位数字存储在一个数组中，以字符的asicll码值来存储

正则表达式

练习：把文本数据中的手机号，还有邮箱，还有电话爬取出来

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

public class BigDecimalDemo {
    public static void main(String[] args) {
        
       String regex = "([1-9]\\d{10})|(010[-]?[\\d]{8})|(400[-]?618[-]?[\\d]{4})|([a-zA-Z]+@(\\w)+(\\.([a-zA-Z]){2,3}){1,2})";
       method(regex);
    
    }

    public static void method(String regex){
        //把电话和号码还有邮箱爬取出来
        String str ="来黑马程序员学习Java,\n" +
                "电话：18512516758，18512508907\n"+
                "或者联系邮箱：boniu@itcast.cn,\n"+
                "座机电话：01036517895，010-98951256\n"+
                "邮箱：bozai@itcast.cn,\n"+
                "热线电话：400-618-9090，400-618-4000，4006184000，4006189090";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(str);

        while(m.find()){
            System.out.println(m.group());
        }
    }
}

    String s ="java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和JAva11,"+
        "因为这两个是长期支持版本,下一个长期支持版本是JAVa17,相信在未来不久JAVA17也会逐渐登上历史舞台";

        //1
//         (?=8|17|11) 这个问号代表的是前面的java，是占位符，=符号后面接的东西代表的就是java后面需要接的东西
        String regex = "((?i)java)(?=8|17|11)";
        method(regex,s);
        //2
        //
        String regex1 = "((?i)java)(?:8|11|17)";
        method(regex1,s);
       //3
        String regex2 = "((?i)java)(?!8|11|17)";
        method(regex2,s);

 String s ="java自从95年问世以来,经历了很多版本,abbbbbbbbbbbbaaaaaaaaaaaaa,目前企业中用的最多的是Java8和JAva11,"+
        "因为这两个是长期支持版本,下一个长期支持版本是JAVa17,相信在未来不久JAVA17也会逐渐登上历史舞台";

        //贪婪爬取：获取尽可能多的数据
        String regex = "ab+";
        method(regex,s);
        //非贪婪爬取 ：就是获取尽可能少的数据
        String regex1 = "ab+?";
        method(regex1,s);

//        有一段字符串：小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
//        要求1：把字符串中三个姓名之间的字母替换为vs
//        要求2：把字符串中的三个姓名切割出来
        String str = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
        System.out.println(str.replaceAll("\\w+", "vs"));
        String[] arr = str.split("\\w+");
        for (String s : arr) {
            System.out.println(s);
        }

捕获分组和非捕获分组

从正则表达式的左边开始 第一个( 开始一直到最后一个位置不中断，序号一直递增

 // 判断一个字符串的首尾字符要相等
        String regex1 = "(.).+\\1";
        System.out.println("abbbbba".matches(regex1));
        //判断一个字符串的首尾部分要相同
        String regex2 = "(.+).+\\1";
        System.out.println("ab123ab".matches(regex2));
        //判断一个字符串的首尾部分和中间部分的字符也要相同
        String regex3 = "((.)\\2*)(.+)\\1";
        System.out.println("aabbbaaa".matches(regex3));

 String str = "我要学学编编编编编程程程程程程";
        System.out.println(str.replaceAll("(.)\\1+","$1"));

JDK7以前时间相关类

Date

  Date d1 = new Date(0);//获取到当前时间过了0毫秒之后的时间
        Date d2 = new Date(365*24*60*60*1000L);
        System.out.println(d1);//直接打印他对应的时间
        System.out.println(d2);

        Date d3 = new Date();//获取当前的时间
        Date d4 = new Date();
       System.out.println(d3.getTime()>d4.getTime() ? d3 :d4);
//d3.getTime()得到的是从时间原点到这个时间过了多少毫秒值

SimpleDateFormat

常用方法

日期的格式

        //得到一个格式化时间的对象
        SimpleDateFormat sdf = new SimpleDateFormat();
        //创建一个时间的对象
        Date d = new Date();
        //打印默认格式下的日期
        System.out.println(sdf.format(d));
        //获取一个指定格式的日期
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E");
        Date d1 = new Date();
        System.out.println(sdf1.format(d1));

        //解析字符串中的日期
        String date = "2025-10-26 15-11-13";
        //创建的对象必须和日期的格式要是一样的
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        System.out.println(sdf2.parse(date));

Calendar

Calendar代表了系统当前时间的日历对象，可以单独修改，获取时间中的年月日。
细节：Calendar是一个抽象类，不能直接创建对象


细节：月份的范围是0-11，如果获取出来的是0，那么实际上获取的是第一个月
在老外的习惯里面：星期日为一周的第一天，所有通过get得到的1代表的是星期日，然后依此类推

Calendar.YRAR
Calendar.MONTH
Calendar.DAY_OF_MONTH

package CalendarDemo;

import java.util.Calendar;

public class CalendarDemo1 {
    public static void main(String[] args) {
        //因为calendar是一个抽象类 所以不能通过new获取他的对象，只能通过方法获取子类的对象 再赋值给他
        Calendar cal = Calendar.getInstance();

        //得到Date对象
        System.out.println(cal.getTime());
         //得到对应字段的值
        System.out.println(cal.get(Calendar.YEAR));
       //设置对应字段的值
        cal.set(Calendar.YEAR,2026);
        System.out.println(cal.getTime());
       //让对应字段加amount 如果超过的 那么他上一个位置会字段添加
        cal.add(Calendar.YEAR,10);
        System.out.println(cal.getTime());


    }
}

JDK8新增时间相关类

Date类

ZoneId:时区

 //获取所有的时区
        Set<String> set = ZoneId.getAvailableZoneIds();
        for(String s : set){
            System.out.println(s);
        }
        //获取当前系统默认的时区
        System.out.println(ZoneId.systemDefault());
       // 设置指定的时区
        ZoneId zoneId = ZoneId.of("Asia/Aden");
        System.out.println(zoneId);

Instant:时间戳(不带时区)

//获取当前时间的Instant对象（标准时间）
        Instant instant1 = Instant.now();
        System.out.println(instant1);
        //根据（秒、毫秒，纳秒）获取Instant对象
        Instant instant2 = Instant.ofEpochMilli(0L);
        System.out.println(instant2);
        Instant instant3 = Instant.ofEpochSecond(1L);
        System.out.println(instant3);
        Instant instant4 = Instant.ofEpochSecond(1L,1000000000);
        System.out.println(instant4);
        
        //3.指定时区
       ZonedDateTime  z = Instant.now().atZone(ZoneId.of("Chile/Continental"));
        System.out.println(z);

        //isXXX 判断 比较时间的大小
        System.out.println(instant3.isAfter(instant4));
        System.out.println(instant3.isBefore(instant4));

        //减少时间系列的方法
        Instant instant5 = instant4.minusSeconds(-10);
        System.out.println(instant4);
        System.out.println(instant5);

        //添加时间系列的方法
        Instant instant6 = instant5.plusSeconds(20);
        System.out.println(instant6);

ZoneDateTime：带时区的时间

 // 获取ZonedDateTime对象
        ZonedDateTime zdt = ZonedDateTime.now();
        System.out.println(zdt);
        ZonedDateTime zdt1 = ZonedDateTime.of(2025,10,27,10,24,10,0,ZoneId.of("Asia/Shanghai"));
        System.out.println(zdt1);
        
        //修改时间系列的方法
        ZonedDateTime zdt2 =  zdt1.withYear(2030);
        System.out.println(zdt2);
        //减少时间系列的方法
        ZonedDateTime zdt3 = zdt1.minusMonths(10L);
        //添加时间系列的方法
        ZonedDateTime zdt4 =zdt1.plusMonths(10L);
        System.out.println(zdt3);
        System.out.println(zdt4);

日期格式化类：SimpleDateFormat

DateTimeFormatter 用于时间的格式化和解析

 //解析、格式化器
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd HH:mm:ss");
        //获取时间对象
        ZonedDateTime z = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        //格式化时间
        System.out.println(dtf.format(z));

日历类：Calendar(LocalDate:年月日,LocalTime:时分秒,LocalDateTime:年月日时分秒)

 //获取当前时间
        LocalDate ld = LocalDate.now();
        //获取指定的时间
        LocalDate ld1 = LocalDate.of(2023,10,10);
        System.out.println(ld1);
        int year = ld.getYear();
        System.out.println(year);
        System.out.println(ld);

        ld = ld.withYear(2030);
        ld = ld.plusYears(100);
        ld = ld.minusYears(1200);
        System.out.println(ld);


        LocalTime lt = LocalTime.now();

        System.out.println(lt);

        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);
       ld = ldt.toLocalDate();
       lt = ldt.toLocalTime();

        System.out.println(ld);
        System.out.println(lt);

工具类

Duration:时间间隔（秒，纳秒）

  LocalDateTime ld = LocalDateTime.now();

        LocalDateTime ld1 = LocalDateTime.of(2000,1,1,10,11,20);

        Duration d = Duration.between(ld1,ld);

        System.out.println(d);
        System.out.println(d.toDays());
        System.out.println(d.toNanos());

Period:时间间隔（年月日）

 LocalDate ld = LocalDate.now();
        System.out.println(ld);
        LocalDate ld1 = LocalDate.of(2000,1,1);
        Period d = Period.between(ld1,ld);
        System.out.println(d);
        //获取相差的年 月 日
        System.out.println(d.getYears());
        System.out.println(d.getMonths());
        System.out.println(d.getDays());
        //获取之间间隔的所有的月
        System.out.println(d.toTotalMonths());

ChronoInit:时间间隔（所有单位）

这个类是最常用的包含所有的的时间间隔

 LocalDateTime today = LocalDateTime.now();

        System.out.println(today);

        LocalDateTime birthday = LocalDateTime.of(2000,1,1,0,0,0);

        System.out.println(birthday);

        //相差的年数
        System.out.println(ChronoUnit.YEARS.between(birthday, today));
       // 相差的纪元数
        System.out.println(ChronoUnit.ERAS.between(birthday, today));

包装类

包装类：用一个对象，把基本数据类型包装起来

使用场景：就是当参数需要传入一个对象时，基本数据类型不行，这是就只能用包装类 还有就是集合只能引用数据类型，如果想存基本数据类型，就要用他们对应的包装类

// 基本数据类型对应的包装类
byte     ----> 		Byte
short    ----> 		Short
char     ----> 		Character
int      ----> 		Integer
long     ----> 		Long
float    ----> 		Float
double   ----> 		Double
boolean  ----> 		Boolean

       //获取整数的包装类
        Integer i1 = new Integer(10);
        System.out.println(i1);

        Integer i2 = Integer.valueOf(10);
        System.out.println(i2);

 //在jdk5之后对Integer进行了优化，对于-128-127直接的整数，Integer会提创建好类 然后如果在范围以内的数，就能直接用已经创建好的对象，所以如果是在这个范围以内的话，他们的地址值是一样的
        Integer i3 = Integer.valueOf(10);
        System.out.println(i3 == i2);
//在jdk5之后 Integer可以直接复制 和进行运算 在对象的内部会自动的进行拆箱和装箱操作
        Integer i4  = 10;
        Integer i5  = 20;
        Integer i6 = i4+i5;
        System.out.println(i6); 

  Integer i1 = 10;
        //获取二进制
        System.out.println(Integer.toBinaryString(i1));
        //获取八进制
        System.out.println(Integer.toOctalString(i1));
        //获取十六进制
        System.out.println(Integer.toHexString(i1));

        //细节：八中包装类中除了Character，其它都有对饮的parseXxx的方法，把字符串转化为对应类型的数据
        String binaryNum = "111";
        System.out.println(Integer.parseInt(binaryNum));
        System.out.println(Double.parseDouble(binaryNum));

综合练习

      //这是jdk7以前的球活了多久的方法
      String birthday1 = "2006-09-25";
      SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd");
      long old = sdf.parse(birthday1).getTime();

      long now = System.currentTimeMillis();
      System.out.println((now-old)/1000/60/60/24);

      
      //这是jdk8之后求活了多少天的方法
      LocalDate birthday = LocalDate.of(2006,9,25);
      LocalDate ld = LocalDate.now();
      System.out.println(ChronoUnit.DAYS.between(birthday, ld));

//判断一年是否是闰年

 //jdk7以前
        Calendar c = Calendar.getInstance();
        c.set(2000,2,1);
        c.add(Calendar.DATE,-1);
        System.out.println(c.get(Calendar.DATE));
        //jdk8以前
        LocalDate ld = LocalDate.of(2000,3,1);
        ld = ld.minusDays(1);
        System.out.println(ld.getDayOfMonth());

        //直接调用一个方法
        System.out.println(ld.isLeapYear());

Arrays

int[] arr = {1,2,3,4,5,6,7,8,9,10};
        Integer[] arr2 = {2,3,5,6,2,7,9,0,12};
        // String toString(数组)
        System.out.println(Arrays.toString(arr));
        // int binarySearch(有序数组,查找值);
        System.out.println(Arrays.binarySearch(arr, 10));
       // int[] copyof(原数组，新数组长度);
        int[] temp = Arrays.copyOf(arr,12);
        System.out.println(Arrays.toString(temp));
        // int[] copyOfRange(原数组,起始索引,结束索引);
        temp = Arrays.copyOfRange(arr,1,12);
        System.out.println(Arrays.toString(temp));
        // void fill(数组,元素) 相当于给数组初始化
        Arrays.fill(temp,100);
        System.out.println(Arrays.toString(temp));
        //void sort(数组) 默认是升序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
        //void sort(数组,排序规则); 这个排序规则是一个接口的实现类 因为这个排序规则只会被用一次，所以可以用匿名内部类
        Arrays.sort(arr2,new Comparator<Integer>() {
            @Override
            public int compare(Integer o1,Integer o2){
               //o2是在有序的数组中，o1是在无序的数组中
               //如果o1-o2大于0就把o1放在有序的数组的后面否则就放在前面,所以这就是升序，如果是02-01的话 就是降序
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(arr2));

Lambda表达式

lambda表达式的基本作用：
简化函数式接口的匿名内部类的写法
lambda表达式的使用前提：
必须是接口的匿名内部列，接口中只能有一个抽象方法
lambda的好处：
lambda是一个匿名函数，可以写出更简洁更灵活的代码。

package suanfa;

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

       //因为方法的参数是一个接口所有传参需要传入接口的实现类 又因为只需要用一次所以可以使用匿名内部类
       method(new Swim() {
           @Override
           public void Swimming() {
               System.out.println("我正在游泳");
           }
       });
      //这是lambda表达式
       method(()->{
           System.out.println("我正在游泳");
       });


    }

    public static void method(Swim s){
        s.Swimming();
    }

}

interface Swim{
    public abstract void Swimming();
}

lambda表达式的省略写法
省略核心：可推导，可省略
1.参数类型可以不写
2.如果只有一个参数，参数类型可以省略，同时（）也可以省略
3.如果lambda表达式的方法体只有一行，那么大括号，分号，return可以省略不写，当时需要同时省略

Integer[] arr = {3,2,1,6,4,3,7,8,10};
        //正常的写法
        Arrays.sort(arr,new Comparator<Integer>(){
            @Override
            public int compare(Integer o1,Integer o2){
                return o1 - o2;
            }
        });

        //正常的lambda表达式
        Arrays.sort(arr,(Integer o1,Integer o2)->{
                return o1 - o2;
            });
        //省略的lambda表达式
        Arrays.sort(arr,(o1,o2)->o1 - o2);