Java基础篇-4

常用API以及基础算法

记住类名和作用，其余用API帮助文档

Math

• 是一个帮助我们用于进行数学计算的工具类
• 私有化构造方法，所有的方法都是静态的

常用方法：

• abs(int a) 获取参数绝对值
• ceil(double a) 向上取整
• floor(double a) 向下取整
• round(float a) 四舍五入
• max(int a, int b)
• pow(double a, double b) 返回a的b次幂的值
• random() 返回值为double的随机值，范围[0.0,1.0]
• cbrt() 开立方根
• sqrt() 开平方根

System

• exit(int status) 终止当前运行的java虚拟机
• currentTimeMillis() 返回当前系统的时间毫秒值形式（前后都写一个，可以获取程序运行总时间）
• arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数) 数组拷贝

   int[] arr1 = (1,2,3,4,5,6,7,8,9,10);
   int[] arr2 = new int[10];

   System.arraycopy(arr1, 0, arr2, 4, 3);
   //arr2:0000123000

拷贝细节:

1. 如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错
2. 在拷贝的时候需要考虑数组的长度，如果超出范围也会报错
3. 如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型

Runtime

表示当前虚拟机的运行环境
非静态，需要建立对象调用方法

Object和Objects

object是ava中的顶级父类。所有的类都直接或间接的继承于object类。
object类中的方法可以被所有子类访问，所以我们要学习object类和其中的方法
只有无参的构造方法

三种常见的成员方法：

toString方法:

如果我们打印一个对象，想要看到属性值的话，那么就重写toString方法就可以了
在重写的方法中，把对象的属性值进行拼接

equals方法：

如果没有重写equals方法，那么默认使用object中的方法进行比较，比较的是地址值是否相等
一般来讲地址值意义不大，所以会重写，重写之后比较的就是对象内部的属性值
看被谁调用，就是哪里的方法。

clone方法：

对象克隆： 把A对象的属性值完全拷贝给B对象，也叫对象拷贝,对象复制
由于是protected属性,需要重写
默认浅克隆
书写细节:

1. 重写object中的clone方法
2. 让javabean类实现Cloneable接口
3. 创建原对象并调用clone就可以了

深浅克隆

浅克隆：
不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝
基本数据类型拷贝过来的是具体的数据，引用数据类型拷贝过来的是地址值。
Object类默认的是浅克隆

• 字符串复用
• 引用数据类型会重新创建新的
• 重写或者使用第三方工具类

深克隆：
基本数据类型拷贝过来，字符串复用，引用数据类型会重新创建新的
如果需要深克隆需要重写方法或者使用第三方工具类

Objects

Objects是一个工具类，提供了一些方法去完成一些功能。

BigInteger构造方法：

1. 如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取
2. 如果BigInteger表示的超出long的范围，可以用构造方法获取
3. 对象一旦创建，BigInteger内部记录的值不能发生改变
4. 只要进行计算都会产生一个新的BigInteger对象

细节部分：

1. 字符串中必须是整数，且要与进制吻合
2. 静态方法：-16 ~ 16是已经创建好的BigInteger对象，多次获取不会创建新的

构造方法创建对象
    BigInteger bd1 =new BigInteger(4,new Random());
//0~2的4次方-1之间获取

//4.静态方法获取BigInteger的对象，内部有优化
    BigInteger bd5 = BigInteger.valueOf(100);

BigInteger常见成员方法：

import java.math.BigInteger;

BigInteger bd1 = BigInteger.valueOf(10);
BigInteger bd2 = BigInteger.valueOf(5);
//成员方法创建对象
BigInteger bd3 = bd1.add(bd2);
BigInteger[] arr = bd1.divideAndRemainder(bd2);
System.out.println(arr[0]);
System.out.println(arr[1]);
//arr[0]是商，arr[1]是余数

boolean result = bd1.equals(bd2);

BigInteger bd4 = bd1.pow(2);

BigInteger bd5 = bd1.max(bd2);
System.out .println(bd5 == bd1);//true
System.out .println(bd5 == bd2)//false

BigInteger bd6 = BigInteger.valueOf(2147483647L);
int i = bd6.intValue();

BigInteger bd6 = BigInteger.valueOf(200);
double v = bd6

BigInteger底层存储方式

BigDecimal

小数转为二进制位数太多

• 用于小数的精确计算
• 用来表示很大的小数

//1.通过传递double类型的小数来创建是不精确的，所以不建议使用
    BigDecimal bd1 = new BigDecimal(0.01);
    BigDecimal bd2 = new BigDecimal(0.09);

//2.通过传递字符串表示的小数来创建对象
    BigDecimal bd3 = new BigDecimal("0.01");
    BigDecimal bd4 = new BigDecimal("0.09");
    BigDecimal bd5 = bd3.add(bd4);
//3.通过静态方法获取对象
    BigDecimal bd6 = BigDecimal.valueof(1);

//1.如果要表示的数字不大，没有超出double的取值范围，建议使用静态方法
//2.如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
//3.如果我们传递的是0~10之间的整数，包含0，包含10，那么方法会返回已经创建好的对象，不会重新new

//1.加法
    BigDecimal bd1 = BigDecimal.valueof(10.0);
    BigDecimal bd2 = BigDecimal.valueof(3.0);
    BigDecimal bd3 = bd1.add(bd2);
//2.减法
    BigDecimal bd4 = bd1,subtract(bd2);
//3.乘法
    BigDecimal bd5 = bd1.multiply(bd2);
//4.除法
    BigDecimal bd6 = bd1.divide(bd2, 2, RoundingMode.HALF_UP);
    System.out.print1n(bd6);//53.33

BigDecimal底层存储方式

按照字符存储，每个字符对应的数字

正则表达式

System.out.println(qq.matches("[1-9]\\d{5,19}"));

作用1：检验字符串是否满足规则
作用2：在一段文本中查找满足要求的内容

System.out.println("a".matches("[abc]")); // true
System.out.println("ab",matches("[abc]")); // false
System.out.println("ab",matches("[abc][abc]")); // true

System.out.println("a".matches("[a-zA-Z0-9]")); //false
System.out.println("aa".matches("[a-zA-Z]")); //false

// [a-z&&[^m-p]] a到z和除了m到p的交集。 (等同于[a-lq-z])

System.out.println("\"");
// \表示转义字符，改变后面那个字符原本的含义
 ```java
 System.out.println("2442faa" .matches(" \\w{6,}"));//true
 System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//必须是数字和字符，必须是4位  true

//拿着一个正确的数据，从左到右依次去写。
//13115252525
String regex1 = "1[3-9]\\d(9)";
String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";//2565566q@qq.com  2565566q@qq.com.cn  .com.cn这可以出现两次,看成一组，用()

//24小时的正则表达式
String regex4 = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
//优化：
String regex5 ="([e1]\\d|2[0-3])(:[-5]\\d){2}";

//身份证号码的简单校验:
//18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x
String regex2 = "[1-9]\\d(16)(\dlx|x)";
String regex3 = "[1-9]\\d(16)[\\dXx]";
String regex5 = "[1-9]\ld(16}(\\d|(?i)x)";

身份认证严格校验:

小结：

爬虫

       //1.获取正则表达式的对象
       Pattern p = Pattern.compile("Java\\d{0,2}");
       //2.获取文本匹配器的对象
       //拿着m去读取str，找符合p规则的子串
       Matcher m = p.matcher(str);

       //3.利用循环获取
       while (m.find()) {
           String s = m.group();
           System.out.println(s);

带条件爬取

//需求1:爬取版本号为8，11.17的Java文本，但是只要Java，不显示版本号。
//需求2:爬取版本号为8，11，17的Java文本。正确爬取结果为:Java8 Java11 Java17 Java17
//需求3:爬取除了版本号为8，11,17的Java文本，
        String s = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        //1.定义正则表达式
        //?理解为前面的数据Java
        //= 表示Java后面要跟随的数据
        //但是在获取的时候，只获取前半部分
        //需求1:
        String regex1 = "((?i)Java)(?=8|11|17)";
        //需求2:
       String regex2 ="((?i)Java)(8|11|17)";
       String regex3 ="((?i)Java)(?:8|11|17)"; //第二个?表示前面忽略大小写 : 获取整体所有的东西
       //需求3:
       String regex4 = "((?i)Java)(?!8|11|17)";

        Pattern p = Pattern.compile(regex4);
        Matcher m = p.matcher(s);
        while (m.find()) {
            System.out.println(m.group());
        }

贪婪爬取

贪婪爬取: 在爬取数据的时候尽可能的多获取数据
非贪婪爬取: 在爬取数据的时候尽可能的少获取数据

    String regex = "ab+";//abbbbb
    String regex = "ab+?";//ab

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

    String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwg12312小惠惠";
    String result1 = s.replaceAll("[\\w&&[^_]]+", "vs");
//方法在底层跟之前一样也会创建文本解析器的对象
//然后从头开始去读取字符串中的内容，只要有满足的，那么就用第二个参数去替换。
    
    public String[] split(String regex)

//参数regex表示正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。
    String[] arr = s.split("[\\w&&[^_]]+");
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }

分组就是一个小括号
每组是有组号的，也就是序号

• 规则1: 从1开始，连续不间断
• 规则2: 以左括号为基准，最左边的是第一组，其次为第二组，以此类推
  红1蓝2绿3

捕获分组：

// \\组号：表示把第X组的内容拿出来再用一次（内部使用）
String regex1 = "(.).+\\1"; //判断开始部分和结束部分是否一样
String regex2 = "(.+).+\\1";//判断开始部分和结束部分是否一样,可以有多个字符

String regex3 ="((.)\\2*).+\\1";//开始部分内部每个字符也要一致

 //重复内容改为一个
// (.) 表示把重复内容的第一个字符看做一组
// \\1 表示第一字符再次出现
//+ 至少一次
//$1 表示把正则表达式中第一组的内容，再拿出来用(外部使用)

非捕获分组：

//特点:不占用组号
//这里\\1报错原因:(?:)就是非捕获分组，此时是不占用组号的。
//(?:) (?=) (?!) 都是非捕获分组//更多的使用第一个
    String regex1 ="[1-9]\\d{16}(?:\\d|x|x)\\1";// \\1会报错
    String regex2 ="[1-9]\\d{16}(\\d|x|x)\\1";

时间

Date类

//1、如何创建日期对象?
Date date = new Date();
Date date = new Date(指定毫秒值);
//2、如何修改时间对象中的毫秒值
setTime(毫秒值);
//3、如何获取时对象中的毫秒值
getTime();

SimpleDateFormat类

• 格式化:把时间变成我们喜欢的格式
• 解析:把字符串表示的时间变成Date对象。

//1.利用空参构造创建SimpleDateFormat对象，默认格式
    SimpleDateFormat sdf1 = new SimpleDateFormat();
    Date d1 = new Date(0L);
    String str1 = sdf1.format(d1);
    System.out.println(str1);//1970/1/1 上午8:00
//2.利用带参构造创建simpleDateFormat对象，指定格式
    SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EE");
    String str2 = sdf2.format(d1);
    System.out.printIn(str2);//1970年01月01日 08:00:00 周四

//1.可以通过2e-11-11进行解析，解析成一个Date对象String str = "2000-11-11";
//2.解析
    SimpleDateFormat sdf1 = new SimpleDateFormat( "yyyy-MM-dd");
    Date date = sdf1.parse(str);
//3.格式化
    SimpleDateFormat sdf2 = new SimpleDateFormat( "yyyy年MM月dd日");
    String result = sdf2.format(date);System.out.printIn(result);

Calendar类

//1.获取日历对象
//细节1:Calendar是一个抽象类，不能直接new，而是通过一个静态方法获取到子类对象
//底层原理:
//会根据系统的不同时区来获取不同的日历对象,默认表示当前时间。
//把会把时间中的纪元，年，月，日，时，分，秒，星期，等等的都放到一个数组当中
//细节2:
//月份: 范围e~11 如果获取出来的是e.那么实际上是1月。
//星期: 星期日是一周中的第一天 1(星期日)
    
    Calendar c = Calendar.getInstance();//获取对象

//1:  年
//2:  月
//3:  一年中的第几周
//4:  一个月中的第几周
//5:  一个月中的第几天(日期)
//在calendar类中，把索引对应的数字都定义成常量,直接写就行。
    int year = c.get(Calendar.YEAR);
    int month = c.get(Calendar .MONTH) + 1;
    int date = c.get(Calendar.DAY_OF_MONTH);
    int week = c.get(Calendar.DAY_OF_WEEK);

//set方法
    c.set(Calendar.YEAR,2000);
    c.set(Calendar.MONTH,11);//12月
    c.set(Calendar.MONTH,12);//2001年1月

//add方法
    c.add(Calendar.MONTH, 1);
    c.add(Calendar.MONTH, -1);

JDK8新增时间相关类

//ZoneId时区
   //1.获取所有的时区名称
   Set<String> zoneIds = ZoneId.getAvailableZoneIds();
   System.out.println(zoneIds.size());//600
   System.out.printIn(zoneIds);
   //2.获取当前系统的默认时区
   ZoneId zoneId = ZoneId.systemDefault();
   System.out.printIn(zoneId);//Asia/Shanghai
   //3.获取指定时区
   ZoneId.of("Asia/Pontianak");

//Instant 时间戳

    Instant now = Instant.now();
    Instant instant1 = Instant.ofEpochMilli(0L);
    Instant instant2 = Instant.ofEpochMilli(1000000L);
    //静态方法类名去调用

    Instant.now().atZone(Zoned.of("Asia/Shanghai"));
    
   
    ZonedDateTime time3 = time2.withYear(2); //withXxx 修改时间系列的方法

    boolean result1 = instant1.isBefore(instant2);  //true
    boolean result2 = instant1.isAfter(instant2);  //false

    Instant instant3 = instant2.minusSeconds(1);  //减一秒

//细节:
//JDK8新增的时间对象都是不可变的
//如果我们修改了，减少了，增加了时间
//那么调用者是不会发生改变的，产生一个新的时间。

//日期格式化类
//DateTimeFormatter

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

//日历类
    //LocalDate
    LocalDate nowDate = LocalDate.now();
    getMonth()
    getMonthValue()
    getDayOfWeek()
    isBefore()
    isAfter()
    withYear()
    plusDays()//增加年月日
    minusYears()//减少年月日
    
    // 判断今天是否是你的生日
    LocalDate birDate = LocalDate.of(2000, 1， 1);
    LocalDate nowDate1 = LocalDate.now();

    MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
    MonthDay nowMd = MonthDay.from(nowDate1);

    System.out.printIn("今天是你的生日吗?" + birMd.equals(nowMd));//今天是你的生日吗?

//LocalTime
    getMinute();
    getSecond();
    getNano();
   //其余方法同上

//LocalDateTime

    LocalDate birthDate = LocalDate.of(2000, 1, 1);
    System.out.println(birthDate);

    Period period = Period.between(birthDate，today);//第二个参数减第一个参数
//Duration
    Duration duration = Duration.between(birthDate,today);//第二个参数减第一个参数
//转换方法
    toDays()
    toHours() 
    toMinutes()
    toMillis()
    toNanos()

//ChronoUnit
    ChronoUnit.YEARS.between(birthDate，today);
    

包装类

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

Integer

构造方法和静态方法获取对象的区别

//构造方法都是创建一个新的对象
    Integer i10 = new Integer( value: 127);
//静态方法：在一定范围内，是同一对象
    Integer i6 = Integer.valueOf(127);
//以上是JDK5之前的
    Integer i1 = 10;//获取对象直接赋值
    Integer i2 = new (10);
    int i = i1 + i2;
//JDK以后，integer和int可以看成一个东西

Integer成员方法

//1.把整数转成二进制
    String str1 = Integer.toBinaryString(100);
//细节1:
//在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
//细节2:
//8种包装类当中，除了character都有对应的parseXxx的方法，进行类型转换
    String str = "true";
    boolean b = Boolean.parseBoolean(str);
    System.out.println(b);
//改进键盘录入，不管什么类型，统一使用nextLine
//特点：遇到回车才停止
    String line = sc.nextLine();

    int i = Integer.parseInt(line);
    double v = Double.parseDouble(line)

p175 176练习