常用JAVA的API之一

最新推荐文章于 2024-10-17 19:56:07 发布

青的铜

最新推荐文章于 2024-10-17 19:56:07 发布

阅读量200

点赞数 3

分类专栏：技术

技术专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、Object类
Object类可以说是所有类的”上帝”,所谓上帝的含义就是造万物，Java中所有的类都直接或间接继承自Object类，那么了解Object类中的方法有助于理解Java中所有类的共性。

重点方法介绍：
<1>.boolean equals(Object obj)
Java中所有的对象都应该具备比较性，这个方法默认是通过比较对象的引用是否相同来确定对象是否相等的。
源码如下：

    public boolean equals(Object obj) {
        return (this == obj);
    }
 
 1
2
3

<2>public int hashCode()
获取对象的哈希值，Java中不同的对象有不同的哈希值，这个值类似于对象的地址值。因此可以通过哈希值是否相同来判断是否是同一个对象。

建议：自定义的类如果需要以自己的方式比较对象，则建议重写hashCode()和equals()方法

<3>public String toString()
获取对象的字符串表示形式，常用于打印对象中的成员以及成员的值，JavaAPI中大部分类都重写了此方法
Object类中toString()的源码：

public String toString() {
       return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
 
 1
2
3

二、String类
String类是Java中操作字符串的类，它提供了一系列构造字符串，操作字符串的方法，在Java程序中比较常用。
1.构造方法
<1>String() 空参构造，创建一个存储空字符的字符串对象
P.S. 空字符串对象不代表null
<2>String(byte[] bytes) 通过字节数组构造字符串
String(byte[] bytes, int off, int len) 指定字节数组的起始位置和长度
<3>String(char[] value) 通过字符数组构造字符串
String(char[] value, int off, int len) 指定字符数组的起始，和长度
<4>String(StringBuilder builder)
String(StringBuffer buffer)
通过StringBuilder,或StringBuffer对象构造字符串

2.常用方法
<1>char charAt(int index)获取指定索引的字符
<2>
boolean endsWith(String suffix)
boolean startsWith(String prefix)
是否以指定字符串结尾或开头
<3>
int indexOf(int ch)
int lastIndexOf(int ch)
获取指定字符在字符串中第一次，最后一次出现的位置索引值
<4>boolean matches(String regex)判断字符串是否与指定正则表达式匹配
String[] split(String regex)根据正则表达式分割字符串
<5>String toUpperCase()
String toLowerCase()
转换为大写，小写字符串
<6>static String valueOf(基本数据类型...)获取基本数据类型的字符串表示形式
<7>byte[] getBytes() char[] toCharArray()
将字符串转换为字节，字符数组

P.S：字符串是常量值，存储在常量池中，值一旦确定就不能更改，如果定义了一个字符串变量，则每次为变量赋值的操作，都是在常量池中新建一个字符串常量，而不是改变原有字符串。

String类的使用案例：

import java.util.Arrays;

/*
 * 练习String类的常用方法
 */
public class StringDemo {
    public static void main(String[] args) {
        //构造方法
        String str1 = new String("Hello world!");
        byte[] bytes = new byte[]{'H', 'e', 'l', 'l', 'o'};
        String str2 = new String(bytes);
        char[] chars = new char[]{'w', 'o', 'r', 'l', 'd'};
        String str3 = new String(chars);

        //判断方法
        boolean flag = str1.contains(str2);
        boolean flag2 = str1.endsWith(str3);
        boolean flag3 = str1.startsWith(str2);
        System.out.println(flag + "," + flag2 + ',' + flag3);

        //获取方法
        System.out.println("charAt(2) : " + str1.charAt(2));
        System.out.println("str1.substring : " + str1.substring(6));
        //转换方法
        System.out.println("str1-->byte[] : " + Arrays.toString(str1.getBytes()));
        System.out.println("str1-->char[] : " + Arrays.toString(str1.toCharArray()));
        //静态方法
        System.out.println("" + String.valueOf(12.4));
        System.out.println(String.valueOf(34));
        System.out.println(String.valueOf(true));
    }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

运行结果：
这里写图片描述

三、StringBuffer类
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题
StringBuffer是一个线程安全的可变字符序列，提供了更多的操作字符串的方法。
1.构造方法：
<1>StringBuffer()构造一个具有默认缓冲区的空字符串序列
<2>StringBuffer(int capacity)指定出事缓冲区大小
<3>StringBuffer(String str)通过字符串初始化

2.常用方法：
<1>添加功能：
public StringBuffer append(String str)向字符串附加内容
public StringBuffer insert(int offset,String str)在字符串中指定位置插入字符串
<2>删除功能：
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)
<3>替换功能：
public StringBuffer replace(int start,int end,String str)
<4>反转功能：
public StringBuffer reverse()
<5>截取功能
public String substring(int start) public String substring(int start,int end) 本身不发生改变

3.StringBuffer和String的相互转换
String-->StringBuffer
StringBuffer sb = new StringBuffer("hello");
StringBuffer-->String
1.String s = new String(sb);
2.String s = sb.toString();

四、数组高级及Arrays工具类
1.两种排序方式
<1>选择排序：
思路：
1、首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元素，就互换内容。
2、经过第一轮比较之后，此时，第一个元素就是数组中最小的元素。然后再拿第二个元素与除第一个元素和其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。此时，第二个元素就是数组中倒数第二小的元素。
3、依次类推，直到最后一个元素。
代码：

    public static void selectSort(int[] arr) {
        for(int x=0; x<arr.length-1; x++) {
            for(int y=x+1; y<arr.length; y++) {
                if(arr[y] < arr[x]) {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }
 
 1
2
3
4
5
6
7
8
9
10
11

<2>冒泡排序
思路：
1、首先在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
2、经过第一轮比较，最大的元素就已经存储到数组最右边的结点中了。
3、第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
4、依照此方式，一直到只有第一和第二个元素互相比较而结束。
代码：

public static void bubbleSort(int[] arr) {
    for(int x=0; x<arr.length-1; x++) {
        for(int y=0; y<arr.length-1-x; y++) {
            if(arr[y] > arr[y+1]) {
                int temp = arr[y];
                arr[y] = arr[y+1];
                arr[y+1] = temp;
            }
        }
    }
}
 
 1
2
3
4
5
6
7
8
9
10
11

2.两种查找方式
<1>遍历查找
思路：
1.遍历数组的所有元素
2.依次与要查找元素对比，找到则反回索引值
3.没找到返回-1
代码：

public static int getIndex(int[] arr,int value) {
    int index = -1;

    for(int x=0; x<arr.length; x++) {
        if(arr[x] == value) {
            index = x;
            break;
        }
    }

    return index;
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13

<2>二分法查找
思路：
1、设置三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为（max+min）/2。
2、查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
3、如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。设置max=mid-1，mid=(max+min)/2，重复第1、2步的操作。
4、如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。min=mid+1，mid=(max+min)/2，重复第1、2步的操作。
5、如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值，此时返回-1。
代码：

public static int binarySearch(int[] arr,int value) {
    int min = 0;
    int max = arr.length-1;
    int mid = (min+max)/2;

    while(arr[mid] != value) {
        if(arr[mid] > value) {
            max = mid - 1;
        }else if(arr[mid] < value) {
            min = mid + 1;
        }

        if(min > max) {
            return -1;
        }

        mid = (min+max)/2;
    }

    return mid;
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.Arrays工具类
在Arrays工具类中提供了一系列对数组进行操作的方法，包括排序，查找，以及转换为集合等常用方法。
常用方法：
数组转换字符串：
Arrays.toString(byte[] bytes)
Arrays.toString(int[] arr)
排序：
Arrays.sort(类型名[] 变量名)
查找：
Arrays.binarySearch(类型名[] 变量名, 类型名 key)

案例：把字符串中的字符进行排序

String str = "bsaefdo";
char[] chars = str.toCharArray();
Arrays.sort(chars);
str = new String(chars);
 
 1
2
3
4

结果：abdefos

五、基本数据类型包装类
为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型。
如下：

        byte        Byte
        short       Short
        int         Integer
        long        Long
        float       Float
        double      Double
        char        Character
        boolean     Boolean
 
 1
2
3
4
5
6
7
8

各个类的具体功能可以根据需要查阅API文档。

包装类的特点：自动装箱与拆箱
当把一个基本数据类型赋值给对应的包装类时，JVM对基本类型进行自动装箱，转换为对应的包装类对象
当把一个包装类对象赋值个基本类型，进行自动拆箱。
例如：

            Integer i = 100;
            i += 200;
 
 1
2

六、学习Java的思考：查阅API
API文档中包含了Java语言所提供的所有类，接口的功能介绍和使用方式，所以当某一个类不熟悉或者某个方法忘记的时候，就通过查阅API文档学习某个类的使用方法
查阅方式：
1.先看类的简介部分，了解类是干什么的
2.看构造方法部分，若没有构造方法，找返回值与类名相同的方法，知道如何获取这个类的对象
3.查看需要用到的方法，根据是否是静态方法，对应的用类名或对象去调用，完成想实现的功能，或获取对应的返回值。