1. Object 类

Object 是类层次结构的根，每个类都默认继承 Object 作为超类，因此 Object 类的方法是所有类都具备的核心方法。

NO.方法名称类型说明
1public Object()构造器无参构造
2public boolean equals(Object obj)普通对象比较
3public int hashCode()普通取得哈希码
4public String toString()普通对象打印时调用

1.1 == 与 equals () 方法

1.1.1 ==
  • 基本类型：比较值，只要变量值相等，结果为 true

java

运行

int a = 5;
int b = 6;
if (a == b) {
    // 逻辑处理
}
  • 引用类型：比较引用（内存地址），只有指向同一个对象时，结果才为 true

java

运行

Student s1 = new Student();
Student s2 = new Student();
if (s1 == s2) {
    // 逻辑处理（此处为false，因为是两个不同对象）
}
1.1.2 equals()
  • 默认行为：所有类继承 Object 的 equals () 方法，默认实现与==一致，比较对象地址

java

运行

public boolean equals(Object obj) {
    return (this == obj);
}
  • 特例：Integer、Long、Double、String、Date 及包装类重写了 equals ()，比较类型 + 内容，不考虑地址
1.1.3 重写 equals () 方法

场景：需要根据对象属性而非地址进行比较时

java

运行

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        if (age != student.age) return false;
        return name != null && name.equals(student.name);
    }
}

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("林青霞", 30);
        System.out.println(s1.equals(s2)); // 输出true，属性相同
    }
}

1.2 hashCode () 方法

1.2.1 hashCode () 概述
  • 本地方法：定义在java.lang.Object中，返回对象哈希值（基于内存地址或属性计算的整型值）

java

运行

public native int hashCode();
  • 核心作用：在散列表（HashMap、HashSet 等）中快速查找和存储对象，提高效率
1.2.2 重写 hashCode 方法

重写 equals () 时必须重写 hashCode ()，保证 equals 相等的对象 hashCode 一定相同

java

运行

class Teacher {
    private String name;
    private int age;

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Teacher teacher = (Teacher) o;
        if (age != teacher.age) return false;
        return name.equals(teacher.name);
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + (name == null ? 0 : name.hashCode());
        result = 31 * result + age;
        return result;
    }
}

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        if (age != student.age) return false;
        return name != null && name.equals(student.name);
    }

    // 简化写法
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
1.2.3 hashCode 和 equals 的关系
  • 核心结论：
    1. 两个对象 equals 相等 → hashCode 一定相同
    2. 两个对象 hashCode 相同 → 不一定 equals 相等（仅表示在散列表中存放在同一 "篮子"）

1.3 toString () 方法

1.3.1 toString () 概述
  • Object 类默认实现：返回 "类名 @哈希码十六进制" 字符串

java

运行

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
1.3.2 重写 toString () 方法

场景：需要自定义对象打印格式时

java

运行

class Student {
    private String name;
    private int age;

    public Student() {}

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter/setter省略

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student("林青霞", 19);
        System.out.println(s1.toString()); // 输出Student{name='林青霞', age=19}
    }
}

2. 包装类

2.1 包装类概述

Java 为 8 种基本数据类型提供了对应的包装类，使其具备类的特性（可调用方法、参与面向对象编程）。

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

2.2 Integer 类

2.2.1 概述

Integer 封装了 int 类型属性，提供了操作 int 数据的常用方法。

2.2.2 Integer 构造方法（已过时，了解即可）

java

运行

// 1. 通过int值创建
Integer i1 = new Integer(100);
System.out.println(i1);

// 2. 通过String值创建（仅支持数字字符串）
Integer i2 = new Integer("100");
// Integer i2 = new Integer("abc"); // 抛出NumberFormatException
System.out.println(i2);
2.2.3 Integer 成员方法
方法说明
public int intValue()以 int 类型返回 Integer 的值
public static int parseInt(String s)将字符串解析为十进制 int
public static String toString(int i)将 int 转换为 String
public static Integer valueOf(int i)返回表示指定 int 值的 Integer 实例
public static Integer valueOf(String s)返回表示指定字符串值的 Integer 实例

2.3 int 和 String 类型的相互转换

2.3.1 int 转换为 String

java

运行

public static void main(String[] args) {
    int number = 100;

    // 方式1：直接拼接空字符串（简单直观）
    String s1 = number + "";
    System.out.println(s1);

    // 方式2：String.valueOf()（推荐，效率更高）
    String s2 = String.valueOf(number);
    System.out.println(s2);
}
2.3.2 String 转换为 int

java

运行

public static void main(String[] args) {
    String s = "100";

    // 方式1：String → Integer → int
    Integer i = Integer.valueOf(s);
    int x = i.intValue();
    System.out.println(x);

    // 方式2：Integer.parseInt()（推荐，直接转换）
    int y = Integer.parseInt(s);
    System.out.println(y);
}

2.4 自动拆箱和自动装箱

  • 自动装箱：基本数据类型 → 对应包装类
  • 自动拆箱：包装类 → 对应基本数据类型

java

运行

​
​
// 自动装箱：int → Integer
Integer i = 30;
Float f = 30.3f;

// 自动拆箱：Integer → int
int x = i;
float y = f;

​

（2）使用场景

① 适合的场景（解决基本类型默认值问题）：

java

运行

// 问题：int类型有默认值0，无法返回null；改用Integer即可
public static Integer method(Integer a){
    return null;
}

② 不适合的场景（性能损耗）：

java

Integer sum = 0;
for (int i = 0; i < 5000; i++) {
    sum = sum + i; // 问题：每次运算都会自动拆箱+装箱，创建5000个Integer对象，消耗内存
}

3. 字符串类

3.1 String 类

3.1.1 String 类的概述
  • 定义：String 类代表字符串，所有双引号字符串（"abc"）都是 String 类的对象
  • 核心特点：
    1. final 类，不能被继承
    2. 底层用final char[] value存储，创建后内容不可变
    3. 字符串常量存储在方法区常量池，可共享

java

运行

String s1 = "abc";// 字面量方式（常量池）
String s2 = "abc";
s1 = "hello";// 不是修改原字符串，而是创建新字符串"hello"

System.out.println(s1 == s2); // true（初始指向同一常量）
System.out.println(s1); // hello
System.out.println(s2); // abc
3.1.2 String 类的构造方法
方法名说明
public String()创建空字符串（value = new char [0]）
public String(String original)根据已有字符串创建
public String(char[] chs)根据字符数组创建

java

运行

// 空字符串
String s1 = new String();
System.out.println("s1:" + s1);

// 基于字符串创建
String s2 = new String("abc");
System.out.println("s2:" + s2);

// 基于字符数组创建
char[] arr = {'a', 'b'};
String s3 = new String(arr);
System.out.println("s3:" + s3);
3.1.3 构造方法及内存差异

字面量方式：

1. 内存示意图（简易版）

2. 图示解释

  • 栈内存：s1 和 s2 是引用变量，存储的是 “堆中同一个 String 对象” 的地址（地址 A），因此 s1 和 s2 指向同一个对象；
  • 堆内存：只创建 1 个 String 对象，该对象的value属性存储 “常量池中 char 数组” 的地址（地址 B）；
  • 常量池：存储实际的字符数组char[]，是字符串的真实数据，被所有指向该字面量的 String 对象共享。

构造方法方式：

1. 内存示意图（简易版）

2. 图示解释

  • 栈内存：s3 和 s4 是不同的引用变量，分别存储 “堆中两个不同 String 对象” 的地址（地址 C、地址 D）；
  • 堆内存：new String()会强制创建新的 String 对象，因此堆中生成 2 个独立的 String 对象，但这两个对象的value属性都指向常量池中同一个 char 数组的地址（地址 B）；
  • 常量池：char 数组依然只存储一份，是 JVM 的优化机制，避免重复创建相同字符数据。

内存示意图简化说明：

  • 字面量方式：栈（s1/s2）→ 堆（同一个 String 对象）→ 常量池（char []）；
  • 构造方法方式：栈（s3/s4）→ 堆（两个不同 String 对象）→ 常量池（同一个 char []）。
3.1.4 String 类的常用方法
方法说明
char charAt(int index)返回指定索引的字符
boolean equals(Object anObject)比较字符串内容（区分大小写）
int indexOf(String str)返回子字符串首次出现的索引
int length()返回字符串长度
String replaceAll(String regex, String replacement)正则替换所有匹配子串
char[] toCharArray()转换为字符数组
String trim()去除首尾空格
String substring(int beginIndex)从 beginIndex 截取到末尾
String substring(int beginIndex, int endIndex)截取 [beginIndex, endIndex) 区间
String[] split(String regex)按正则拆分字符串
String toLowerCase()转为小写
String toUpperCase()转为大写

java

运行

// 示例1：equals和大小写转换
String s1 = "HelloWorld";
String s2 = "helloworld";
System.out.println(s1.equals(s2)); // false
System.out.println(s1.toLowerCase().equals(s2)); // true

// 示例2：截取字符串
String s7 = "北京是我国的首都";
String s8 = s7.substring(2); // 从索引2开始
System.out.println(s8); // 是我国的首都
String s9 = s7.substring(2, 5); // [2,5)
System.out.println(s9); // 是我国

// 示例3：拆分字符串
String str2 = "hello.world.java";
String[] strs2 = str2.split("\\."); // 注意转义
for (int i = 0; i < strs2.length; i++) {
    System.out.println(strs2[i]); // 依次输出hello、world、java
}
练习
  1. 模拟用户登录：给定用户名和密码，提供 3 次登录机会，登录成功 / 失败给出对应提示
  2. 字符串反转：将指定字符串或字符串指定部分反转（如 "abcdefg" 反转为 "abfedcg"）

3.2 StringBuffer 类

3.2.1 StringBuffer 类的概述
  • 可变字符序列，可视为 "字符串容器"，支持内容增删
  • 核心特点：
    1. 线程安全（方法加 synchronized），效率较低
    2. 底层用可变char[]存储
3.2.2 StringBuffer 类的构造方法
方法名说明
StringBuffer()初始容量 16 的空缓冲区
StringBuffer(int size)指定容量的缓冲区
StringBuffer(String str)以指定字符串初始化

java

运行

// 空缓冲区
StringBuffer sb = new StringBuffer();
System.out.println("sb:" + sb);
System.out.println("sb.length():" + sb.length()); // 0

// 基于字符串初始化
StringBuffer sb2 = new StringBuffer("hello");
System.out.println("sb2:" + sb2); // hello
System.out.println("sb2.length():" + sb2.length()); // 5
3.2.3 StringBuffer 类的常用方法
方法说明
StringBuffer append(xxx)添加数据，返回自身（支持链式调用）
StringBuffer reverse()反转字符序列
String toString()转换为 String 类型

java

运行

// 链式添加
StringBuffer sb = new StringBuffer();
sb.append("hello").append("world").append("java").append(100);
System.out.println("sb:" + sb); // helloworldjava100

// 反转
sb.reverse();
System.out.println("sb:" + sb); // 001avajdlrowolleh

// 拆分（需先转String）
StringBuffer sb3 = new StringBuffer("h,e,l,l,o");
String[] strArr = sb3.toString().split(",");
for (String str : strArr) {
    System.out.print(str + " "); // h e l l o
}
练习

定义方法实现字符串反转：键盘录入字符串，调用方法后输出反转结果（如输入 abc，输出 cba）

3.3 StringBuilder 类

3.3.1 StringBuilder 类的概述
  • 与 StringBuffer 功能完全一致，均为可变字符序列
  • 核心特点：
    1. 线程不安全，效率较高（无同步锁）
    2. 底层用可变char[]存储
    3. 单线程环境优先使用（推荐）
效率对比案例

java

运行

public class StringBuilderDemo {
    public static void main(String[] args) {
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");

        // StringBuffer测试
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

        // StringBuilder测试
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        // String测试（效率最低）
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));
    }
}
练习
  1. 从路径中提取文件名（如 D:\myfile\hello.java → hello.java）
  2. 从路径中提取文件类型（如 D:\myfile\hello.java → .java）

4. 日期类

4.1 System 类

  • 核心方法：public static long currentTimeMillis()
  • 功能：返回当前时间与 1970 年 1 月 1 日 00:00:00 的毫秒差值（时间戳）
  • 用途：计算程序执行时间

java

运行

long startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
    if (i % 2 == 0) System.out.println(i);
}
long endTime = System.currentTimeMillis();
System.out.println("执行时间：" + (endTime - startTime) + "ms");

4.2 Date 类

4.2.1 Date 类概述

代表特定时间点，精确到毫秒。

4.2.2 Date 类构造方法
方法名说明
public Date()初始化当前时间
public Date(long date)初始化指定时间戳（毫秒）对应的时间

java

运行

// 当前时间
Date d1 = new Date();
System.out.println(d1);

// 指定时间戳（1小时=3600000毫秒）
long date = 1000 * 60 * 60;
Date d2 = new Date(date);
System.out.println(d2);
4.2.3 Date 类常用方法
方法名说明
public long getTime()获取时间戳
public void setTime(long time)设置时间戳

java

运行

Date date = new Date();
System.out.println(date);
System.out.println(date.getTime()); // 时间戳
System.out.println(System.currentTimeMillis()); // 与getTime()结果一致

// 设置时间
long time = System.currentTimeMillis();
date.setTime(time);
System.out.println(date);

4.3 Calendar 类

4.3.1 Calendar 类概述
  • 抽象类，提供日期字段操作（年、月、日、时、分、秒）
  • 获取实例：Calendar rightNow = Calendar.getInstance();（无需 new）
4.3.2 Calendar 类常用方法
方法名说明
public final void set(int year,int month,int date)设置年月日
public int get(int field)获取指定字段值（field 为 Calendar 常量）
public abstract void add(int field, int amount)增减指定字段值

java

运行

// 获取Calendar实例
Calendar c = Calendar.getInstance();

// 获取当前日期
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1; // 月份从0开始，需+1
int date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");

// 3年前的今天
c.add(Calendar.YEAR, -3);
year = c.get(Calendar.YEAR);
System.out.println(year + "年" + month + "月" + date + "日");

// 10年后的10天前
c.add(Calendar.YEAR, 10);
c.add(Calendar.DATE, -10);
year = c.get(Calendar.YEAR);
date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");

// 直接设置日期
c.set(2050, 10, 10); // 2050年11月10日（月份10对应11月）
year = c.get(Calendar.YEAR);
month = c.get(Calendar.MONTH) + 1;
date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");
练习

键盘输入任意年份，计算该年 2 月有多少天（提示：3 月 1 日往前推 1 天即为 2 月最后一天）

4.4 SimpleDateFormat 类

4.4.1 SimpleDateFormat 类概述
  • 功能：日期与字符串的格式化转换
  • 所在包：java.text.SimpleDateFormat
4.4.2 SimpleDateFormat 类构造方法
方法名说明
public SimpleDateFormat()默认格式（如：12-10-23 下午 2:30）
public SimpleDateFormat(String pattern)自定义格式（如 "yyyy-MM-dd HH:mm:ss"）
4.4.3 SimpleDateFormat 类常用方法
方法名说明
public final String format(Date date)Date → String（格式化）
public Date parse(String source)String → Date（解析，需处理异常）

java

运行

import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws Exception {
        // 1. Date → String（格式化）
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s); // 如：2024年05月20日 14:30:00

        // 2. String → Date（解析）
        String ss = "2048-08-09 11:11:11";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}
练习

定义日期工具类DateUtils，包含两个静态方法：

  1. public static String dateToString(Date date, String pattern)：日期转指定格式字符串
  2. public static Date stringToDate(String str, String pattern)：字符串转指定格式日期定义测试类DateTest验证工具类。

5. Arrays 工具类

5.1 Arrays 类概述

提供数组常用操作（排序、拷贝、转字符串等），所有方法均为静态方法，通过Arrays.调用。

5.2 Arrays 类构造方法

构造方法为私有，无法创建实例，直接使用静态方法。

5.3 Arrays 工具类常用方法

方法说明
public static String toString(int[] a)数组转字符串（便于打印）
public static void sort(int[] a)数组排序（默认升序）
public static int[] copyOf(int[] original, int newLength)数组拷贝（指定新长度）
public static int[] copyOfRange(int[] original, int from, int to)区间拷贝（[from, to)）

java

运行

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        // 1. 数组排序与转字符串
        int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前：" + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));

        // 2. 数组拷贝
        int scores[] = {57, 81, 68, 75, 91};
        // 拷贝原数组，新数组长度8（多余位置补默认值0）
        int[] newScores1 = Arrays.copyOf(scores, 8);
        System.out.println("拷贝后（指定长度）：" + Arrays.toString(newScores1));

        // 拷贝区间[0,5)（即原数组全部元素）
        int[] newScores2 = Arrays.copyOfRange(scores, 0, 5);
        System.out.println("区间拷贝后：" + Arrays.toString(newScores2));
    }
}

6. Random 类

6.1 概述

用于生成随机数，支持整数、浮点数、布尔值等多种类型。

6.2 Random 类的构造方法

方法名说明
public Random()无参构造（默认以系统时间为种子）
public Random(long seed)有参构造（指定种子，种子相同则随机序列相同）

java

运行

// 无参（每次随机序列不同）
Random r1 = new Random();
// 有参（种子10，每次运行随机序列相同）
Random r2 = new Random(10);

6.3 Random 类中的常用方法

方法说明
nextInt()随机生成 int 范围内整数（-2³¹~2³¹-1）
nextInt(int bound)随机生成 [0, bound) 区间整数
nextLong()随机生成 long 范围内整数
nextFloat()随机生成 [0.0, 1.0) 区间浮点数
nextDouble()随机生成 [0.0, 1.0) 区间浮点数
nextBoolean()随机生成 boolean 值（true/false）

java

运行

import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();

        // 随机boolean值
        for (int i = 0; i < 3; i++) {
            System.out.println("nextBoolean:" + random.nextBoolean());
        }

        // 随机[0.0,1.0)浮点数
        for (int i = 0; i < 3; i++) {
            System.out.println("nextDouble:" + random.nextDouble());
        }

        // 随机[0,10)整数
        for (int i = 0; i < 3; i++) {
            System.out.println("nextInt(10):" + random.nextInt(10));
        }

        // 多线程环境推荐使用ThreadLocalRandom（效率更高，无线程竞争）
        // 生成[1,100]区间整数（注意：上限不包含，需+1）
        int num = ThreadLocalRandom.current().nextInt(1, 101);
        System.out.println("ThreadLocalRandom:" + num);
    }
}
练习

随机生成 5 个 50~100 的随机数（包含 50 和 100）

总结

本文详细介绍了 Java 开发中最常用的 6 大类：Object 类（所有类的父类）、包装类（基本类型的面向对象封装）、字符串类（String/StringBuffer/StringBuilder）、日期类（Date/Calendar/SimpleDateFormat）、Arrays 工具类（数组操作）、Random 类（随机数生成）。

这些类是 Java 编程的基础，掌握其核心方法和使用场景，能大幅提高开发效率。建议结合文中案例动手实践，重点关注：

  • Object 类的 equals/hashCode/toString 重写规范
  • 字符串三类的区别与选型（String 不可变、StringBuffer 线程安全、StringBuilder 效率高）
  • 日期格式化与解析的异常处理
  • 工具类的静态方法调用方式

如果本文对你有帮助，欢迎点赞、收藏、关注！如有疑问，欢迎在评论区交流～

# java # 哈希算法 # 开发语言 # intellij-idea
Logo
AI编程社区

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

码道 · 寻艺——从零构建“非遗交互式对话平台“的完整实践

avatar AI编程社区

码道：用 Python + FastAPI 快速构建一个学生信息管理接口：从零到 Swagger 在线文档

在日常开发和教学中，我们经常需要一套简单、可控、能快速上手的后端接口来演示"前后端分离"、练习 Restful API 设计，或者作为前端联调的 Mock 服务。传统做法往往是搭一套完整的 Web 工程：配置数据库、编写 DAO、引入 ORM、做请求分发……一套流程下来，光环境搭建就要花去不少时间，对于想快速验证想法、或者刚入门 API 开发的同学来说，显得过于沉重。

avatar AI编程社区

码道：从零构建学生信息管理系统 API：FastAPI 内存版 CRUD 项目全解析

FastAPI 的强大，很大程度上来自 Pydantic 的校验能力。我们写下类型声明，FastAPI 在运行时自动把它变成边界检查器。name：字符串，长度限制 1 到 50；age：整数，限制在 6 到 120 之间（ge大于等于、le小于等于）；gender：字符串，用正则限定只能是"男"“女”“其他”；email：邮箱格式字符串；grade与major：可选字段，代表班级和专业方向。

avatar AI编程社区