Java程序设计--常用API(下)（十一）

已于 2023-11-27 10:57:00 修改
阅读量480 收藏 1
点赞数 1
分类专栏： Java 文章标签： java 包装类 正则表达式 数据结构 Lambda
于 2022-03-22 19:19:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ASHIYI66/article/details/123512641
版权

常用API

1、日期与时间

1.1 Date

Date类代表当前所在系统的日期时间信息。

Date的构造器

名称说明
public Date()创建一个Date对象，代表的是系统当前此刻日期时间。

Date的常用方法

名称说明
public long getTime()返回从1970年1月1日00:00:00走到此刻的总的毫秒数

时间毫秒值->日期对象

构造器说明
public Date(long time)把时间毫秒值转换成Date日期对象。
Date方法说明
public void setTime(long time)设置日期对象的时间为当前时间毫秒值对应的时间
import java.time.Instant;
import java.time.ZoneId;
import java.util.Date;

/**
    目标：学会使用Date类处理时间，获取时间的信息
 */
public class DateDemo {
    public static void main(String[] args) {
        // 1、创建一个Date类的对象：代表系统此刻日期时间对象
        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;

        // 3、把时间毫秒值转换成对应的日期对象。
        // Date d2 = new Date(time2);
        // System.out.println(d2);

        Date d3 = new Date();
        d3.setTime(time2);
        System.out.println(d3);

    }
}

1.2 SimpleDateFormat

可以去完成日期时间的格式化操作格式化

构造器

构造器说明
public SimpleDateFormat(String pattern)构造一个SimpleDateFormat，使用指定的格式

格式化方法

格式化方法说明
public final String format(Date date)将日期格式化成日期/时间字符串
public final String format(Object time)将时间毫秒值式化成日期/时间字符串

格式化的时间形式的常用的模式对应关系：
在这里插入图片描述

import javax.xml.crypto.Data;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo{
    public static void main(String[] args) throws ParseException {
        // 目标: 学会使用SimpleDateFormat解析字符串时间成为日期对象。
        // 有一个时间 2021年08月06日 11:11:11 往后 2天 14小时 49分 06秒后的时间是多少。
        // 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));
    }
}

1.3 Calendar

Calendar代表了系统此刻日期对应的日历对象。

Calendar是一个抽象类，不能直接创建对象。

Calendar日历类创建日历对象的方法

方法名说明
public static calendar getInstance()获取当前日历对象

Calendar常用方法

方法名说明
public int get(int field)取日期中的某个字段信息。
public void set(int field,int value)修改日历的某个字段信息。
public void add(int field,int amount)为某个字段增加/减少指定的值
public final Date getTime()拿到此刻日期对象。
public long getTimeInMillis()拿到此刻时间毫秒值

注意:calendar是可变日期对象，一旦修改后其对象本身表示的时间将产生变化。

import javax.xml.crypto.Data;
import java.util.Calendar;
import java.util.Date;

/**
    目标：日历类Calendar的使用,可以得到更加丰富的信息。
 */
public class CalendarDemo{
    public static void main(String[] args) {
        // 1、拿到系统此刻日历对象
        Calendar cal = Calendar.getInstance();
        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;
        System.out.println(mm);

        int days = cal.get(Calendar.DAY_OF_YEAR) ;
        System.out.println(days);

        // 3、public void set(int field,int value)：修改日历的某个字段信息。
        // cal.set(Calendar.HOUR , 12);
        // System.out.println(cal);

        // 4.public void add(int field,int amount)：为某个字段增加/减少指定的值
        // 请问64天后是什么时间
        cal.add(Calendar.DAY_OF_YEAR , 64);
        cal.add(Calendar.MINUTE , 59);

        //  5.public final Date getTime(): 拿到此刻日期对象。
        Date d = cal.getTime();
        System.out.println(d);

        //  6.public long getTimeInMillis(): 拿到此刻时间毫秒值
        long time = cal.getTimeInMillis();
        System.out.println(time);

    }
}

1.4 LocalDate、LocalTime、LocalDateTime

从Java 8开始，java.time包提供了新的日期和时间API

LocalDate、LocalTime、LocalDateTim他们分别表示日期，时间，日期时间对象，他们的类的实例是不可变的对象。他们三者构建对象和API都是通用的。

构建对象的方式如下

方法名说明
public static Xxxx now();静态方法，根据当前时间创建对象LocaDate localDate = LocalDate.now();LocalTime localTime = LocalTime.now();LocalDateTime localDateTime = LocalDateTime.now();
public static Xxox of(…);静态方法，指定日期/时间创建对象LocalDate localDate1 =LocalDate.of(2099,11,11);LocalTime localTime1 = LocalTime.of(11,11,11);LocalDateTime localDateTime1 = LocalDateTime.of(2020,10,6,13,23,43);

LocalDate、LocalTime、LocalDateTime获取信息的API

方法名说明
public int geYear()获取年
public int getMonthValue()获取月份(1-12)
Public int getDayOfMonth()获取月中第几天乘法
Public int getDayOfYear()获取年中第几天
Public DayOfWeek getDayOfWeek()获取星期

在这里插入图片描述
LocalDateTime的转换API

方法名说明
public LocalDate toLocalDate()转换成一个LocalDate对象
public LocalTime toLocalTime()转换成一个LocalTime对象

修改相关的API

这些方法返回的是一个新的实例引用，因为LocalDateTime 、LocaIDate 、LocalTime都是不可变的

方法名说明
plusDays, plusWeeks, plusMonths, plusYears向当前LocalDate 对象添加几天、几周、几个月、几年
minusDays, minusWeeks, minusMonths, minusYears从当前LocalDate 对象减去几天、几周、几个月、几年
withDayOfMonth, withDayOfYear, withMonth, withYear将月份天数、年份天数、月份、年份修改为指定的值并返回新的LocalDate 对象
isBefore, isAfter比较两个LocalDate
import java.time.LocalDate;
import java.time.Month;

public class Demo01LocalDate {
    public static void main(String[] args) {
        // 1、获取本地日期对象。
        LocalDate nowDate = LocalDate.now();
        System.out.println("今天的日期：" + nowDate);//今天的日期：

        int year = nowDate.getYear();
        System.out.println("year：" + year);


        int month = nowDate.getMonthValue();
        System.out.println("month：" + month);

        int day = nowDate.getDayOfMonth();
        System.out.println("day：" + day);

        //当年的第几天
        int dayOfYear = nowDate.getDayOfYear();
        System.out.println("dayOfYear：" + dayOfYear);

        //星期
        System.out.println(nowDate.getDayOfWeek());
        System.out.println(nowDate.getDayOfWeek().getValue());

        //月份
        System.out.println(nowDate.getMonth());//AUGUST
        System.out.println(nowDate.getMonth().getValue());//8

        System.out.println("------------------------");
        LocalDate bt = LocalDate.of(1991, 11, 11);
        System.out.println(bt);//直接传入对应的年月日
        System.out.println(LocalDate.of(1991, Month.NOVEMBER, 11));//相对上面只是把月换成了枚举
    }
}

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;

public class Demo02LocalTime {
    public static void main(String[] args) {
        // 1、获取本地时间对象。
        LocalTime nowTime = LocalTime.now();
        System.out.println("今天的时间：" + nowTime);//今天的时间：

        int hour = nowTime.getHour();//时
        System.out.println("hour：" + hour);//hour：

        int minute = nowTime.getMinute();//分
        System.out.println("minute：" + minute);//minute：

        int second = nowTime.getSecond();//秒
        System.out.println("second：" + second);//second：

        int nano = nowTime.getNano();//纳秒
        System.out.println("nano：" + nano);//nano：

        System.out.println("-----");
        System.out.println(LocalTime.of(8, 20));//时分
        System.out.println(LocalTime.of(8, 20, 30));//时分秒
        System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒
        LocalTime mTime = LocalTime.of(8, 20, 30, 150);

        System.out.println("---------------");
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20));
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30));
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30, 150));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30, 150));
    }
}

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo03LocalDateTime {
    public static void main(String[] args) {
        // 日期 时间
        LocalDateTime nowDateTime = LocalDateTime.now();
        System.out.println("今天是：" + nowDateTime);//今天是：
        System.out.println(nowDateTime.getYear());//年
        System.out.println(nowDateTime.getMonthValue());//月
        System.out.println(nowDateTime.getDayOfMonth());//日
        System.out.println(nowDateTime.getHour());//时
        System.out.println(nowDateTime.getMinute());//分
        System.out.println(nowDateTime.getSecond());//秒
        System.out.println(nowDateTime.getNano());//纳秒
        //日：当年的第几天
        System.out.println("dayOfYear：" + nowDateTime.getDayOfYear());//dayOfYear：249
        //星期
        System.out.println(nowDateTime.getDayOfWeek());//THURSDAY
        System.out.println(nowDateTime.getDayOfWeek().getValue());//4
        //月份
        System.out.println(nowDateTime.getMonth());//SEPTEMBER
        System.out.println(nowDateTime.getMonth().getValue());//9


        LocalDate ld = nowDateTime.toLocalDate();
        System.out.println(ld);

        LocalTime lt = nowDateTime.toLocalTime();
        System.out.println(lt.getHour());
        System.out.println(lt.getMinute());
        System.out.println(lt.getSecond());
    }
}

1.5 Instant

JDK8获取时间戳特别简单，且功能更丰富。Instant类由一个静态的工厂方法now()可以返回当前时间戳。

import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;

public class InstantDemo {
    public static void main(String[] args) {
        // 1、得到一个Instant时间戳对象
        Instant instant = Instant.now();
        System.out.println(instant);

        // 2、系统此刻的时间戳怎么办？
        Instant instant1 = Instant.now();
        System.out.println(instant1.atZone(ZoneId.systemDefault()));

        // 3、如何去返回Date对象
        Date date = Date.from(instant);
        System.out.println(date);

        Instant i2 = date.toInstant();
        System.out.println(i2);
    }
}

时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是类似JDK8以前的Date.lnstant和Date这两个类可以进行转换。

1.6 DateTimeFormatter

在JDK8中，引入了一个全新的日期与时间格式器DateTimeFormatter。
正反都能调用format方法。

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeFormatDemo {
    public static void main(String[] args) {
        // 本地此刻  日期时间 对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);

        // 解析/格式化器
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EEE a");
        // 正向格式化
        System.out.println(dtf.format(ldt));
        // 逆向格式化
        System.out.println(ldt.format(dtf));

        // 解析字符串时间
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 解析当前字符串时间成为本地日期时间对象
        LocalDateTime ldt1 = LocalDateTime.parse("2019-11-11 11:11:11" ,  dtf1);
        System.out.println(ldt1);
        System.out.println(ldt1.getDayOfYear());
    }
}

1.7 Period/Duration

Period

在Java8中，我们可以使用以下类来计算曰期间隔差异: java.time.Period

主要是Period 类方法 getYears()， getMonths()和getDays()来计算,只能精确到年月日。用于计算两个“时间”间隔。用于LocalDate 之间的比较。

import java.time.LocalDate;
import java.time.Period;

public class PeriodDemo {
    public static void main(String[] args) {
        // 当前本地 年月日
        LocalDate today = LocalDate.now();
        System.out.println(today);//

        // 生日的 年月日
        LocalDate birthDate = LocalDate.of(1998, 10, 13);
        System.out.println(birthDate);

        Period period = Period.between(birthDate, today);//第二个参数减第一个参数

        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }
}

Duration

在Java8中，我们可以使用以下类来计算时间间隔差异: java.time.Duration提供了使用基于时间的值测量时间量的方法。用于计算两个“日期”间隔。

用于LocalDateTime 之间的比较。也可用于Instant之间的比较。

import java.time.Duration;
import java.time.LocalDateTime;

public class DurationDemo {
    public static void main(String[] args) {
        // 本地日期时间对象。
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        // 出生的日期时间对象
        LocalDateTime birthDate = LocalDateTime.of(2021,8
                ,06,01,00,00);

        System.out.println(birthDate);

        Duration duration = Duration.between(  today , birthDate);//第二个参数减第一个参数

        System.out.println(duration.toDays());//两个时间差的天数
        System.out.println(duration.toHours());//两个时间差的小时数
        System.out.println(duration.toMinutes());//两个时间差的分钟数
        System.out.println(duration.toMillis());//两个时间差的毫秒数
        System.out.println(duration.toNanos());//两个时间差的纳秒数
    }
}

1.8 ChronoUnit

java.time.temporal.ChronoUnit

ChronoUnit类可用于在单个时间单位内测量一段时间，这个工具类是最全的了，可以用于比较所有的时间单位

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitDemo {
    public static void main(String[] args) {
        // 本地日期时间对象：此刻的
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        // 生日时间
        LocalDateTime birthDate = LocalDateTime.of(1990,10,1,
                10,50,59);
        System.out.println(birthDate);

        System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate, today));
        System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate, today));
        System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate, today));
        System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate, today));
        System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate, today));
        System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate, today));
        System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate, today));
        System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate, today));
        System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate, today));
        System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate, today));
        System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate, today));
        System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate, today));
        System.out.println("相差的世纪（百年）数：" + ChronoUnit.CENTURIES.between(birthDate, today));
        System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate, today));
        System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate, today));
    }
}

2、包装类

包装类就是8种基本数据类型对应的引用类型。

基本数据类型引用数据类型
byteByte
shortShort
intInteger
longLong
charCharacter
floatFloat
doubleDouble
booleanBoolean

Java为了实现一切皆对象，为8种基本类型提供了对应的引用类型。集合和泛型其实也只能支持包装类型，不支持基本数据类型。

自动装箱:基本类型的数据和变量可以直接赋值给包装类型的变量。

自动拆箱:包装类型的变量可以直接赋值给基本数据类型的变量。

包装类的特有功能

包装类的变量的默认值可以是null，容错率更高。

可以把基本类型的数据转换成字符串类型

调用toString()方法得到字符串结果。
调用lnteger.toString(基本类型的数据)。

可以把字符串类型的数值转换成真实的数据类型

Integer.parselnt(“字符串类型的整数”)
Double.parseDouble(“字符串类型的小数”)。

/**
    明白包装类的概念，并使用。
 */
public class Test {
    public static void main(String[] args) {
        int a = 10;
        Integer a1 = 11;
        Integer a2 = a; // 自动装箱
        System.out.println(a);
        System.out.println(a1);

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

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

        // int age = null; // 报错了！
        Integer age1 = null;
        Integer age2 = 0;

        System.out.println("-----------------");
        // 1、包装类可以把基本类型的数据转换成字符串形式。
        Integer i3 = 23;
        String rs = i3.toString();
        System.out.println(rs + 1);

        String rs1 = Integer.toString(i3);
        System.out.println(rs1 + 1);

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

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

        String number = "23";
        //转换成整数
        // int age = Integer.parseInt(number);
        int age = Integer.valueOf(number);
        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);
    }
}

3、正则表达式

3.1 正则表达式概述、初体验

正则表示：正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。

正则表达式初体验

需求:假如现在要求校验一个qq号码是否正确，6位及20位之内，必须全部是数字。
先使用目前所学知识完成校验需求;然后体验—下正则表达式检验。

public class RegexDemo1 {
    public static void main(String[] args) {
        // 需求：校验qq号码，必须全部数字 6 - 20位
        System.out.println(checkQQ("251425998"));
        System.out.println(checkQQ("2514259a98"));
        System.out.println(checkQQ(null));
        System.out.println(checkQQ("2344"));

        System.out.println("-------------------------");
        // 正则表达式的初体验：
        System.out.println(checkQQ2("251425998"));
        System.out.println(checkQQ2("2514259a98"));
        System.out.println(checkQQ2(null));
        System.out.println(checkQQ2("2344"));

    }

    public static boolean checkQQ2(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;
        }

        // 2、判断qq中是否全部是数字，不是返回false
        //  251425a87
        for (int i = 0; i < qq.length(); i++) {
            // 获取每位字符
            char ch = qq.charAt(i);
            // 判断这个字符是否不是数字，不是数字直接返回false
            if(ch < '0' || ch > '9') {
                return false;
            }
        }

        return true; // 肯定合法了！
    }
}

3.2 正则表达式的匹配规则

字符串对象提供了匹配正则表达式的方法

在这里插入图片描述

字符类(默认匹配一个字符)

在这里插入图片描述

预定义的字符类(默认匹配一个字符)

在这里插入图片描述

贪婪的量词(配合匹配多个字符)
在这里插入图片描述

需求

  1. 请编写程序模拟用户输入手机号码、验证格式正确，并给出提示，直到格式输入正确为止。
  2. 请编写程序模拟用户输入邮箱号码、验证格式正确，并给出提示，直到格式输入正确为止。
  3. 请编写程序模拟用户输入电话号码、验证格式正确，并给出提示，直到格式输入正确为止。
import java.util.Arrays;
import java.util.Scanner;

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

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

3.3 正则表达式的应用

方法名说明
public String replaceAll(String regex,String newStr)按照正则表达式匹配的内容进行替换
public String] split(String regex):按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。
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);
    }
}

3.4 正则表达式爬取信息

/**
    拓展：正则表达式爬取信息中的内容。(了解)
 */
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);
        }

    }
}

4、Arrays类

4.1 Arrays类概述，常用功能演示

数组操作工具类,专门用于操作数组元素的。

Arrays类的常用API

方法名说明
public static String tostring(类型[] a)返回数组的内容（字符串形式)
public static void sort(类型[] a)对数组进行默认升序排序
public static void sort(类型[] a, Comparator<? superT> c)使用比较器对象自定义排序
public static int binarySearch(int[] a, int key)二分搜索数组中的数据,存在返回索引,不存在返回-1

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));
    }

}

4.2 Arrays类对于Comparator比较器的支持

Arrays类的排序方法

方法名说明
public static void sort(类型a)对数组进行默认升序排序
public static void sort(类型a, Comparator< ? super T> c)使用比较器对象自定义排序

自定义排序规则

设置Comparator接口对应的比较器对象，来定制比较规则。

  • 如果认为左边数据大于右边数据返回正整数
  • 如果认为左边数据小于右边数据返回负整数
  • 如果认为左边数据等于右边数据返回0
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));

        // 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));


    }
}

5、常见算法

参见数据结构系列博客 数据结构笔记。

6、Lambda表达式

6.1 Lambda概述

Lambda表达式是JDK 8开始后的一种新语法形式。

作用:简化匿名内部类的代码写法。

Lambda表达式的简化格式

(匿名内部类被重写方法的形参列表)->{
	被重写方法的方法体代码。
}
注:->是语法形式。无实际含义

public class LambdaDemo1 {
    public static void main(String[] args) {
        // 目标：学会使用Lambda的标准格式简化匿名内部类的代码形式
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("乌龟跑的很慢~~~~~");
            }
        };
        a.run();

        // 注意：lambda并不是可以简化所有匿名匿名内部类形式！！
//        Animal a1 = () -> {
//            System.out.println("乌龟跑的很慢~~~~~");
//        };
//        a1.run();
    }
}



abstract class Animal{
    public abstract void run();
}

注意:Lambda表达式只能简化 函数式接口（首先必须是接口、其次接口中有且仅有一个抽象方法的形式） 的匿名内部类的写法形式

6.2 Lambda应用

public class LambdaDemo2 {
    public static void main(String[] args) {
        // 目标：学会使用Lambda的标准格式简化匿名内部类的代码形式
        // 注意：Lambda只能简化接口中只有一个抽象方法的匿名内部类形式（函数式接口）
//        Swimming s1 = new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("老师游泳贼溜~~~~~");
//            }
//        };

//        Swimming s1 = () -> {
//            System.out.println("老师游泳贼溜~~~~~");
//        };

        Swimming s1 = () -> System.out.println("老师游泳贼溜~~~~~");
        go(s1);

        System.out.println("---------------------");
//        go(new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("学生游泳很开心~~~");
//            }
//        });

//        go(() ->{
//                System.out.println("学生游泳很开心~~~");
//        });

        go(() -> System.out.println("学生游泳很开心~~~"));


    }

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

@FunctionalInterface // 一旦加上这个注解必须是函数式接口，里面只能有一个抽象方法
interface Swimming{
    void swim();
}

6.3 Lambda表达式的省略规则

Lambda表达式的省略写法(进—步在Lambda表达式的基础上继续简化)

  • 参数类型可以省略不写。
  • 如果只有一个参数，参数类型可以省略，同时()也可以省略。
  • 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号!
  • 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写
会思想的苇草i
关注
专栏目录
【Java编程】05_Java API
李鲤驴的博客
06-17 393
1. Package 关键字 1.1 概述 在程序开发中，需要将编写的类分目录存放便于管理，Java引入了包（package）机制。Java中的包是专门用来存放类的，通常功能相同的类存放在相同的包中。 使用package声明类或接口所属的包，声明在源文件的首行。 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意” 每" . "一次，就代表一层文件目录。 同一个包下，不能命名同名的接口、类。不同的包下可以。 1.2 包的作用 包的作用： 包帮助管理大型软件系统：将功能相近的类
Java/eclipse新建项目TR_53，编写程序，完成以下功能
SANSHANGY的博客
11-01 417
1.新建一个类School，类成员: (1)录取分数线，变量line，类型为int，static(静态)，private。 (2)成员方法: setLine(int line)，用于将参数赋值给变量line，public。 getLine()，用于返回line的值，public。 2.新建一个类Student，类成员: (1) 成员变量: 学生姓名name，类型String，private。 学生考号id，类型int，private。 成绩total，类型intprivate。
Java基础-String和Date
BASK2311的博客
02-03 307
在Java中，由于String用得非常普遍，Java对它有一些特殊的处理，本节暂不介绍这些内容，只是把它当作一个表示字符串的类型来看待。String是Java API中的一个类，表示多个字符，即一段文本或字符串，它内部是一个char的数组，提供了若干方法用于操作字符串。Date也是Java API中的一个类，表示日期和时间，它内部是一个long类型的值，也提供了若干方法用于操作日期和时间。日期和时间处理是一个比较大的话题，我们留待第7章详解，本节我们只是把它当作表示日期和时间的类型来看待。
蓝桥杯0基础学习
weixin_60719453的博客
04-09 1865
2、如果用“|”作为分隔的话,必须是如下写法,String.split("\\|"),这样才能正确的分隔开,不能用String.split("|")，根据斐波那契数列的状态转移方程，当前状态只和之前的两个状态有关，其实并不需要那么长的一个数组来存储所有的状态，只要想办法存储之前的两个状态就行了。其实我么发现next(),nextInt()和nextFloat()看到空格符或回车符都认为读取结束，此时不会读取回车符。这样才能正确的分隔开,不能用String.split(".")。对比一下两者所消耗时间。
java基础期末总结
weixin_61508006的博客
12-27 1003
变量类型 变量名 = 初始值;面向对象特点：封装，继承，多态Java中异常是指Java程序在运行时可能出现的错误或非正常情况Throwable类：是所有异常类的父类，其两个直接子类Error类和Exception类Error类：程序中产生的错误Exception类：程序中产生的异常RuntimeException类及其子类用于表示运行时异常---unchecked异常其他子类用于编译时异常---checked异常自定义异常必须继承自Exception或其子类。
java源码api-java-:JAVA常用API源码解析
05-25
"java源码api-java-"这个主题专注于讲解Java API的常用组件，帮助开发者深入理解其工作原理，提升编程技能。 Java API覆盖了多个方面，包括集合框架、IO流、多线程、网络编程、反射机制等。以下是一些关键知识点： ...
JAVA程序设计-课程标准.doc
05-15
### JAVA程序设计-课程标准知识点解析 #### 一、课程性质 - **核心课程**: 作为计算机类专业的核心课程，《JAVA程序设计》旨在培养学生掌握JAVA编程技术及其面向对象(OOP)的设计思想。 - **专业基础**: 该课程是...
Java程序设计(第3版)-唐大仕-课件
12-10
《Java程序设计(第3版)》是唐大仕教授编著的一本深入浅出的Java编程教材，适合初学者和有一定经验的开发者学习。这本书的课件包含了丰富的教学资源，帮助读者更好地理解和掌握Java语言的核心概念和技术。下面将根据...
Java程序设计Java常用JavaAPI电子资源pdf
最新发布
06-02
在编写Java程序时,并不是所有地类与接口都需要我们去定义,JDK自带很多常用地系统类,直接使用即可。比如在进行字符串处理时,有专门地字符串处理类,我们可以直接使用这些类提供地方法对字符串进行操作。这样程序编写变...
Java自学视频教程-JavaSE基础-常用API-04、String类常用API.mp4
08-19
Java是一种编程语言，被特意设计用于互联网的分布式环境。Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既...
java field包_int get(int field)
weixin_33877700的博客
03-04 339
int get(int field)描述 (Description)java.util.Calendar.get()方法返回给定日历字段的值。声明 (Declaration)以下是java.util.Calendar.get()方法的声明public int get(int field)参数 (Parameters)field - 给定的日历字段。返回值 (Return Value)给定字段的值。...
Java中Calendar常用方法总结
qq_40967319的博客
10-10 827
方法名 说明 public int get(int field) 返回给定日历字段的值 public abstract void add(int field, int amount) 根据日历的规则，将指定的时间量添加或减去给定的日历字段 public final void set(int year,int month,int date) 设置当前日历的年月日 public int get(int field):返回给定日历字段的值 Cal...
Java Calendar 的常用方法（get、set、add）
卡尔特斯
07-22 1031
import java.util.Calendar; public class test { public static void main(String[] args) { // ======================== get 的使用 ============= // 获取日历对象 Calendar c = Calendar.getInstance(); // public int get(int field): 返回指定日历字段的值 int.
暑期JAVA学习（二）正则表达式
xjl243636988的博客
06-26 191
●正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。●需求:假如现在要求校验一个QQ号码是否正确，6位及20位之内，必须全部是数字。 ●不使用正则表达式完成校验需求●使用正则表达式检验（超方便！） （1）字符类(默认匹配一个字符) （2）预定义的字符类(默认匹配一个字符) （3）量词 (配合匹配多个字符) ①请编写程序模拟用户输入手机号码、验证格式正确，并给出提示，直到格式输入正确为止。 ②请编写程序模拟用户输入邮箱号码、验证格式正确，并给出提示，直到格式输入正确为止。 ③请编写程序
Calender类和System类及其常用方法
qq_48785525的博客
11-30 226
Calendar类 概念 ​ java.util.Calendar 日历类，抽象类，在Date类后出现的，替换掉了很多Date类中的方法。该类将所有的可能用到的时间信息封装为静态成员变量，通过类名.静态成员变量获取时间字段值 获取方式 ​ 由于Calendar类是一个抽象类，语言敏感性，Calendar类并不是直接创建对象来获取时间属性值，而是通过静态方法创建，返回子类对象。 静态方法如下： ​ public static Calendar getInstance()：使用默认时区和默认的语言环
编写程序模拟用户输入手机号码、邮箱号码、座机号码，验证格式是否正确并给出提示，直到格式输入正确为止
qq_46690403的博客
06-25 1439
编写程序模拟用户输入手机号码、邮箱号码、座机号码，验证格式是否正确并给出提示，直到格式输入正确为止
JavaSE基础进阶学习day07
q2524344929的博客
04-10 332
教学视频资源来自 https://www.bilibili.com/video/BV1Cv411372m?p=125&spm_id_from=pageDriver
Java程序设计--常用API(上)（九）
会思想的苇草i的博客
03-21 922
String是Java中表示字符串的类，提供了丰富的字符串操作方法。ArrayList是Java中的动态数组实现，可以动态增加或减少元素。这两个类在Java编程中经常被用到，提供了便利的字符串处理和动态数组功能。
Java程序设计笔记三：Java API和集合
Far_Rainbow的博客
09-19 1488
Java API API（Application Programming Interface）是指应用程序编程接口，的JavaAPI是指JDK提供的各种功能的Java类 String类 String类的初始化： （1）使用字符串常量直接初始化 初始化：String str = "absdefj"; （2）使用构造方法初始化 方法声明 功能描述 String() 创建一个内容为空的字符串 String(String value) 根据指定的字符串内容创建对象 String(char[]
Java程序设计基础类库与工具类库解析
"Java-程序设计PPT涵盖了Java的基础类库和工具类库，包括包的概念、使用，以及Java核心类库的介绍。" 在Java编程中，包（Package）是一个重要的组织单元，它用于管理和组织类，使得代码更加有序且可重用。包的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

会思想的苇草i

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值