Java06-java常用类

一、Object

1、概述：

是java中所有的类包括自己定义的类的父类，包括数组也拥有Object类中的方法。 

2、成员方法：

①、hashCode() ：获取对象地址值的int类型的形式。

②、getClass() ：获取对象的类的字节码文件对象。

③、toString() ：获取对象的字符串表现形式。（一般来说，子类如果想要查看成员变量的情况需要重写toString()方法）

④、equals() ：equals()底层是使用==比较对象的，默认是比较地址值。（如果子类要比较成员变量的值，需要重写该方法）

⑤、finalize() ：是main方法中用作垃圾回收的方法。

⑥、clone() ：是针对对象的浅拷贝（如果该类没有实现cloneable接口就无法调用clone()方法） 

二、Scanner

1、概述:

主要用作键盘录入的。

2、成员方法：

①、next() ：用于从输入流中读取下一个单词（以空白字符作为分隔符）。

②、nextLine() ：用于读取输入流中的一整行内容，包括行尾的换行符（可以接收特殊字符）

③、hasNextXxx() ：这些方法在进行输入读取之前，可以用来判断是否可以安全地调用相应的读取方法（如next()或nextInt()），以避免出现输入不匹配导致的异常。

hasNextXxx() 方法如下 ：判断下一次输入的数据类型

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一些单词和数字：");

        while (scanner.hasNext()) {
            if (scanner.hasNextInt()) {
                int number = scanner.nextInt();
                System.out.println("读取到整数：" + number);
            } else {
                String word = scanner.next();
                System.out.println("读取到单词：" + word);
            }
        }

        scanner.close();
    }
}

三、String

1、概述：

表示一个字符串的类型

2、特点：

①、 一旦被创建就无法更改。

②、字符串具有下标索引的概念。     

3、构造方法:

①、public String() ：创建一个空的字符串对象。

②、public String(byte[] bytes) ：用给定的字节数组创建一个字符串。默认情况下，使用平台的默认字符编码将字节转换为字符。

例如：byte[] bytes = {72, 101, 108, 108, 111}; // ASCII 码对应 "Hello"，String str = new String(bytes);会创建一个内容为"Hello"的字符串。

③、public String(byte[] bytes,int offset,int length) ：从给定的字节数组中，从指定的偏移量offset开始，取length个字节来创建字符串。同样使用平台默认字符编码进行转换。

④、public String(char[] value) ：用给定的字符数组创建一个字符串。

例如：char[] chars = {'H', 'e', 'l', 'l', 'o'};，String str = new String(chars);创建一个内容为"Hello"的字符串。

⑤、public String(char[] value,int offset,int count) ：从给定的字符数组中，从指定的偏移量offset开始，取count个字符来创建字符串。

⑥、public String(String original) ：创建一个新的字符串对象，其内容与给定的原始字符串original相同。（本质上是复制了一个字符串对象）

4、成员方法：

判断功能：

①、boolean equals(Object obj) ：这个方法用于比较两个字符串的内容是否完全相同。

例如："hello".equals("hello")返回true，"hello".equals("Hello")返回false。

②、boolean equalsIgnoreCase(String str) ：与equals方法类似，但在比较时忽略大小写。

例如："hello".equalsIgnoreCase("Hello")返回true。

③、boolean contains(String str) ：用于判断一个字符串是否包含另一个指定的子字符串。

例如："Hello world".contains("world")返回true。

④、boolean startsWith(String str) ：检查一个字符串是否以指定的字符串开头。

例如："Hello world".startsWith("Hello")返回true。

⑤、boolean endsWith(String str) ：检查一个字符串是否以指定的字符串结尾。

例如："Hello world.txt".endsWith(".txt")返回true。

⑥、boolean isEmpty() ：判断一个字符串是否为空字符串，即长度为 0。

例如："".isEmpty()返回true，"hello".isEmpty()返回false。

获取功能：

①、int length() ：返回此字符串的长度。

例如："Hello".length()返回 5。

②、char charAt(int index) ：返回指定索引处的字符。

索引从 0 开始。例如："Hello".charAt(1)返回 'e'。

③、int indexOf(int ch) ：返回指定字符在字符串中第一次出现的索引。

如果字符不在字符串中，则返回 -1。例如："Hello".indexOf('l')返回 2。

④、int indexOf(String str) ：返回指定子字符串在字符串中第一次出现的索引。如果子字符串不在字符串中，则返回 -1。

例如："Hello world".indexOf("world")返回 6。

⑤、int indexOf(int ch,int fromIndex) ：从指定的索引fromIndex开始，返回指定字符在字符串中第一次出现的索引。如果字符不在字符串中或索引超出范围，则返回 -1。

例如："Hello".indexOf('l', 2)从索引 2 开始查找字符 'l'，返回 3。

⑥、int indexOf(String str,int fromIndex) ：从指定的索引fromIndex开始，返回指定子字符串在字符串中第一次出现的索引。如果子字符串不在字符串中或索引超出范围，则返回 -1。

例如："Hello world".indexOf("world", 7)从索引 7 开始查找子字符串 "world"，返回 -1。

⑦、String substring(int start) ：返回一个新的字符串，它是此字符串的子字符串，从指定索引start开始直到字符串末尾。

例如："Hello world".substring(6)返回 "world"。

⑧、String substring(int start,int end) ：返回一个新的字符串，它是此字符串的子字符串，从指定的开始索引start（包括）到结束索引end（不包括）。

例如："Hello world".substring(0, 5)返回 "Hello"。

转换功能：

①、byte[] getBytes() ：将此字符串转换为一个字节数组，使用平台的默认字符编码进行转换。

例如："Hello".getBytes()会将字符串"Hello"转换为一个字节数组，具体内容取决于平台默认编码下每个字符对应的字节值。

②、char[] toCharArray() ：将此字符串转换为一个字符数组。

例如："Hello".toCharArray()会返回一个包含字符'H'、'e'、'l'、'l'、'o'的字符数组。

③、static String valueOf(char[] chs) ：将给定的字符数组转换为字符串。

例如：char[] chars = {'H', 'e', 'l', 'l', 'o'}; String str = String.valueOf(chars);会创建一个内容为"Hello"的字符串。

④、static String valueOf(int i) ：将给定的整数转换为字符串表示。

例如：String str = String.valueOf(123);会创建一个内容为"123"的字符串。

⑤、String toLowerCase() ：返回此字符串的小写形式。

例如："Hello".toLowerCase()返回"hello"。

⑥、String toUpperCase() ：返回此字符串的大写形式。

例如："Hello".toUpperCase()返回"HELLO"。

⑦、String concat(String str) ：将指定的字符串连接到此字符串的末尾。

例如："Hello".concat(" world")返回"Hello world"。相当于使用+运算符进行字符串连接，即"Hello" + " world"。

替换功能： 

①、String replace(char old,char new) ：这个方法用于将字符串中出现的指定旧字符old替换为新字符new，并返回一个新的字符串

String str = "Hello";
String newStr = str.replace('l', 'p');
System.out.println(newStr); // Heppo

②、String replace(String old,String new) ：该方法将字符串中出现的指定旧字符串old替换为新字符串new，并返回一个新的字符串。

String str = "Hello world";
String newStr = str.replace("world", "universe");
System.out.println(newStr); // Hello universe

去除字符串两端空格：

String trim() ：用于去除字符串两端的空白字符（包括空格、制表符、换行符等），并返回一个新的字符串。

String str = "   Hello World!   ";
String trimmedStr = str.trim();
System.out.println(trimmedStr); // "Hello World!"

按字典顺寻比较两个字符串：

①、int compareTo(String str) ：

1. 功能：

   • 按字典顺序比较两个字符串。

   • 如果当前字符串在参数字符串之前，则返回一个负整数。

   • 如果两个字符串相等，则返回 0。

   • 如果当前字符串在参数字符串之后，则返回一个正整数。

2. 示例：

   • "apple".compareTo("banana")会返回一个负整数，因为"apple"在字典顺序上先于"banana"。

   • "apple".compareTo("apple")返回 0。

   • "banana".compareTo("apple")会返回一个正整数。

②、int compareToIgnoreCase(String str) ：

1. 功能：

   • 与compareTo类似，但在比较时不区分大小写。

   • 同样根据字典顺序比较两个字符串，只是不考虑字符的大小写差异。

2. 示例：

   • "Apple".compareToIgnoreCase("banana")和"apple".compareToIgnoreCase("banana")的结果是一样的，因为不区分大小写进行比较。

   • "APPLE".compareToIgnoreCase("apple")返回 0。

四、StringBuffer

1、构造方法：

①、public StringBuffer() ：创建一个空的StringBuffer对象，初始容量为 16 个字符。

②、public StringBuffer(int capacity) ：创建一个空的StringBuffer对象，并指定初始容量为capacity。这样可以在预先知道可能需要存储大量字符时避免频繁的容量扩展，提高性能。

例如：StringBuffer sb = new StringBuffer(100);创建了一个初始容量为 100 个字符的StringBuffer。

③、public StringBuffer(String str) ：创建一个StringBuffer对象，其初始内容为给定的字符串str。初始容量为字符串的长度加上 16。

例如：StringBuffer sb = new StringBuffer("Hello");创建了一个StringBuffer，内容为"Hello"。

2、成员方法：

 添加功能：

①、public StringBuffer append(String str) ：将指定的字符串str追加到当前StringBuffer对象的末尾。

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World!").append(" How are you?");
System.out.println(sb); // Hello World! How are you?

②、public StringBuffer insert(int offset,String str) ：在当前StringBuffer对象中指定的偏移量offset处插入指定的字符串str。

StringBuffer sb = new StringBuffer("Hello");
sb.insert(2, "abc");
System.out.println(sb); // Helabclo

删除功能：

①、public StringBuffer deleteCharAt(int index) ：删除指定索引位置的字符。

StringBuffer sb = new StringBuffer("Hello");
sb.deleteCharAt(2);
System.out.println(sb); // Helo

②、public StringBuffer delete(int start,int end) ：删除从指定的开始索引（包括）到结束索引（不包括）之间的字符。

StringBuffer sb = new StringBuffer("Hello World");
sb.delete(5, 10);
System.out.println(sb); // Hello d

替换功能：

public StringBuffer replace(int start,int end,String str) ：这个方法用于将当前StringBuffer对象中从指定的开始索引start（包括）到结束索引end（不包括）之间的字符序列替换为给定的字符串str。

StringBuffer sb = new StringBuffer("Hello World");
sb.replace(6, 11, "Universe");
System.out.println(sb); // Hello Universe

反转功能：

public StringBuffer reverse() ：该方法用于反转当前StringBuffer对象中的字符序列。

StringBuffer sb = new StringBuffer("Hello World");
sb.reverse();
System.out.println(sb); // dlroW olleH

截取功能：

①、public String substring(int start) ：返回一个新的字符串，它是从当前StringBuffer对象的指定索引start开始直到字符串末尾的子字符串。

StringBuffer sb = new StringBuffer("Hello World");
String subStr = sb.substring(6);
System.out.println(subStr); // World

②、public String substring(int start,int end) ：返回一个新的字符串，它是从当前StringBuffer对象的指定开始索引start（包括）到结束索引end（不包括）之间的子字符串。

StringBuffer sb = new StringBuffer("Hello World");
String subStr = sb.substring(0, 5);
System.out.println(subStr); // Hello

 五、Arrarys

1、概述：

针对数组操作提供的工具类

2、（静态）成员方法：

①、public static String toString(int[] a) ：将一个整数数组转换为字符串表示形式。

int[] arr = {1, 2, 3, 4, 5};
String str = Arrays.toString(arr);
System.out.println(str); // [1, 2, 3, 4, 5]

②、public static void sort(int[] a) ：对给定的整数数组进行排序，采用的是一种高效的排序算法（通常是快速排序的变体）。

int[] arr = {5, 2, 8, 1, 4};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 4, 5, 8]

③、public static int binarySearch(int[] a,int key) ：在已排序的整数数组中进行二分查找，以确定指定的键值key是否存在于数组中。

int[] arr = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(arr, 3);
System.out.println(index); // 2
int notFoundIndex = Arrays.binarySearch(arr, 6);
System.out.println(notFoundIndex); // -6

 六、Random

1、概述：

产生随机数

2、构造方法：

public Random() ：创建一个新的随机数生成器。它使用当前时间作为种子，使得每次创建的随机数生成器产生的随机数序列不同。

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        Random random = new Random();
        int randomNumber = random.nextInt();
        System.out.println(randomNumber);
    }
}

3、成员方法：

①、nextInt() ：生成一个随机整数。

Random random = new Random();
int randomInt = random.nextInt();
System.out.println(randomInt);

②、nextInt(int bound) ：生成一个介于 0（包括）和指定边界 bound（不包括）之间的随机整数。

Random random = new Random();
int randomIntInRange = random.nextInt(100); // 生成 0 到 99 之间的随机整数
System.out.println(randomIntInRange);

③、nextLong() ：生成一个随机长整型数。

Random random = new Random();
long randomLong = random.nextLong();
System.out.println(randomLong);

④、nextFloat() ：生成一个随机浮点数，范围在 0.0 到 1.0 之间。

Random random = new Random();
float randomFloat = random.nextFloat();
System.out.println(randomFloat);

⑤、nextDouble() ：生成一个随机双精度浮点数，范围在 0.0 到 1.0 之间。

Random random = new Random();
double randomDouble = random.nextDouble();
System.out.println(randomDouble);

⑥、nextInt(int seed) ：以给定的种子值为基础生成随机数。这些方法通常是在已有的随机数生成器对象上调用，并且会根据种子值和内部算法产生特定的随机数。

Random random = new Random();
int seed = 42;
int randomNumber = random.nextInt(seed);
System.out.println(randomNumber);

七、日期

1、Date：获取当前时间

2、SimpleDateFormat：将日期进行格式化

成员方法：

①、format(Date) -->得到一个格式化后的字符串类型

②、parse(String time) --> 根据传入的时间字符串，取出时间转成Date类型对象进行封装。