Java | apijava01字符串与包装类

最新推荐文章于 2025-12-01 18:34:47 发布

原创最新推荐文章于 2025-12-01 18:34:47 发布 · 725 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#java #intellij idea

软件开发专栏收录该内容

7 篇文章

订阅专栏

apijava01

字符串常量池
String常用方法
- lenth()
- trim()
- toUpperCase()/toLowerCase()
- startsWith()/endsWith()
- charAt()
StringBuilder类
StringBuilder的常用方法
- append()
- delete()
- replace()
- insert()
Object类
包装类
生成一个4位验证码(数字和字母的组合)，输出到控制台并提示用户输入验证码，输入后若正确则提示验证码正确，若错误则提示验证码错误。注意：不区分大小写。

字符串常量池

String字符串类型
- java.lang.String类使用final修饰，不能被继承
- String的底层封装的是一个字符数组
- String在内存中采用Unicode编码格式，每个字符占用2个字节的内存空间
- 字符串对象一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值（指向新的对象）
  - String称为不变对象
字符串常量池：是java对String的一个优化措施
- java推荐我们使用字面量/直接量（直接""）的方式来创建字符串对象，并且会将所有以字面量方式创建的对象缓存到常量池中，当使用相同字面量再创建字符串对象时，将会复用常量池中的对象，以减少内存开销。

代码

StringDemo.java

package apijava01;

/**
 * String字符串类
 */
public class StringDemo {
    public static void main(String[] args) {
        String s1 = "123abc"; //字面量创建的字符串第一次使用时会还存在常量池中
        String s2 = "123abc"; //重用s1对象（复用常量池中"123abc"对象）
        String s3 = "123abc"; //依然重用
        String s4 = new String("123abc");//new则一定创建新对象，不推荐这样的方式来创建字符串对象
        System.out.println(s1==s2);//true, s1和s2为引用类型变量，保存的是地址，此时地址相同
        System.out.println(s1==s3);//true
        System.out.println(s1==s4);//false, s1和s4的地址不同
        System.out.println("-----------------------------------");

        String s = "123";
        String s5 = s + "abc";//拼接字符串会产生新对象，s5指向新对象
        System.out.println(s5==s1);//false，没有重用常量池对象
        String s6 = "123"+"abc";//两个字面量连接时，会触发预计算特性，直接编译为String s6="123abc"，复用该对象
        System.out.println(s6==s1);//true
        System.out.println("-----------------------------------");

        String s7 = "123abc";
        String s8 = new String("123abc");
        System.out.println(s7==s8);//false, ==是比地址，因为地址不同，所以为false
        System.out.println(s7.equals(s8));//true, equals()是比较内容相同
    }
}

结果

true
true
false
-----------------------------------
false
true
-----------------------------------
false
true

String常用方法

String常用方法：
- length(): 获取字符串的长度（字符个数）
- trim(): 去除当前字符串两边的空白字符
- toUpperCase() / toLowerCase(): 将当前字符串中的英文部分给转换为全大写 / 全小写
- startsWith() / endsWith(): 判断当前字符串是否是以给定的字符串开始 / 结束的
- charAt(): 返回当前字符串指定位置上的字符----根据位置找字符

代码

LengthDemo.java

package apijava01;

/**
 * int length()
 * 返回当前字符串的长度（字符个数）
 */
public class LengthDemo {
    public static void main(String[] args) {
        String str = "我爱Java!";
        int len = str.length();//获取str的长度
        System.out.println(len);//7
    }
}

TrimDemo.java

package apijava01;

/**
 * String trim()
 * 去除字符串两边的空白字符
 */
public class TrimDemo {
    public static void main(String[] args) {
        String str = "   hello world         ";
        String trim = str.trim(); //trim()后得到新的字符串对象并存储在trim变量中
        System.out.println(trim); //hello world
        System.out.println(str);  //   hello world         ,字符串是不变对象,str内容不变
    }
}

ToUpperCaseDemo.java

package apijava01;

/**
 * String toUpperCase()
 * String toLowerCase()
 * 将当前字符串中的英文部分转换为全大写或全小写
 */
public class ToUpperCaseDemo {
    public static void main(String[] args) {
        String str = "我爱Java!";
        String upper = str.toUpperCase();//将str中的英文部分转换为全大写，并赋值给upper
        System.out.println(upper);//我爱JAVA!
        String lower = str.toLowerCase();//将str中的英文部分转换为全小写，并赋值给lower
        System.out.println(lower);//我爱java!
        System.out.println(str);  //我爱Java!
    }
}

StartsWithDemo.java

package apijava01;

/**
 * boolean startsWith(String str)
 * boolean endsWith(String str)
 * 判断当前字符串是否是以给定字符串（str）开始或结束的
 */
public class StartsWithDemo {
    public static void main(String[] args) {
        String str = "www.baidu.com";
        boolean start = str.startsWith("www");//判断str是否是以www开头的
        System.out.println(start);//true

        boolean end = str.endsWith(".png");//判断str是否是以.png结束的
        System.out.println(end);//false
    }
}

CharAtDemo.java

package apijava01;

/**
 * char charAt(int index)
 * 获取当前字符串中指定位置(index)的字符
 */
public class CharAtDemo {
    public static void main(String[] args) {
        String str = "thinking in java"; //java编程思想
        char c = str.charAt(9);
        System.out.println(c); //i
    }
}

结果

LengthDemo.java

TrimDemo.java

hello world
   hello world

ToUpperCaseDemo.java

我爱JAVA!
我爱java!
我爱Java!

StartsWithDemo.java

true
false

CharAtDemo.java

StringBuilder类

StringBuilder类：
- 由于String是不变对象，每次修改内容都会创建新的对象，因此String不适合频繁修改操作，为了解决这个问题，java提供了StringBuilder类。
- StringBuilder类是专门用于修改字符串的一个类，内部维护一个可变的char数组，所做操作都是在这个数组之上进行的，修改速度、性能优秀，并且提供了修改字符串的常见方式：增、删、改、插、反转。

代码

StringAndStringBuilderDemo.java

package apijava01;

/**
 * String和StringBuilder的性能测试
 * 1.String是不变对象，因此不适合频繁修改内容，开销大、性能差
 * 2.StringBuilder是可变对象，适合频繁修改内容，开销小、性能好
 */
public class StringAndStringBuilderDemo {
    public static void main(String[] args) {
        String str = "a";
        for (int i = 0; i < 100000; i++) { //10万次
            str = str + "a";
        }
        System.out.println("执行完毕");

        StringBuilder builder = new StringBuilder("a");
        for (int i = 0; i < 100000; i++) { //10万次
            builder.append("a");
        }
        System.out.println("执行完毕");
    }
}

结果

执行完毕
执行完毕

StringBuilder的常用方法

StringBuilder的常用方法：
- append(): 追加内容（增）
- delete(): 删除部分内容（删）
- replace(): 替换部分内容（改）
- insert(): 插入内容（插）

代码

StringBuilderDemo.java

package apijava01;

/**
 * java.lang.StringBuilder专门用于编辑字符串内容的工具类
 * 其内部维护一个可变的char数组
 * 同时提供了编辑字符串内容的相关操作：增删改插
 */
public class StringBuilderDemo {
    public static void main(String[] args) {
        String str = "好好学习Java";
        StringBuilder builder = new StringBuilder(str);

        //append():追加内容---在末尾追加
        builder.append("，为了做出项目");//在末尾追加内容
        System.out.println(builder);//好好学习Java，为了做出项目

        //replace():替换部分内容（含头不含尾）
        builder.replace(9,16,"就是为了改变世界");
        System.out.println(builder);

        //delete():删除部分内容（含头不含尾）
        builder.delete(0,8);//删除下标为0到7的
        System.out.println(builder);//，就是为了改变世界

        //insert():插入内容
        builder.insert(0,"活着");//在下标0的位置插入活着
        System.out.println(builder);//活着，就是为了改变世界
        System.out.println("----------------------------------");

        //StringBuilder的创建方式
        StringBuilder builder1 = new StringBuilder();//空字符串
        StringBuilder builder2 = new StringBuilder("abc");//abc串
        System.out.println(builder1);
        System.out.println(builder2);
        System.out.println("----------------------------------");

        //String和StringBuilder互转：
        String s = "abc";
        StringBuilder builder3 = new StringBuilder(str);//abc串，基于String对象构造StringBuilder
        String s2 = builder3.toString();//将builder3转换为String
        System.out.println(s);
        System.out.println(builder3);
        System.out.println(s2);
    }
}

结果

好好学习Java，为了做出项目
好好学习Java，就是为了改变世界
，就是为了改变世界
活着，就是为了改变世界
----------------------------------

abc
----------------------------------
abc
好好学习Java
好好学习Java

Object类

Object
- 是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态
- Object中有两个经常被派生类重写的方法：toString()和equals()
  - 调用Object类的toString()时默认返回：类的全称@hashcode值，没有参考意义，所以常常重写toString()来返回具体的属性值
  - 注意：String、StringBuilder都重写了toString()来返回具体的字符串内容
  - 调用Object类的equals()时默认比较的还是==（即比较地址），没有参考意义，所以常常重写equals()来比较具体的属性值
  - 注意事项：
    - String类、包装类重写了equals()来比较内容是否相等，但StringBuilder并没有
    - 重写equals()的基本原则：
      - 原则上要比较两个对象的属性值是否相同
      - 两个对象必须是同一类型的，若类型不同则直接返回false

代码

Point.java

package apijava01;

import java.util.Objects;

public class Point {
    private int x;
    private int y;

    public Point() {
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

ToStringDemo.java

package apijava01;

public class ToStringDemo {
    public static void main(String[] args) {
        //输出引用变量时默认调用Object类的toString()方法
        //该方法返回的字符串格式为：类的全称@hashcode值
        //但我们真正想输出的应该是对象的属性值
        //我们认为Object类的toString()并不能满足需求
        //因此我们常常重写toString()来返回具体的属性值
        Point p = new Point(100,200);
        System.out.println(p);
        System.out.println(p.toString());
    }
}

EqualsDemo.java

package apijava01;

public class EqualsDemo {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        //String类重写了equals()来比较字符串内容是否相同
        System.out.println(s1.equals(s2));//true

        StringBuilder builder1 = new StringBuilder("hello");
        StringBuilder builder2 = new StringBuilder("hello");
        //StringBuilder类没有重写equals(),因此调用的还是Object类的equals()比较地址
        System.out.println(builder1.equals(builder2));//false

        //s1与builder1的类型不同，所以equals()一定是false
        System.out.println(s1.equals(builder1)); //false
        System.out.println("-----------------------------------------");

        /*
          调用Object的equals()，内部还是使用==比较地址，没有参考意义
          若想比较对象的属性值是否相同，我们认为Object类的equals()并不能满足需求
          因此常常重写equals()来比较属性值
         */
        Point p1 = new Point(100,200);
        Point p2 = new Point(100,200);
        System.out.println(p1==p2);//false，==比较的是地址
        //因为Point类重写了equals()方法
        //所以此处调用的是重写之后的equals()，比较的是属性的值是否相同
        System.out.println(p1.equals(p2));//true
    }
}

结果

ToStringDemo.java

Point{x=100, y=200}
Point{x=100, y=200}

EqualsDemo.java

true
false
false
-----------------------------------------
false
true

包装类

包装类：
- java定义了8个包装类，目的就是为了解决基本类型不能直接参与面向对象开发的问题，使基本类型可以通过包装类的形式存在。
- 包含：Integer、Character、Byte、Short、Long、Float、Double、Boolean，其中Character和Boolean是直接继承自Object类的，其余6个包装类继承自Number类。
- JDK1.5时推出了一个新特性：自动拆装箱。当编译器编译时若发现是基本类型与包装类型之间的相互赋值，则自动补全代码完成转换工作，这个过程叫做自动拆装箱。

代码

IntegerDemo.java

package apijava01;

/**
 * wrapper
 * 包装类的演示
 */
public class IntegerDemo {
    public static void main(String[] args) {
        //演示包装类的定义：
        Integer i1 = new Integer(5);
        Integer i2 = new Integer(5);
        System.out.println(i1==i2);//false，==比较的是地址
        System.out.println(i1.equals(i2));//true，包装类重写equals()比较值了
        
        //valueOf()方法会复用1个字节（-128到127）范围内的数据，建议使用valueOf()
        Integer i3 = Integer.valueOf(5);
        Integer i4 = Integer.valueOf(5);
        System.out.println(i3==i4);//true
        System.out.println(i3.equals(i4));//true，包装类重写equals()比较值了

        //演示基本类型与包装类型之间互转：
        Integer i = Integer.valueOf(5);//基本类型转换为包装类型
        int j = i.intValue();//包装类型转换为基本类型

        //触发了自动装箱特性，会被编译为：Integer m = Integer.valueOf(5);
        Integer m = 5;//基本类型到引用类型---装
        //触发了自动拆箱特性，会被编译为：int n = m.intValue();
        int n = m;//引用类型到基本类型---拆

        //演示包装类的常用操作：
        //1)可以通过包装类来获取基本类型的取值范围：
        int max = Integer.MAX_VALUE; //获取int的最大值
        int min = Integer.MIN_VALUE; //获取int的最小值
        System.out.println("int的最大值为：" + max + "，最小值为：" + min);
        long max1 = Long.MAX_VALUE; //获取long的最大值
        long min1 = Long.MIN_VALUE; //获取int的最小值
        System.out.println("long的最大值为：" + max1 + "，最小值为：" + min1);

        //2)通过包装类可以将字符串转换为对应的基本类型
        String s1 = "39";
        int age = Integer.parseInt(s1);//将字符串s1转换为int类型并赋值给age
        System.out.println(age); //39---int类型

        String s2 = "123.456";
        double price = Double.parseDouble(s2); //将字符串s2转换为double类型并赋值给price
        System.out.println(price); //123.456---double类型
    }
}

结果

false
true
true
true
int的最大值为：2147483647，最小值为：-2147483648
long的最大值为：9223372036854775807，最小值为：-9223372036854775808
39
123.456

验证码

API：应用程序接口，java中提供有非常常用的类、接口、方法等。
java.lang包：语言包，java将特别常用的类封装到lang包中了，它认为写程序过程中一定会用到这些类，所以java.lang包中的类是不需要import的。
String和StringBuilder的选择
- 字符串内容若需要查看，则建议用String—实际应用中一般都是查看
- 字符串内容若需要频繁修改，则建议StringBuilder

代码

Test.java

package apijava01;

import java.util.Random;
import java.util.Scanner;

/**
 * 验证码
 */
public class Test {
    public static void main(String[] args) {
        String line = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Random random = new Random();
        String code = "";
        for (int i = 0; i < 4; i++) {
            int index = random.nextInt(line.length());
            char c = line.charAt(index);
            code += c;
        }
        System.out.println("验证码：" + code);
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入上述验证码：");
        String input = scan.nextLine();

        if(code.equalsIgnoreCase(input)){
            System.out.println("通过！");
        }else{
            System.out.println("失败！");
        }
    }
}

结果

验证码：7YPQ
请输入上述验证码：
7ypq
通过！