前言:
Java是一种强大而灵活的编程语言，具有广泛的应用范围，从桌面应用程序到企业级应用程序都能够使用Java进行开发。在Java的编程过程中，使用标准类库是非常重要的，因为标准类库提供了丰富的类和API，可以简化开发过程，提高开发效率。本文将介绍一些常用的Java类库及其API，希望能够帮助开发人员更好地理解和应用Java编程中的常用工具和功能
目录
String类StringBuffer类StringBuilder区别
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类型的时间戳构造出一个对象
作者建议:学习知识在于深度理解，多动手、多动脑，总能更快地领悟。不要仅仅停留在阅读代码的层面，亲自动手敲打一遍，会带来更丰富的收获。通过实践，我们能够更深入地理解知识，掌握技能，并且在解决问题时更加得心应手。相信自己的能力，坚持不懈地实践，你将会取得更大的进步和成就。让学习成为一种习惯，让动手实践成为你提升的捷径，加油！你是最棒的!
110
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
