SuifengFlying

公告

欢迎来到我的博客，这里记录生活与技术。

了解更多

2072 字

10 分钟

常用类

2026-07-28

JavaSE

Java

/

JavaSE

/

常用类

lang包常用类#

Object类#

toString方法 ：获得对象的字符串形式，默认获得的是：包名+类名@十六进制内存地址
equals方法：比较两个对象是否相等，默认比较的是 == ，可以在子类中重写equals方法自定义比较的内容。
clone方法：将一个对象克隆，获得一个拥有相同属性及状态的对象，对象要进行克隆就要实现Cloneable接口，否则就会出现异常
hashCode方法：获得对象的哈希码值，默认的哈希码值是用对象的内存地址，通过一个哈希算法获得的值称为哈希码值。在某些环境下，代表了这个对象。
finalize方法：当垃圾回收器要回收这个对象时，会调用这个对象的finalize方法完成回收。程序员调用finalize方法是无效的

包装类/封装类#

八种基本类型都有对应的包装类，Java是面向对象编程，操作的都是对象，而基本类型不是对象，有时我们要将基本类型的数据当做对象使用，就要将基本类型的数据封装为包装类对象；

所有的包装类中都封装了一个对应的基本类型属性。

byte — Byte

short — Short

int — Integer

long — Long

char — character

fioat — Float

double — Double

boolean — Boolean

Integer#

如何将int封装为Integer对象；如何获取Integer对象中的int值

1
Integer integer1 = new Integer(3);
2
       Integer integer11 = new Integer(3);
3
       System.out.println(integer1==integer11);
4
       //将字符串解析为int
5
       Integer integer2 = new Integer("3");
6
       //推荐使用：
7
       //判断参数是否在-128~127 之间，如果在这个范围，
8
// 则从Integer数组（-128~127的Integer对象）中取出对应的Integer对象
9
//如果不在这个范围，则创建了新的Integer对象
10
//因为为了节省内存，-128~127之间的整数是最长使用的
11
//这个数组也称为整数常量池
12
Integer integer3 = Integer.valueOf("3");
13
Integer integer33 = Integer.valueOf("3");
14
System.out.println(integer3==integer33);

获取int值

1
Integer integer1 = new Integer(3);
2
System.out.println(integer1.intValue());

Integer.parseInt方法：将字符串解析为int值

方法就三个： Integer.valueOf 、Integer.parseInt、integer对象.intValue

自动拆装箱#

为了方便程序员编程，在JDK5版本出现了自动拆装箱功能，Integer和int在编码时类型无差别。

例如：

1
 public static void main(String[] args) {
2
    //自动装箱 ： 编译后的代码：Integer i = Integer.valueOf(3)
3
    //自动拆装箱以变量类型为准
4
    Integer i = 3;
5
    //自动拆箱 int i2 = 3;
6
    int i2 = Integer.valueOf(3);
7
    //自动装箱 test(Integer.valueOf(3))
8
    test(3);
9
 }
10
 public static void test(Object obj){
11
 }

清晰：

1
public static void main(String[] args) {
2
   Integer i1 = 3;
3
   Integer i2 = 3;
4
   System.out.println(i1==i2); //true
5
   Integer i3 = 300;
6
   Integer i4 = 300;
7
   System.out.println(i3==i4); //false
8
   int i5 = Integer.valueOf(300);  //int i5 = 300;
9
   int i6 = Integer.valueOf(300);
10
    System.out.println(i5==i6); //true
11
    //自动拆箱
12
    System.out.println(Integer.valueOf(3)+3==6);
13
    System.out.println(Integer.valueOf(3)==3);
14
}
15
public static void test(Object obj){
16
}

String字符串类#

String是一个内容不可改变的字符序列。

内容不可改变：字符串的内容不能改变，如果要改变内容，只能获得一个新的字符串。

**字符序列：**字符串属于字符序列，字符序列是CharSequence接口，需要CharSequence时，就可以传入一个字符串对象

1
 public static void main(String[] args) {
2
    String str = "abcdefg";
3
    String str2 = str.replace("bcd","BCD");
4
    System.out.println(str2);
5
 }

String类的源代码：

String类中封装了一个byte[] 数组，字符串的内容存储在byte[]中的，例如”ab”字符串对象的byte[]数组的内容为{97,98} ；例如 “你好” 字符串的byte[] 内容要对’你’和’好’进行默认字符集的编码。字符串的所有方法都是针对于byte[] 内容的操作。
String类中的byte[]数组是final的

String对象#

有两种表示： “abc” 常量对象和 new String(“abc”)；

类似于“abc” 常量对象存储到字符串常量池中，如果常量池中没有这个值的字符串对象则创建字符串对象存储到字符常量池；如果字符串常量池中有这个对象，则直接获取这个对象。

1
 String s1 = "ab";
2
 String s2 = "ab";
3
 System.out.println(s1==s2); //true
4
 String s3 = new String("ab");
5
 String s4 = new String("ab");
6
 System.out.println(s3==s4); //false
7
 //连接字符串一定会返回一个新的字符串
8
 String s5 = s1 + "";
9
 System.out.println(s1 == s5); //false
10
 //"ab"和"" 都是常量，在编译期先计算常量的结果
11
 //编译后就是String s6 = "ab"
12
 String s6 = "ab" + "";
13
 System.out.println(s1 == s6); //true

字符串类的API方法#

charAt(int index) : 返回的是char类型，返回指定位置的char值

1
String s = "abcdefg";
2
        //获取每个字符
3
        /*for (int i = 0; i < s.length(); i++) {
4
            System.out.println(s.charAt(i));
5
        }*/
6
        //获得反转后的字符串
7
        /*String str = "";
8
        for (int i = s.length()-1; i >=0; i--) {
9
            str = str + s.charAt(i);
10
        }
11
        System.out.println(str);*/
12
        //获得"cde"
13
        String str = "";
14
        for (int i = 0; i < s.length(); i++) {
15
            if(i>=2&&i<=4){
16
                str += s.charAt(i);
17
            }
18
        }
19
        System.out.println(str);

compareTo(String anotherString) : 两个字符串比较，返回1 ；-1；0
contains(String str) : 是否包含指定的字符串
endsWith和startsWith : 是否以指定字符串开头或结束
equals: 比较两个字符串的内容
getBytes() : 获得此字符串对象的byte[]数组

1
 String s = "abc";
2
 byte[] bytes = s.getBytes();
3
 String s1 = new String(bytes);
4
 System.out.println(s.equals(s1)); //true

indexOf(String str) : 获得给定字符串第一次出现的位置 ，如果字符串中没有指定的字符串则返回-1
lastIndexOf(String str) : 获得给定字符串最后第一次出现的位置
replace(String s1,String s2) :将字符串中的s1内容替换为s2内容。返回一个新的字符串
split(String s) : 根据给定的字符串对字符串进行拆分，返回字符串数组

1
String s = "abcbc";
2
       String[] strs = s.split("b");
3
       for (int i = 0; i < strs.length; i++) {
4
           System.out.println(strs[i]);
5
       }
6
       System.out.println("----------");
7
       strs = s.split("c");
8
       for (int i = 0; i < strs.length; i++) {
9
           System.out.println(strs[i]);
10
       }
11
       System.out.println("----------");
12
       strs = s.split("xyz");
13
       for (int i = 0; i < strs.length; i++) {
14
           System.out.println(strs[i]);
15
       }

substring(int startIndex) : 获取子串，又叫截取字符串，从startIndex开始截取到最后
substring(int startIndex,int endIndex) : 从startIndex开始到 endIndex-1 。前闭后开
toUpperCase和toLowerCase : 转大写、小写
trim() ：去掉字符串前后空格。

StringBufier#

是一个带缓冲区的内容可改变的字符序列

带缓冲区：存储的字符串也是存储在byte[]中，只是byte[]数组不是final的，可扩容的；每次扩容byte[]时会额外的扩容预留的长度
**内容可改变：**在改变字符串内容时，不会创建新的对象，在原对象的内容后面进行追加或修改
**字符序列：**实现了CharSequence接口

StringBufier在处理字符串时（体现的是改变字符串的内容）效率高于String

StringBufier和String不能转型的，但是StringBufier提供了toString方法获得字符串内容，通过newStringBufier(String参数）获得一个StringBufier对象

实例：用String连接10000次字符串和用StringBufier连接10000次对比

1
 public static void main(String[] args) {
2
    //1w  91ms      1
3
    //10w  836ms    9
4
    //100w 47517ms  23
5
    /*long start = System.currentTimeMillis();
6
    String str = "a";
7
    for (int i = 0; i < 1000000; i++) {
8
        str += "a";
9
    }
10
    long end = System.currentTimeMillis();
11
    System.out.println("String连接耗时："+(end-start));*/
12
    long start = System.currentTimeMillis();
13
    StringBufier stringBufier = new StringBufier("a");
14
    for (int i = 0; i < 10000000; i++) {
15
        stringBufier.append("a");
16
    }
17
    long end = System.currentTimeMillis();
18
    System.out.println("StringBufier连接耗时："+(end-start));
19
 }

String在改变字符串内容（连接操作）时效率下降极快

研究StringBufier的源代码

1
public StringBufier(String str) {
2
    super(str.length() + 16);
3
    append(str);
4
}

new StringBufier(“a”) : 创建了StringBufier对象，封装了一个长度为1+16的byte[] 。16长度就是缓冲，之后将”a”添加到byte[]中

执行stringBufier.append（“a”）: 先判断是否需要扩容，扩容时会有容量的余量，将“a”添加到byte数组中

StringBufier的API方法#

相比String类，增加了一些API方法

append方法：向末尾追加内容
delete方法：删除范围的字符串
insert方法：向执行位置插入字符串
reverse方法：反转字符串

StringBuilder类#

StringBuilder和StringBufier具有相同的API，也是带缓冲区的内容可改变的字符序列。

StringBufier是线程安全的，StringBuilder是线程不安全的，StringBuilder效率高

线程安全：两个线程同时操作一个资源时，为了保证数据的一致性，在一个线程使用资源时对资源加锁，另一个线程将等待直到锁被打开，才能使用资源，那么这个资源是线程安全的，对于两个线程来讲是同步的

线程安全会影响效率，线程不安全的效率高于线程安全。

常用类

https://mizuki.mysqil.com/posts/10常用类/

作者

SuifengFlying

发布于

2026-07-28

许可协议

CC BY-NC-SA 4.0

Java SE

8 / 13

接口（interface）集合框架

欢迎来到 SuifengFlying!