Java--常用类APl(复习总结)

前言:

Java是一种强大而灵活的编程语言，具有广泛的应用范围，从桌面应用程序到企业级应用程序都能够使用Java进行开发。在Java的编程过程中，使用标准类库是非常重要的，因为标准类库提供了丰富的类和API，可以简化开发过程，提高开发效率。本文将介绍一些常用的Java类库及其API，希望能够帮助开发人员更好地理解和应用Java编程中的常用工具和功能

前言:

Object类

定义

toString方法

equals方法

Arrays类

equals 方法

copyof方法

fill方法

sort( )方法

binarySearch（）方法

toString( )方法

基本数据类型包装类

Integer包装类

包装类转化为基本类

自动的拆箱

基本类转为包装类型

自动装箱

String类

String的简单理解

获取功能的常用方法

转换功能

StringBuffer类

StringBuffer类概述

StringBuffer和String的区别?

添加功能

删除功能

替换功能

反转功能

截取功能

String类StringBuffer类StringBuilder区别

Math类

Random类

Date类

Object类

定义

Object类是所有Java类的祖先(根基类).每个类都使用Object 作为超类 (父类).所有对象(包括数组)都继承实现这个类的方法.

Object可以表示Java中任意的类(体现了多态性)

如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

例如: public class Person { ... }

等价于： public class Person extends Object { ... }

toString方法

Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息

当需要通过输出语句输出一个对象时,如System.out.println(person),将自动调用该对象类的 toString()方法,如果该类中没有重写toString(),那么默认调用Object类中的toString(),默认输出对象hashCode值

public class NoOverrideToString {
    private int id;
    private String name;

    public NoOverrideToString(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public static void main(String[] args) {
        NoOverrideToString obj = new NoOverrideToString(1, "Example");
        System.out.println(obj.toString());
    }
}

打印结果:NoOverrideToString@7ef20235

可以根据需要在用户自定义类型中重写toString()方法

public class OverrideToString {
    private int id;
    private String name;

    public OverrideToString(int id, String name) {
        this.id = id;
        this.name = name;
    }

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

    public static void main(String[] args) {
        OverrideToString obj = new OverrideToString(1, "Example");
        System.out.println(obj.toString());
    }
}

打印结果:OverrideToString{id=1, name='Example'}

equals方法

boolean equals（Object obj）用来判断对象是否相等,返回的是一个boolean值

Object 中的 equals 方法默认使用==比较,比较的是对象地址,这点需要注意.

class Student{
    int age;
    String name;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    //没有重写equals方法
}
public class Test {
    public static void main(String[] args) {
        //创建二个对象
        Student a1 = new Student(18, "小明");
        Student a2 = new Student(18, "小明");
        //对象比较
        System.out.println(a1.equals(a2));
    }
}

运行结果:false

JDK提供的一些类,如String,Date等,重写了Object的equals方法,调用这些类的equals方法, x.equals (y) ,当x和y所引用的对象是同一类对象且属性内容相等返回 true 否则返回 false

class Student{
    int age;
    String name;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    //重写equals方法

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Student){
            Student other =(Student) obj;
            return name.equals(other.name) && age ==other.age;
        }
        return false;
    }
}
public class Test {
    public static void main(String[] args) {
        //创建二个对象
        Student a1 = new Student(18, "小明");
        Student a2 = new Student(18, "小明");
        //对象比较
        System.out.println(a1.equals(a2));
    }
}

运行结果:true

关于 " == " :

"==" 比较等号两边是否相等

○ 当==用于基本类型比较时，比较的是变量值是否相等。
○ 当==用于引用类型比较时，比较的是对象的地址是否相等

Arrays类

equals 方法

比较两个数组对象中元素是否相等.

而数组对象中的equals用来判断与另一个数组对象是否相等

public class Null {
    public static void main(String[] args) {
       /*
        比较两个数组内容是否相等
         */
        int[] a={1,2,3,4};
        int[] b={1,2,3,4};
        System.out.println(Arrays.equals(a,b));
 
    }
}

运行结果:false

copyof方法

数组复制，将原数组内容复制到一个指定长度新数组中

    public static void main(String[] args) {
        int[] a = {1,2,3,4};
        int[] b = Arrays.copyOf(a,4);//将原数组c复制到长度为4的新数组d中
        System.out.println(Arrays.toString(b));
    }

打印结果:[1, 2, 3, 4]

fill方法

将指定的int值分配给指定的int数组的每个元素

    public static void main(String[] args) {
        int[] a = {1,2,3,4};
        Arrays.fill(a,4);
        System.out.println(Arrays.toString(a));
    }

运行结果:[4, 4, 4, 4]

sort( )方法

排序,且可通过索引局部排序

public class Null { 
public static void main(String[] args) {
        //全部排序
        int[] a = {5,4,3,2,1};
         Arrays.sort(a);
         System.out.println(Arrays.toString(a));
         //通过索引指定区间排序,tolndex索引对应的值不参与排序
         int[] b ={6,5,4,3,2,1};
        Arrays.sort(b,1,4);  //对数组b索引1~4元素排序,所有4不参与
        System.out.println(Arrays.toString(b));
    }
}

运行结果:[1, 2, 3, 4, 5] [6, 3, 4, 5, 2, 1]

binarySearch（）方法

二分查找,查找前需要先排序

public class Null {
    public static void main(String[] args) {
        int[] b ={5,4,6,8,2,1,7};
        Arrays.sort(b);  //排序后 b={1,2,4,5,6,7,8}
        int index =Arrays.binarySearch(b,6); //需要找6
        System.out.println(index);  //输出索引,排序后6对应的索引为4
    }
}

运行结果:4

toString( )方法

将数组中的元素内容拼接成一个字符串输出

public class Null {
    public static void main(String[] args) {
        int[] a={1,2,3,4};
        System.out.println(a);  //输出数组地址或首元素地址,不是数组的元素内容
        System.out.println(Arrays.toString(a));;//通过toString()输出元素内容
    }
}

打印结果:[I@14ae5a5] [1, 2, 3, 4]

基本数据类型包装类

Java中基本数据类型使用8个关键字声明的,不是面向对象的例如：int a = 10；

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进表示，这样八个和基本数据类型对应的类统称为包装类

包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法

理解:Java语言是面向对象的,可以为每一个基本类型定义一个类进行表示,这样我们在类中还是保持一个基本类型变量储存数据,同时还可以提供许多方法对基本数据变量进行操作.

Integer包装类

 //一类是静态方法
        System.out.println(Integer.toBinaryString(5));//转为二进制
        System.out.println(Integer.toHexString(17));//转为16进制
        System.out.println(Integer.toOctalString(9));//转为8进制
        System.out.println(Integer.max(10,5));//去最大数
        System.out.println(Integer.compare(8,10));//两个整数比较大小 1 0 -1
        //一类是非静态
        System.out.println(a.equals(b));//这个是Integer中的equlas的比较 
                                        //  这里Integer不可以传字母 
                                      
        System.out.println(a.compareTo(b));

        //转换的方法  包装类型 转 基本类型
         int aa  = a.intValue();
         int bb = Integer.parseInt("20");

         //把基本类型 转为包装类型
         int cc = 10;
         Integer dd = new Integer(cc);
         Integer ee = Integer.valueOf(cc);

包装类转化为基本类

自动的拆箱

int c = a.intvalue(); ==============>int c = a; //默认自动的调用intvalue这个方法。

基本类转为包装类型

自动装箱

int x = 10；

Integer y = Integer.valueof(x); =============> Integer y = x //这里默认调用的是Integer y = Integer.valueof(x);

自动装箱时，会默认自动调用valueof（）方法

在valueof（）中如果基本类型在-128——127之间,会在缓存数组中直接取一个Integer对象，减少创建次数，如果二个值相等，获取同一个对象. 如果不在这个区间，每次都创建一个新的对象.建议一般使用equals用来比较。

String类

String的简单理解

地址：java.lang.String

java中所有字符串都是此类的实例

"adb"-------> 字符串对象底层是一个char数组

字符串对象的创建

1.String s ="adb"

创建时，先去字符串池中查找有没有相同的值的对象，如果没有，就创建一个字符串对象返回地址，如果字符串常量中已经储存，不用创建新的，直接返回已经存在的对象的地址。

2.String s1 = new String("sdc");

3.字符串创建后不能被改变

注意`:String s = "abc" //这个是创建一个新的对象s赋值是abc,s+ = "fghgh" 这个是第二次创建新对象s赋值是abc + fghgh所以最后s就是abcfghgh

获取功能的常用方法

int length( ) 获取字符串长度
char charAt( ) 获取指定位置上的字符
int indexOf( ) 获取字符首次出现的位置,也可以从指定位置开始查找
lastIndexOf( ) 从后往前找
String substring( ) 从指定位置开始截取一个字符串副本

String str = "Hello, World!";
int len = str.length(); // 获取字符串长度
char ch = str.charAt(7); // 获取索引位置为7的字符
int index = str.indexOf("o"); // 查找字符'o'第一次出现的位置
int lastIndex = str.lastIndexOf("o"); // 从后往前查找字符'o'出现的位置
String sub = str.substring(1, 5); // 从索引1开始截取到索引5的子字符串

System.out.println("Length: " + len);
System.out.println("Character at index 7: " + ch);
System.out.println("Index of 'o': " + index);
System.out.println("Last index of 'o': " + lastIndex);
System.out.println("Substring from index 1 to 5: " + sub);

打印结果:

Length: 13
Character at index 7: W
Index of 'o': 4
Last index of 'o': 8
Substring from index 1 to 5: ello

转换功能

byte[] getBytes()

这个方法返回字符串的字节数组表示形式。它将字符串转换为字节数组，使用的编码取决于平台的默认字符集。

char[] toCharArray()

返回一个字符数组，包含了字符串中的所有字符。每个字符在数组中的位置对应字符串中的相同位置。

static String valueOf(char[] chs)

这是一个静态方法，接受一个字符数组 chs 并返回一个新的字符串，包含 chs 中的字符内容。

String toLowerCase()

返回一个新字符串，其中所有的字符都被转换为小写形式。

String toUpperCase()

返回一个新字符串，其中所有的字符都被转换为大写形式。

String concat(String str)

将指定的字符串 str 连接到调用字符串的末尾，并返回一个新的字符串。相当于使用 + 运算符进行字符串拼接。

String[] split(String regex)

根据给定的正则表达式 regex 将字符串拆分为子字符串数组。返回的数组包含了根据分隔符 regex 分割的多个子字符串。

replace(char old, char new)

这个方法用于将字符串中的指定字符old替换为新字符new

replace(String old, String new)

这个方法用于将字符串中的指定子字符串old替换为新的子字符串new

replaceAll(String regex, String replacement)

这个方法用于根据正则表达式regex，替换字符串中匹配正则表达式的部分为指定的replacement字符串

replaceFirst(String regex, String replacement)

这个方法与replaceAll类似，不同的是它只替换匹配正则表达式regex的第一个部分

String trim( )

去除字符串两端空格（字符串中间的空格不能去除

StringBuffer类

StringBuffer类概述

我们如果对字符串进行拼接操作,每次拼接,都会构建一个新的String 对象,既耗时,又浪费空间。而StringBuffer就可以解决这个问题线程安全的可变字符序列

StringBuffer和String的区别?

String可以直接创建字符串对象，而StringBuffer不能,需要新创建一个字符串对象

          String s1 = "abc";
          StringBuffer s2 = new StringBuffer("abc");

String:

String 类是不可变的（immutable）。这意味着一旦一个 String 对象被创建，它的内容不能被更改。任何看似修改 String 内容的操作实际上是创建了一个新的 String 对象

StringBuffer:

StringBuffer 是可变的（mutable）。它允许修改其内容，而不创建新的对象。

添加功能

public StringBuffer append(String str)

该方法用于将指定的字符串 str 添加到当前 StringBuffer 对象的末尾。
返回的是修改后的 StringBuffer 对象本身

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World");
// 现在 sb 包含 "Hello World"

public StringBuffer insert(int offset,String str)

该方法将指定的字符串 str 插入到当前 StringBuffer 对象中的指定 offset 位置处。
返回的是修改后的 StringBuffer 对象本身

StringBuffer sb = new StringBuffer("Hello");
sb.insert(5, " World");
// 现在 sb 包含 "Hello World"

删除功能

public StringBuffer deleteCharAt(int index)

该方法用于删除当前 StringBuffer 对象中指定 index 处的字符。
返回的是修改后的 StringBuffer 对象本身

StringBuffer sb = new StringBuffer("Hello World");
sb.deleteCharAt(5);
// 现在 sb 包含 "HelloWorld"，即删除了第 5 个位置上的空格

public StringBuffer delete(int start, int end)

该方法用于删除当前 StringBuffer 对象中从 start 到 end-1 范围内的子字符串。
返回的是修改后的 StringBuffer 对象本身

StringBuffer sb = new StringBuffer("Hello World");
sb.delete(5, 11);
// 现在 sb 包含 "Hello"，即删除了从第 5 个位置（包括）到第 11 个位置（不包括）之间的字符

替换功能

public StringBuffer replace(int start, int end, String str)

该方法用于将当前 StringBuffer 对象中从 start 到 end-1 范围内的子字符串用指定的字符串 str 替换
返回的是修改后的 StringBuffer 对象本身

StringBuffer sb = new StringBuffer("Hello World");
sb.replace(6, 11, "Java");
// 现在 sb 包含 "Hello Java"，即将从第 6 个位置（包括）到第 11 个位置（不包括）之间的子字符串替换为 "Java"

反转功能

public StringBuffer reverse()

该方法用于反转当前 StringBuffer 对象中的字符序列
返回的是修改后的 StringBuffer 对象本身

StringBuffer sb = new StringBuffer("Hello");
sb.reverse();
// 现在 sb 包含 "olleH"，即原字符串的字符顺序被反转了

截取功能

public String substring(int start)

该方法用于从当前 StringBuffer 对象中提取从 start 位置到末尾的子字符串
返回的是一个新的 String 对象，包含从 start 位置到末尾的字符序列

StringBuffer sb = new StringBuffer("Hello World");
String sub1 = sb.substring(6);
// sub1 现在包含 "World"，即从第 6 个位置（包括）开始直到末尾的子字符串

public String substring(int start, int end)

该方法用于从当前 StringBuffer 对象中提取从 start 到 end-1 的子字符串
返回的是一个新的 String 对象，包含从 start 到 end-1 的字符序列

StringBuffer sb = new StringBuffer("Hello World");
String sub2 = sb.substring(6, 11);
// sub2 现在包含 "World"，即从第 6 个位置（包括）到第 11 个位置（不包括）之间的子字符串

截取功能和前面几个功能的不同

返回值类型是String类型，本身没有发生改变

StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程安全的

String类StringBuffer类StringBuilder区别

可变性：

String：是不可变类，一旦创建，内容不可更改。每次对 String 类型的操作（如拼接、替换等）都会创建一个新的 String 对象。
StringBuffer：是可变类，线程安全（即是同步的）。它支持在字符串中进行添加、插入、删除和替换字符或子串的操作，而不会创建新的对象。
StringBuilder：也是可变类，但不是线程安全的。它和 StringBuffer 的 API 是相同的，但没有实现同步，因此在单线程环境下性能更好。

线程安全性：

String：不涉及线程安全问题，因为不可变性保证了在多线程环境下不会发生竞态条件。
StringBuffer：是线程安全的，因为它的关键操作使用了synchronized关键字进行同步，可以安全地在多线程环境下使用。
StringBuilder：不是线程安全的，因此在单线程环境下性能比 StringBuffer 更好，但在多线程环境下需要手动处理同步问题。

性能：

操作少量数据时，String 的性能通常比较好，因为不涉及额外的内存分配和复制操作。
操作大量数据或需要频繁修改字符串时，StringBuffer 和 StringBuilder 的性能会更好，因为它们支持可变操作而不需要创建新对象。

Math类

其方法的参数和返回值类型一般为double型

abs(double a)

功能：返回参数 a 的绝对值。
示例：
double x = -10.5;
double absX = Math.abs(x); // absX 的值为 10.5
sqrt(double a)

功能：返回参数 a 的平方根。
示例：
double y = 25.0;
double sqrtY = Math.sqrt(y); // sqrtY 的值为 5.0
pow(double a, double b)

功能：返回 a 的 b 次幂。
示例
double base = 2.0;
double exponent = 3.0;
double result = Math.pow(base, exponent); // result 的值为 8.0 (2的3次方)
max(double a, double b)

功能：返回 a 和 b 中的较大值。
示例：
double m = 10.5;
double n = 8.0;
double maxVal = Math.max(m, n); // maxVal 的值为 10.5
min(double a, double b)

功能：返回 a 和 b 中的较小值。
示例
double p = -3.0;
double q = 0.5;
double minVal = Math.min(p, q); // minVal 的值为 -3.0
random()

功能：返回一个大于等于 0.0 且小于 1.0 的随机 double 类型的数。
示例
double rand = Math.random(); // rand 的值为 0.0 到 1.0 之间的随机数
long round(double a)

功能：将 double 类型的参数 a 四舍五入为 long 类型。
示例：
double num = 10.6;
long roundedNum = Math.round(num); // roundedNum 的值为 11

Random类

首先要创建Random对象 //Random random = new Random（）；

random.nextBoolean=====> 随机返回一个布尔值

random. nextInt() //随机返回一个int类型的数

random. nextInt(int n) // 随机返回一个超过n的int数

import java.util.Random;

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

        // 生成随机布尔值
        boolean randomBoolean = random.nextBoolean();
        System.out.println("Random Boolean: " + randomBoolean);

        // 生成随机整数
        int randomInt = random.nextInt();
        System.out.println("Random Integer: " + randomInt);

        // 生成指定范围内的随机整数
        int n = 100; // 指定范围
        int randomIntInRange = random.nextInt(n);
        System.out.println("Random Integer within range [0, " + n + "): " + randomIntInRange);
    }
}

运行结果

Random Boolean: true
Random Integer: 123456789
Random Integer within range [0, 100): 42

Date类

使用Date类代表当前系统时间

Date d = new Date();

Date d = new Date(long d);

d.getTime() 获取1970.1.1 0.0.0 至程序运行时刻的毫秒值

lomg d是一个时间戳将指定的long类型的时间戳构造出一个对象

作者建议:学习知识在于深度理解，多动手、多动脑，总能更快地领悟。不要仅仅停留在阅读代码的层面，亲自动手敲打一遍，会带来更丰富的收获。通过实践，我们能够更深入地理解知识，掌握技能，并且在解决问题时更加得心应手。相信自己的能力，坚持不懈地实践，你将会取得更大的进步和成就。让学习成为一种习惯，让动手实践成为你提升的捷径，加油！你是最棒的!