当前位置： 首页 > article >正文

【day15】String常用API

article 2024/12/25 11:02:58

模块14回顾

在深入探讨模块15之前，让我们简要回顾一下【day14】中的关键点：

  1. 异常处理：

    • 分类：Throwable分为Error（错误）和Exception（异常）。
    • 编译时期异常：如调用方法时底层抛出的异常，通常是Exception及其子类（除了RuntimeException之外）。
    • 运行时期异常：如RuntimeException及其子类，这些异常在程序运行时才会被发现。

  2. 异常处理机制：

    • 使用throws关键字声明异常。
    • 使用try...catch语句块捕获并处理异常。

  3. finally块：

    • 无论是否发生异常，finally块中的代码都会执行，常与try...catch配合使用。
    • 常用于资源的关闭操作。

  4. 自定义异常：

    • 通过继承Exception创建编译时期异常，或继承RuntimeException创建运行时期异常。
    • 提供构造方法以设置异常信息。

  5. Object类：

    • 所有Java类的根类，提供toString、equals和clone方法。
    • toString方法默认返回对象的地址值，若重写则返回对象内容。
    • equals方法默认比较对象地址值，若重写则比较对象内容。
    • clone方法需要实现Cloneable接口，并重写该方法以复制对象。

  6. 经典接口：

    • Comparable和Comparator接口，用于对象的比较。

模块14重点

本模块将全面介绍Java中的基础API，特别是String类的使用和操作。

第一章：String类

1.String介绍

String类是Java中表示字符串的类，具有以下特点：

  • 所有字符串字面值（如"abc"）都是String类的实例。
  • 字符串是不可变的，这意味着一旦创建，其值就不能更改。
  • String对象是不可变的，因此可以被共享。

在这里插入图片描述
在这里插入图片描述

2.String的实现原理

在JDK 8中，String类的底层实现是一个被final修饰的char数组。从JDK 9开始，这一实现变为了被final修饰的byte数组， 一个char类型占2个字节， 一个byte类型占1个字节，以节省内存空间。

字符串定义完之后，数组就创建好了，被final一修饰，数组的地址值直接定死

3.String的创建

String对象可以通过多种方式创建：

  • 使用无参构造函数String()。
  • 使用String(String original)根据已有字符串创建新对象。
  • 使用String(char[] value)根据字符数组创建。
  • 使用String(byte[] bytes)根据字节数组创建，使用平台默认字符集解码。
public class Demo02String {
    public static void main(String[] args) {
        //1.String()  -> 利用String的无参构造创建String对象
        String s1 = new String(); //
        System.out.println(s1);
        //2.String(String original) -> 根据字符串创建String对象
        String s2 = new String("abc");
        System.out.println(s2);
        //3.String(char[] value) -> 根据char数组创建String对象
        char[] chars = {'a','b','c'};
        String s3 = new String(chars);
        System.out.println(s3);
        /*
          4.String(byte[] bytes) -> 通过使用平台的默认字符集解码指定的 byte 数组，
                                    构造一个新的 String
         */
        byte[] bytes1 = {97,98,99};
        String s4 = new String(bytes1);
        System.out.println(s4);

        byte[] bytes2 = {-97,-98,-99};
        String s5 = new String(bytes2);
        System.out.println(s5);

        byte[] bytes3 = {-28,-67,-96};
        String s6 = new String(bytes3);
        System.out.println(s6);

        //5.简化形式
        String s7 = "abc";
        System.out.println(s7);
    }
}
  • String(char[] value, int offset, int count) char数组的一部分转成String对象，value:要转String的char数组，offset:从数组的哪个索引开始转，count:转多少个
  • String(byte[] bytes, int offset, int length) 将byte数组的一部分转成String对象， bytes:要转String的byte数组， offset:从数组的哪个索引开始转，length:转多少个
public class Demo03String {
    public static void main(String[] args) {
       /* 1.String(char[] value, int offset, int count)->将char数组的一部分转成String对象
        value:要转String的char数组
        offset:从数组的哪个索引开始转
        count:转多少个*/
        char[] chars = {'a','b','c','d','e','f'};
        String s1 = new String(chars,1,3);
        System.out.println(s1);
       /* 2.String(byte[] bytes, int offset, int length)->将byte数组的一部分转成String对象
        bytes:要转String的byte数组
        offset:从数组的哪个索引开始转
        length:转多少个*/
        byte[] bytes = {97,98,99,100,101};
        String s2 = new String(bytes,0,2);
        System.out.println(s2);
    }
}

4.String面试题

一个常见的面试题是关于String对象的创建和比较。例如，String s = new String("abc")会创建几个对象？答案是两个：一个是"abc"字面值，另一个是new关键字创建的新对象。

public class Demo04String {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s2==s3);//false
    }
}

在这里插入图片描述

5.字符串常见问题

字符串拼接时，如果右侧是字符串字面值，则不会产生新对象。但如果右侧有变量，则会产生新的字符串对象。

public class Demo05String {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        String s4 = "hello"+"world";
        String s5 = s1+"world";
        String s6 = s1+s2;

        System.out.println(s3==s4);//true
        System.out.println(s3==s5);//false
        System.out.println(s3==s6);//false
    }
}

在这里插入图片描述

第二章：String的方法

1.判断方法

String类提供了equals和equalsIgnoreCase方法，用于比较字符串内容，后者忽略大小写。

public class Demo01String {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        String s3 = "Abc";
        System.out.println(s1==s2);//比较地址值了

        //boolean equals(String s) -> 比较字符串内容
        System.out.println(s1.equals(s2));
        //boolean equalsIgnoreCase(String s) -> 比较字符串内容,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s3));

        System.out.println("=========================");
        String s4 = "123";
        String s5 = "一二三";
        System.out.println(s4.equalsIgnoreCase(s5));//false
        String s6 = "壹贰叁";
        System.out.println(s5.equalsIgnoreCase(s6));//false
    }
}

2.练习1：模拟用户登录

已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录成功与否，给出相应的提示

  • 先定义两个字符串,表示注册过的用户名和密码
  • 创建Scanner对象,键盘录入用户名和密码
  • 比较,如果输入的用户名和密码跟已经注册过的用户名和密码内容一样,就登录成功,否则就登录失败
public class Demo02String {
    public static void main(String[] args) {
        //1.先定义两个字符串,表示注册过的用户名和密码
        String username = "root";
        String password = "123";
        //2.创建Scanner对象,键盘录入用户名和密码
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请您输入用户名:");
            String name = sc.next();
            System.out.println("请您输入密码:");
            String pwd = sc.next();
            //3.比较,如果输入的用户名和密码跟已经注册过的用户名和密码内容一样,就登录成功,否则就登录失败
            if (name.equals(username) && pwd.equals(password)) {
                System.out.println("登录成功");
                break;
            } else {
                if (i == 2) {
                    System.out.println("账号冻结");
                } else {
                    System.out.println("登录失败!");
                }
            }
        }
    }
}

import java.util.Objects;

public class Demo03String {
 public static void main(String[] args) {
     //String s = "abc";
     String s = null;
     //method(s);

     String s1 = null;
     String s2 = "abc";
     method01(s1,s2);
 }

 /*
   工具类:Objects
   方法:判断两个对象是否相等 -> 自带防空指针作用
       public static boolean equals(Object a, Object b) {
          return (a == b) || (a != null && a.equals(b));
       }

  */
 private static void method01(String s1, String s2) {
   if (Objects.equals(s1,s2)){
       System.out.println("是abc");
   }else{
       System.out.println("不是abc");
   }
 }

 /*
   如果传递过来的对象是null,再去点其他方法,就会空指针
   解决:不要让一个字符串变量去点,用确定的字符串去点,可以防空
  */
 private static void method(String s) {
     /*if (s.equals("abc")){
         System.out.println("是abc");
     }else{
         System.out.println("不是abc");
     }*/
     if ("abc".equals(s)){
         System.out.println("是abc");
     }else{
         System.out.println("不是abc");
     }
 }
}

3.获取功能

String类提供了多种获取字符串信息的方法，如length()、concat、charAt、indexOf和substring。

public class Demo04String {
    public static void main(String[] args) {
        String s1 = "abcdefg";
        //int length() -> 获取字符串长度
        System.out.println(s1.length());
        //String concat(String s)-> 字符串拼接,返回新串儿
        System.out.println(s1.concat("haha"));
        //char charAt(int index) -> 根据索引获取对应的字符
        System.out.println(s1.charAt(0));
        //int indexOf(String s) -> 获取指定字符串在大字符串中第一次出现的索引位置
        System.out.println(s1.indexOf("a"));
        //String subString(int beginIndex) -> 截取字符串,从指定索引开始截取到最后,返回新串儿
        System.out.println(s1.substring(3));
        //String subString(int beginIndex,int endIndex) -> 截取字符串,从beginIndex开始到endIndex结束
        //含头不含尾,返回新串儿
        System.out.println(s1.substring(1,6));

    }
}

4.练习2：遍历字符串

以下是一个遍历字符串并打印每个字符的示例代码。

public class Demo05String {
    public static void main(String[] args) {
        String s = "abcdefg";
        for (int i = 0; i < s.length(); i++) {
            System.out.println(s.charAt(i));
        }
    }
}

5.转换功能

String类还提供了将字符串转换为字符数组和字节数组的方法，如toCharArray和getBytes。

public class Demo06String {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s = "abcdefg";
        //1.char[] toCharArray() -> 将字符串转成char数组
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
        System.out.println("===============");
        //2.byte[] getBytes() -> 将字符串转成byte数组
        byte[] bytes = s.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("===============");
        //3.String replace(CharSequence c1,CharSequence c2)-> 替换字符 CharSequence->String的接口
        System.out.println(s.replace("a","z"));

        System.out.println("===============");
        //4.byte[] getBytes(String charsetName) -> 按照指定的编码将字符串转成byte数组
        byte[] bytes1 = "你好".getBytes("GBK");
        for (int i = 0; i < bytes1.length; i++) {
            System.out.println(bytes1[i]);
        }

    }
}

6.练习4：统计字符

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)

  • 创建Scanner对象，键盘录入
  • 定义三个变量，用来统计
  • 调用next方法录入一个字符串，遍历字符串，将每一个字符拿出来
  • 统计大写字母 A-Z -> 65-90，
  • 统计小写字母 a-z -> 97-122
  • 统计数字：0-9 -> 48-57
  • 将统计结果打印出来
public class Demo07String {
    public static void main(String[] args) {
        //1.创建Scanner对象,键盘录入
        Scanner sc = new Scanner(System.in);
        //2.定义三个变量,用来统计
        int big = 0;
        int small = 0;
        int number = 0;
        //3.调用next方法录入一个字符串,遍历字符串,将每一个字符拿出来
        String data = sc.next();
        char[] chars = data.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char num = chars[i];

             /*4.统计大写字母
                  A-Z -> 65-90
                  比如:B -> 66 -> 在65-90之间,证明就是大写字母*/
            if (num>='A' && num<='Z'){
                big++;
            }
             /*5.统计小写字母
                  a-z -> 97-122
                  比如:b -> 98 -> 在97-122之间,证明就是小写字母*/
            if (num>='a' && num<='z'){
                small++;
            }
             /*6.统计数字:
                  0-9 -> 48-57
                  比如:字符1 -> 49 -> 在48-57之间,证明就是数字*/
            if (num>='0' && num<='9'){
                number++;
            }
        }

        //7.将统计结果打印出来
        System.out.println("大写有"+big+"个");
        System.out.println("小写有"+small+"个");
        System.out.println("数字有"+number+"个");
    }
}

7.分割功能

String类的split方法可以根据正则表达式规则分割字符串。

public class Demo08String {
    public static void main(String[] args) {
        String s = "abc,txt";
        String[] split = s.split(",");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

        System.out.println("===============");
        String s2 = "haha.hehe";
        String[] split1 = s2.split("\\.");
        for (int i = 0; i < split1.length; i++) {
            System.out.println(split1[i]);
        }
    }
}

8.其他方法

String类还提供了其他实用方法，如contains、endsWith、startsWith、toLowerCase、toUpperCase和trim。

public class Demo09String {
    public static void main(String[] args) {
        String s = "abcdefg";
        //1.boolean contains(String s) -> 判断老串儿中是否包含指定的串儿
        System.out.println(s.contains("a"));
        //2.boolean endsWith(String s) -> 判断老串儿是否以指定的串儿结尾
        System.out.println(s.endsWith("g"));
        //3.boolean startsWith(String s) -> 判断老串儿是否以指定的串儿开头
        System.out.println(s.startsWith("a"));
        //4.String toLowerCase()-> 将字母转成小写
        System.out.println("ADbcda".toLowerCase());
        //5.String toUpperCase() -> 将字母转成大写
        System.out.println("dafadRWERW".toUpperCase());
        //6.String trim() -> 去掉字符串两端空格
        System.out.println(" hadfhad hdsfha  sfhdsh ".trim());

        System.out.println("==================");
        System.out.println(" hadfhad hdsfha  sfhdsh ".replace(" ",""));
    }
}

第四章：StringBuilder类

1.StringBuilder的介绍

StringBuilder是一个可变的字符序列，主要用于字符串拼接。与String相比，StringBuilder在拼接时不会频繁创建新对象，因此效率更高。

StringBuilder的特点:

  • 底层自带缓冲区,此缓冲区是没有被final修饰的byte数组,默认长度为16
  • 如果超出了数组长度,数组会自动扩容
  • 创建一个新长度的新数组,将老数组的元素复制到新数组中,然后将新数组的地址值重新赋值给老数组
  • 默认每次扩容老数组的2倍+2
  • 如果一次性添加的数据超出了默认的扩容数组长度(2倍+2),比如存了36个字符,超出了第一次扩容的34,就按照实际数据个数为准,就是以36扩容

2.StringBuilder的使用

StringBuilder提供了append、reverse和toString等方法，用于字符串拼接、翻转和转换。

public class Demo01StringBuilder {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println(sb);

        StringBuilder sb1 = new StringBuilder("abc");
        System.out.println(sb1);

    }
}

常用方法:
StringBuilder append(任意类型数据) -> 字符串拼接，返回的是StringBuilder自己
StringBuilder reverse()-> 字符串翻转，返回的是StringBuilder自己
String toString()-> 将StringBuilder转成String-> 用StringBuilder拼接字符串是为了效率,为了不占内存，那么拼完之后我们后续可能会对拼接好的字符串进行处理，就需要调用String中的方法，所以需要将StringBuilder转成String

public class Demo02StringBuilder {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        StringBuilder sb1 = sb.append("张无忌");
        System.out.println(sb1);
        System.out.println(sb);
        System.out.println(sb==sb1);

        System.out.println("==============");
        //链式调用
        sb.append("赵敏").append("周芷若").append("小昭");
        System.out.println(sb);

        sb.reverse();
        System.out.println(sb);

        String s = sb.toString();
        System.out.println(s);
    }
}

3.练习：判断回文内容

以下是一个使用StringBuilder判断字符串是否为回文的示例代码。

public class Demo03StringBuilder {
    public static void main(String[] args) {
        //1.创建Scanner对象
        Scanner sc = new Scanner(System.in);
        String data = sc.next();
        //2.创建StringBuilder对象
        StringBuilder sb = new StringBuilder(data);
        //3.翻转
        sb.reverse();
        //4.将StringBuilder转成String
        String s = sb.toString();
        if (data.equals(s)){
            System.out.println("是回文内容");
        }else{
            System.out.println("不是回文内容");
        }

    }
}

http://www.kler.cn/a/450624.html

相关文章：

  • Rust 在前端基建中的使用
  • 搭建Elastic search群集
  • Unity3D仿星露谷物语开发5之角色单例模式
  • Redis篇--常见问题篇7--缓存一致性2（分布式事务框架Seata）
  • 安装fast_bev环境
  • 深度学习每周学习总结J9（Inception V3 算法实战与解析 - 天气识别）
  • 【论文阅读笔记】Learning to sample
  • 数据结构经典算法总复习（上卷）
  • redis延迟队列
  • 云边端一体化架构
  • pyinstaller打包资源文件和ini配置文件怎么放
  • 油漆面积（2017年蓝桥杯）
  • 在瑞芯微RK3588平台上使用RKNN部署YOLOv8Pose模型的C++实战指南
  • ABP vNext框架之EntityVersion
  • 绩效考核试题
  • 技术文档的语言表达：简洁、准确与易懂的平衡艺术
  • 嵌入式科普(24)从SPI和CAN通信重新理解“全双工”
  • 智能脂肪秤方案pcba设计研发步骤解析
  • 开发场景中Java 集合的最佳选择
  • 华为浏览器(HuaweiBrowser)，简约高效上网更轻松
  • uniapp Native.js原生arr插件服务发送广播到uniapp页面中
  • leetcode 面试经典 150 题：螺旋矩阵
  • Spring基础分析13-Spring Security框架
  • Python中zip
  • H3C MPLS跨域optionB
  • MacOS M3源代码编译Qt6.8.1