java基础07常用API

于 2024-11-04 14:34:18 发布
阅读量658 收藏 18
点赞数 27
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_63550078/article/details/143483318
版权

Java中的常用API：

1，说明

​ API（应用程序接口）：

​ 数据接口：获取数据（前后端分离），数据可视化

​ 功能接口：手机短信接口，邮箱发送接口，支付接口，支付接口

​ java中的常用API指常用的一些类的方法。

2、api

1-Object

​ Object是Java中所有类的直接或间接父类。
​

Object上的常用方法：

​ 1) //是一个本地方法（native），将当前对象进行克隆，被克隆对象所在的类必须实现Cloneable接口。
​ 克隆，相当于复制。基于已经存在的对象克隆出一个属性相同的对象来。
​ Object clone()；

​ 2)当前类所创建的对象，如果没有引用时，被判定为垃圾对象，但是该对象不是被立即回收。
​ 而是达到了垃圾回收器的条件时触发，在触发对象回收时，会调用该方法，完成资源的清理。
​ 这个概念有点类似于析构（当对象没有引用时，会自动调用方法，完成对象所持有资源的释放，
​ 并清理对象）但是java中的finalize，不等同于析构。java没有析构的概念。
​ System.gc(); 唤醒垃圾回收器，清理垃圾对象。但是垃圾回收器不一定会立即执行。
​ 如果在对象不被使用时，释放对象所占用资源，应该自己编写相应的代码实现。
​ void finalize()；
​
​ 3）Class<?> getClass()； //获取对象的实际类型
​
​ 4）—可以认为是唯一的—同一个对象的哈希码一致，不同对象的哈希码不同。
​ —取值大概是43亿个；哈希码的取值是散列的—随机分布在这43亿个取值范围中
​ hashCode()
​
​ 5）//用于比较两个对象的地址是否相同，通常情况下，equals方法需要重写
​ 实现当两个引用地址不同，但是属性相同时，也可以判定为相等。
​ boolean equals(Object obj);

​ instanceof关键字：用于判断某个对象是否为指定的类型：
​ obj instanceof ClassName

​ null关键字：表示当前的引用地址为空，也作为对象中引用类型属性的默认值。
​ null可以用于比较是否相等，但不能做其他任何操作否则会抛
​ 空指针异常
​
​ 6）如果将一个对象作为字符串打印输出，则该方法的返回值就作为要打印的内容
​ 一般作为代码调试。
​ String toString()

​

​ 其他方法：与线程通信相关方法

​ notify() //唤醒线程池中的任意一个线程
​ notifyAll() //唤醒所有线程
​ wait(long timeout) //线程等待（挂起），并设置超时时间
​ wait()

2-String
定义：

​ 表示字符串，并且是一个最终(final)类。

字符串拼接问题：

​ 在使用“+”对字符串拼接时，实际上使用的是new StringBuilder().append().
​ 如果遇到需要循环拼接字符串的场景，则应该使用StringBuilder()，节约内存空间.

在字符串拼接的应用中有两个类都可以处理：

​ StringBuilder：（默认），存在多线程并发安全问题，线程不安全类。并发效率高
​ StringBuffer： 加入了关键字synchronized，保证线程安全。并发效率相比StringBuilder较低。

​ 字符串String实际上是char value[]（字符数组）

常用方法：

​ charAt(int index)—获取指定位置上的字符;如果指定的下标不存在，则会出现StringIndexOutOfBoundsException
​ length()—获取字符串的长度
​ toCharArray()—将字符串转化为一个字符数组
​ compareTo(String str)—按字典顺序（实际上就是按照从小到大的顺序）来比较两个字符串
​ concat(String str)—拼接两个字符串，返回一个新字符串
​ getBytes(String charsetName)—将字符串按照指定的编码转化为字节数组
​ equals(Object o)—比较两个字符串是否一致。比较的是两个字符串的实际值
​ endsWith(String suffix)—判断是否是指定的结尾
​ startsWith(String suffix)—判断是否是指定的开头
​ contains(String str) —判断字符串中是否包含str。
​ hashCode()—获取对象的哈希码—注意，同一个字符串的哈希码在任何条件下都是一样的。
​ String(char[] cs, int index, int offset)—表示从字符数组cs的第index位开始，将offset个元素转化为字符串
​ indexOf(int ch, int index)—表示从字符串的第index位开始，向后寻找字符ch第一次出现的位置；如果找不到，则返回-1

3-正则表达式

1）定义

​ 使用一些具有特殊含义的元字符，编写字符串的匹配规则。
​ Regex — Pattern
​

2）案例

​ Pattern p = Pattern.compile(“a*b”); //基于传入的正则构建正则表达式对象
​ Matcher m = p.matcher(“aaaaab”); //调用匹配器，匹配传入的字符串
​ boolean b = m.matches(); //判断是否匹配成功

​

3）常用元字符

. //表示匹配除换行符以外的任意字符

//匹配前一个字符出现0次或多次

//匹配前一个字符出现至少一次
{n} //匹配前一个字符出现n次
{n,m} //匹配前一个字符出现>=n 且 <=m次 {8, 16}
{n,} //匹配前一个字符出现至少n次
^ //匹配开始位置，例如：匹配以abc为开始 “^abc”
$ //匹配结束位置，例如：匹配以jpeg为结束 “jpeg$”
[] //匹配其中的任意一个字符， “f[ao]t” fat, fot
[-] //如果连字符“-”在选择匹配中出现，可以表示区间范围 [a-zA-Z_], [0-9]
[^] //排除选择匹配中出现的所有字符， “f[^ao]t”
() //分组捕获，出现在括号中的内容会被添加到一个数组中，并且从1开始编号。
//被分组后的内容可以根据编号进行反向引用 \1(从捕获的数组中提取下标为1的单元)
| //表示或者 “ab|cd” ,匹配ab或者cd

\d //匹配0-9之间任意一个数
\s //匹配特殊的控制符，空格，制表符，换行符
\w //与[a-zA-Z_]相同

4）方法说明

​ group([int i]) //从捕获的分组中提取指定下标的单元，但是在调用之前一定要先确认
​ 是否匹配成功 ，即先调用matches()为true时再提取
​ 如果group参数为0表示提取数组中第一个元素也就是完全匹配的所有内容。

​

爬虫案例：

​

//爬虫
    String content = "<a href=\"https://www.baidu.com?abc=354sdfsdf\">百度</a>";
    //从a标签上提取url地址 - 正则
    Pattern pattern = Pattern.compile("<a href=\"(.*)\">百度</a>");
    Matcher matcher = pattern.matcher(content);
    //System.out.println(matcher.matches());

     if(matcher.matches()){
         //提取url
         String group = matcher.group(1);
         System.out.println(group);
     }

​
练习：
​ 1、匹配手机号是否符合规范
​ 2、匹配邮箱地址是否符合规范

public static boolean validateMobileNumber(String mobileNumber) {
    //手机号
    /*
    * ^ 表示匹配字符串的开头。
    * 1 表示以 1 开头。
    * [3-9] 表示第二位数字是 3 到 9 中的一个。
    * \\d{9} 表示后面跟着 9 个数字。
     */
    String regex = "^1[3-9]\\d{9}$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(mobileNumber);
    return matcher.matches();
}
public static boolean validateQQMail(String email) {
    // QQ 邮箱验证正则表达式
    //[1-9]\\d{4,10}表示以 1 到 9 开头，后面跟着 4 到 10 个数字.
    String regex = "^[1-9]\\d{4,10}@qq.com$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(email);
    return matcher.matches();
}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入手机号码的11位: ");
    String mobileNumber = scanner.nextLine();

    if (validateMobileNumber(mobileNumber)) {
        System.out.println(mobileNumber + " 是有效的手机号码");
    } else {
        System.out.println(mobileNumber + " 不是有效的手机号码");
    }

    System.out.print("请输入 QQ 邮箱: ");
    String qq = scanner.nextLine();

    if (validateQQMail(qq)) {
        System.out.println(qq + " 是有效的 QQ 邮箱");
    } else {
        System.out.println(qq + " 不是有效的 QQ 邮箱");
    }
    scanner.close();
}

4-数学相关类

（1）Math

​ addExact(5, 19); //加法运算
​ subtractExact(25, 9); //减法运算
​ multiplyExact(2, 8); //乘法运算
​ floorDiv(3, 2); //除法运算
​ abs(-9); //绝对值
​ pow(2, 3); //次幂
​ max(8, 9); //最大值
​ min(2, 7); //最小值
​ random(); //返回一个0-1之间的随机数，返回double类型
​ ceil(double a); //向上取整
​ floor(double a)；//向下取整
​

​ 注意：对于浮点数而言，在计算机底层做换算时会被转为无限循环的小数。
​ 1.3 - 1.333333333；因此在处理精度要求更高的场景推荐使用下面的类。
​

（2）BigDecimal

​ 在BigDecimal中，数值会被作为字符串进行处理。
​
​ //将数值封装为BigDecimal对象
​ BigDecimal num1 = new BigDecimal(“数字”)
​ BigDecimal num2 = new BigDecimal(“数字”)
​
​ 常用方法：
​
​ num1.add(num2); //加法运算
​ num1.subtract(num2); //减法运算
​ num1.multiply(num2); //乘法运算
​ num1.divide(num2); //除法运算
​ num1.abs(); //绝对值
​ num1.pow(3); //次幂
​ num1.max(num2); //最大值
​ num1.min(num2); //最小值
​
​ 案例：
​ BigDecimal n1 = new BigDecimal(“3”);
​ BigDecimal n2 = new BigDecimal(“2”);

​ BigDecimal divide = n1.divide(n2);
​ System.out.println(divide.doubleValue());

5-包装类

​ 针对java中的基本数据类型（基本类型变量上没有属性&方法）。而java称为纯面向对象语言，因此对基本类型做了相应的包装类型。
​

​ 基础 byte short char int long float double boolean
​ 包装 Byte Short Character Integer Long Float Double Boolean

​ 注意：自jdk1.5开始，java支持将基础类型的值直接赋值给包装类型，反之也可以。
​ 包装类型 = 基础类型 //封箱
​ 基础类型 = 包装类型 //拆箱
​
​ 封箱的过程实际上调用的是包装类身上的valueOf()方法实现。
​ Integer valueOf(int i)
​
​ 拆箱的过程中实际调用的是包装类身上的*Value()方法。

6-日期类

​ 在方法身上添加了@Deprecated注解的，表示官方即将在以后的版本不再支持，即将被废弃。

​ jdk1.8之前：
​ Date //表示日期类

​ ——getTime() //返回从1970-1-1 0:0:0 到当前时间的秒数(时间戳)
​ Calendar //日历

​ ——getInstance() //返回当前日期的Calendar对象

​ ——set() //设置时间

​ SimpleDateFormat 日期格式化

​ ——SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

​ ——format(Date date) //将日期对象根据格式转为对应的字符串

​ jdk1.8开始：
​ LocalDateTime 日期时间
​ LocalDate 日期
​ LocalTime 时间
​
​ Duration 时间
​ Period 日期

​ LocalDateTime：

​ ——now() //返回当前日期的LocalDateTime对象

​ ——of(…) //将指定的日期时间转为LocalDateTime对象

案例：
LocalDateTime now = LocalDateTime.now();
String format = now.format(DateTimeFormatter.ofPattern(“YYYY-MM-dd HH:mm:ss”));
System.out.println(format);

​

7-异常

1）定义

​ 异常是java中用于问题反馈的机制。（ERROR 错误, Exception异常）
​ ERROR: 不应该尝试捕获，是程序正常运行过程中出现的不可避免的严重问题。
​ Exception：异常对于程序员来说是可控的。

​ 错误和异常都是直接继承java.lang.Throwable 。

2）异常处理

​ 1-在方法上可以抛出异常
​ throws 异常类型
​

​ 2-捕获
​ try{
​ //可能会存在异常的代码
​ }catch(异常类型 变量){
​ //异常处理
​ }catch(异常类型 变量){
​ //异常处理
​ }
​ …
​ finally {
​ //无论是否有异常产生都会被调用
​ }

3）异常的分类

​ 编译时异常：
​ 在编译阶段抛出的异常，这种异常是必须要解决的。
​

​ 运行时异常：
​ 在运行时有可能会出现的异常，这种异常可以处理也可以不处理。
​ 如果该异常类型是RuntimeException的子类都属于运行时异常。

4）如何通过抛异常进行问题反馈

​ 可以通过throw 配合异常实现
​ 在方法中：
​ throw new 异常类(“”);
​

​ 注意：如果抛出的是编译时异常，则需要在方法参数列表后使用throws 抛出，
​ 如果是运行时异常，可以不用在方法上抛。

5）异常捕获处理办法

​ a、如果捕获的每个异常都有自己的处理办法，就需要分别捕获
​ b、如果所有异常处理都相同，则可以直接找这些异常的共同父类。
​ c、如果多个异常需要进行分组处理，那么同一组的异常之间可以用 | 隔开 — JDK1.7
​ （不能出现有直接继承关系的异常类）
​

6）自定义异常

​ 类继承Exception–相当于自定义了一个编译时异常类。
​ 类继承RuntimeException–相当于自定义了一个运行时异常类。

练习：
1、输入一个字符串和一个数字，数字表示字节个数，然后按照指定的字节个数来截取这个字符串，
要求不准出现半个字符的现象

public static String truncateString(String str, int numBytes) {
    StringBuilder result = new StringBuilder();
    // 创建一个`StringBuilder`对象用于构建最终的结果字符串
    int byteCount = 0;
    // 初始化字节计数器
    for (char c : str.toCharArray()) {
        // 遍历输入字符串的每个字符
        byte[] charBytes = String.valueOf(c).getBytes(StandardCharsets.UTF_8);
        // 将当前字符转换为字符串并获取其在 UTF-8 编码下的字节数组
        if (byteCount + charBytes.length <= numBytes) {
            // 如果累计的字节数加上当前字符的字节数小于等于指定的字节数
            result.append(c);
            // 将当前字符添加到结果中
            byteCount += charBytes.length;
            // 增加字节计数器
        } else {
            break;
            // 否则停止循环，不再添加字符
        }
    }
    return result.toString();
    // 将`StringBuilder`转换为字符串并返回
}

public static void main(String[] args) {
    String str = "这是一个测试字符串";
    int numBytes = 14;
    String truncatedStr = truncateString(str, numBytes);
    System.out.println("截取后的字符串: " + truncatedStr);
}

2、输入一个字符串，提取这个字符串中的数字并求和 -> sdf85dfghd72s6 -> 8 5 7 2 6 -> 28

public static class ExtractAndSumDigitsFromInput {
    public static int extractAndSumDigits(String str) {
        // 定义一个方法，用于从给定字符串中提取数字并求和
        int sum = 0;
        // 初始化求和结果为 0
        for (char c : str.toCharArray()) {
            // 遍历输入字符串的每个字符
            if (Character.isDigit(c)) {
                // 如果字符是数字
                sum += c - '0';
                // 将数字字符转换为对应的整数并累加到 sum 中
            }
        }
        return sum;
        // 返回求和结果
    }

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // 创建 Scanner 对象用于获取用户输入
    System.out.print("请输入字符串: ");
    String str = scanner.nextLine();
    // 读取用户输入的字符串
    int sum = extractAndSumDigits(str);
    // 调用提取和求和的方法
    System.out.println("读取的数字");
    String c = scanner.nextLine();

    System.out.println("数字之和为: " + sum);
    // 输出数字之和
    scanner.close();
    // 关闭 Scanner 对象，释放资源
}

}

3、输入一个字符串，提取这个字符串中的数字并排序->sdf85dfghd72s6 -> 8 5 7 2 6 -> 2 5 6 7 8

public static List<Integer> extractAndSortDigits(String str) {
    List<Integer> digitList = new ArrayList<>();
    // 创建一个用于存储数字的整数列表

for (char c : str.toCharArray()) {
    // 遍历输入字符串的每个字符
    if (Character.isDigit(c)) {
        // 如果字符是数字
        digitList.add(c - '0');
        // 将数字字符转换为整数并添加到列表中
    }
}

digitList.sort(Integer::compareTo);
// 对数字列表进行排序

return digitList;
// 返回排序后的数字列表

}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // 创建 Scanner 对象用于获取用户输入

System.out.print("请输入字符串: ");
String str = scanner.nextLine();
// 读取用户输入的字符串

List<Integer> sortedDigits = extractAndSortDigits(str);
// 调用提取和排序数字的方法

System.out.println("提取并排序后的数字: " + sortedDigits);
// 输出排序后的数字列表

scanner.close();
// 关闭 Scanner 对象以释放资源

}

4、输入一个字符串，利用charAt方法判断这个字符串是否是一个回文字符串

public static boolean isPalindrome(String str) {
    int left = 0;  // 初始化左指针，指向字符串的第一个字符
    int right = str.length() - 1;  // 初始化右指针，指向字符串的最后一个字符

    while (left < right) {  // 当左指针小于右指针时，循环进行比较
        if (str.charAt(left)!= str.charAt(right)) {  // 如果左右指针所指字符不相等
            return false;  // 直接返回false，表示不是回文串
        }
        left++;  // 左指针向右移动一位
        right--;  // 右指针向左移动一位
    }
    return true;  // 如果循环结束都没有返回false，说明是回文串，返回true
}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);  // 创建Scanner对象用于获取用户输入

    System.out.print("请输入字符串: ");
    String str = scanner.nextLine();  // 读取用户输入的字符串

    if (isPalindrome(str)) {  // 调用isPalindrome方法判断输入的字符串是否为回文串
        System.out.println(str + " 是回文字符串");
    } else {
        System.out.println(str + " 不是回文字符串");
    }

    scanner.close();  // 关闭Scanner对象，释放资源
}

5、输入一个字符串，统计每个字符出现的个数—hsoafngifaoa -> h:1 s:1 o:2 a:3 f:2 n:1 g:2 i:1

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // 创建 Scanner 对象用于获取用户输入

    System.out.print("请输入字符串: ");
    String str = scanner.nextLine();
    // 读取用户输入的字符串

    Map<Character, Integer> charCountMap = countCharacters(str);
    // 调用 countCharacters 方法统计字符出现次数，并将结果存储在 charCountMap 中

    for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
        // 遍历 charCountMap 中的每个键值对
        System.out.println(entry.getKey() + ": " + entry.getValue());
        // 输出字符及其出现的次数
    }

    scanner.close();
    // 关闭 Scanner 对象以释放资源
}

public static Map<Character, Integer> countCharacters(String str) {
    Map<Character, Integer> countMap = new HashMap<>();
    // 创建一个 HashMap 来存储字符及其出现的次数

    for (char c : str.toCharArray()) {
        // 遍历输入字符串的每个字符
        if (countMap.containsKey(c)) {
            // 如果字符已经在 countMap 中
            countMap.put(c, countMap.get(c) + 1);
            // 将其对应的值加 1
        } else {
            countMap.put(c, 1);
            // 如果字符不在 countMap 中，将其添加并初始值设为 1
        }
    }
    return countMap;
    // 返回统计结果
}

点个赞鼓励一下谢谢

犹生豫梦
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值