Java 常用API

Mr. Rabbit.

已于 2022-07-12 23:12:14 修改

阅读量717

点赞数 2

文章标签： java 开发语言算法

于 2022-07-12 23:11:38 首次发布

本文链接：https://blog.csdn.net/weixin_52340450/article/details/125754151

版权

API 常用类

Java API概述：

就是应用程序编程接口是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供
给开发人员进行使用帮助说明。

1.基本数据类型包装类

Java是一个面向对象的语言，但是其中的八种基本数据类型却并非是面向对象的，故而在使用时有诸多不便，所以提出了基本数据类型包装类。
包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法。

2.Object类

是所有类的基类

tostring方法 Object类中定义有public String toString()方法，其返回值是 String类型，描述当前对象的有关信息。并且在使用”sout“输出时，用”+“连接的内容也默认调用了Object类中的tostring方法。也可以自定义类中重写tostring方法，使其多样化，规范化。
equals方法定义了判断两个对象是否相等的逻辑返回值时bool类型（在object类中equals方法只对进行判断的两个对象是否是同一个引用进行判断）而在其它类中equals可以对引用的内容进行判断。

Arrays类

用于操作数组工具类，里面定义了常见操作数组的静态方法。

equals 方法

比较两个非同一数组是否相等，而数组本身的equals判断另一个数
组是否它本身

sort排序

可对数字中所有或是指定长度进行排序（默认时升序）。
自定义对象排序自定义类实现Comparable接口重写compareTo方法

binarySearch -使用二分搜索算法搜索指定数组（binarySearch(type[] a, type key)）

如果key在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)

tostring类

String类

1.概念：

由多个字符组成的一串数据，值一旦创建就不改变，一旦改变就会创建一个新的对象；

2.String对象的创建方法

● 第一种:

String s = “abc”;

先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找

有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中

的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建.

● 第二种:

一概在堆中创建新对象，值存储在堆内存的对象中。

String s = new String(“abc”);

3.String所提供的各种方法

1.获取方法

package stringDemo2;

public class gain {
    public static void main(String[] args) {
        String str = "abcdefg";
        System.out.println(str.length());//返回字符串长度(return value.length;)
        System.out.println(str.charAt(1));//输入index索引返回该索引位置的字符（char）；
        System.out.println(str.indexOf("c"));//返回该字符的索引，(从前往后找，只返回首次找到的字符索引)；
        System.out.println(str.indexOf("c", 4));//返回该字符的索引，（从指定位置往后找，只返回首次找到的字符索引）；
        System.out.println(str.lastIndexOf("c"));//从后往前找，同上；
    }
}

输出
```
7
b
2
-1
2
```

2.截取方法

package stringDemo2;

public class cut out {
    public static void main(String[] args) {
        String str="abcdefg";
        System.out.println(str.substring(3));//返回该索引往后的字串
        System.out.println(str.substring(2,6));//返回从start到end的字符（start包含end不包含）；
    }

}

输出
```
defg
cdef
```

3.转换方法

package stringDemo2;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class zhuanhuan {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str="中国";
        byte b[]=str.getBytes("gbk");//将字符串转化为指定编码，并将字符串储存于字节数组（注：解码的编码要与译码时相同）
        System.out.println(Arrays.toString(b));
        String s=new String(b,"gbk");//解码过程
        System.out.println(s);
        String s1="abcd";
        char[] chars=s1.toCharArray();//将字符串转化为字符并储存在字符数组中；
        System.out.println(Arrays.toString(chars));//以字符数组形式输出；
        String s2=new String(chars);//还原
        String s3=String.valueOf(chars);//还原
        System.out.println(s2);
        System.out.println(s3);
    }
}

输出

[-42, -48, -71, -6]
中国
[a, b, c, d]
abcd
abcd

4.判断方法

package stringDemo2;

public class  judge{
    public static void main(String[] args) {
        String str1="abcdefg";
        String str2="abcdefg";
        String str3="AbcdefG";
        String str="abc";
        String s= "";
//        String s1=null;
        System.out.println(str1.equals(str2));//比较字符串内容是否相同(返回类型：boolean)；
        System.out.println(str1.equalsIgnoreCase(str3));//比较字符串内容是否相同(不区分大小写)(返回类型：boolean)；
        System.out.println(str1.contains(str));//是否包含子串（连续）(返回类型：boolean)；
        System.out.println(s.isEmpty());//判断字符串是否为空串(返回类型：boolean)；NULL并非空串；
        System.out.println(str1.startsWith("abc"));//判断字符串是否以该字串开头；(返回类型：boolean)
        System.out.println(str1.endsWith("efg"));//判断字符串是否以该字串结尾；(返回类型：boolean)
        System.out.println(str1.compareTo(str3));//比较两字符串大小；
        // （若长度相同则返回不同值的asc值之差）（字符串长度不同则返回length之差）；(返回类型：int);
    }
}

输出
```
true
true
true
true
true
true
32
```

5.替换方法

package stringDemo2;

public class tihuan {
    public static void main(String[] args) {
        String str=" abcde1a3f5g ";
        String str1=str.replace("a","A");//替换连续子串；
        System.out.println(str1);
        String str2=str.replaceAll("\\d","A");//正则”模式匹配“替换
        System.out.println(str2);
        String str3=str.replaceFirst("\\d","A");//正则”模式匹配“替换第一次出现的regex；
        System.out.println(str3);
        String str4=str.trim();//去除字符串两端” “空格；
        System.out.println(str.length());
        System.out.println(str4.length());
    }
}

输出

Abcde1A3f5g 
abcdeAaAfAg 
abcdeAa3f5g 
13
11

4.StringBuffer类与StringBuilder类

1.为什么我们会在string类的基础上引入StringBuffer类与StringBuilder类？

字符串广泛应用在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串需要注意是，String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间，而StringBuffer与StringBuilder就可以解决这个问题。

2.StringBuffer类与StringBuilder类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

详解StringBuffer

因为StringBuffer类与StringBuilder类之间只有在多线程时会有区别，故而只对StringBuffer做以下详解：

1.StringBuffer

在API中是这样解释StringBuffer的：

线程安全，可变的字符序列。字符串缓冲区就像一个string但可以修改。在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。

也就是说StringBuffer会提供一个字符缓冲区(默认大小为长度为16的字符数组)，每当写入的内容超过16时会自动增加容量；

2.StringBuffer中的方法

构造方法

public StringBuffer()

构造一个没有字符的字符串缓冲区，初始容量为16个字符。

public StringBuffer(String str)

构造一个没有字符的字符串缓冲区和指定的初始容量。

● 添加功能

public StringBuffer append(String str)

将1字符串表示附加到序列中。

public StringBuffer insert(int offset,String str)

将字符串插入到此字符序列中(指定位置)。

● 删除功能

public StringBuffer deleteCharAt(int index)

删除该索引的字符；

public StringBuffer delete(int start,int end)

删除此序列的子字符串中的字符

● 替换功能

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

将指定区间替换为指定字符串；(不同于string的操作，stringbuffer是在原数组中操作)；

● 反转功能

public StringBuffer reverse()

反转字符串

● 截取功能

public String substring(int start)

截取指定区间

public String substring(int start,int end)

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

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

3.代码实现

public class StringBufferDemo {
    public static void main(String[] args) {
//        new StringBuffer();//无参，底层char数组长度默认为16；
//        new StringBuffer(30);//int 参数 底层数组长度默认为指定长度30；
        StringBuffer stringBuffer = new StringBuffer("abcd");//此时地址StringBuffer@491
        stringBuffer.append("efg");//此时value char数组地址为@496”未超出初始长度’str.length+16‘“
        stringBuffer.append("asdafdaf");//仍未超出
        stringBuffer.append("zxcvasdfasdfg");//此时超出’str.length+16‘value char地址改变，但stringbuffer对象地址不改变；
        System.out.println(stringBuffer);//
        StringBuffer sb = new StringBuffer();
        sb.append("abc");//向字符串末尾追加字符串；不改变原字符串地址；
        System.out.println(sb);
        sb.insert(2,"acs");//向指定位置插入字符串；
        System.out.println(sb);
        sb.delete(1,2);//删除指定区间的字符串；
        System.out.println(sb);
        sb.deleteCharAt(2);//删除该索引的字符；
        System.out.println(sb);
        sb.replace(2,3,"ac");//将指定区间替换为指定字符串；(不同于string的操作，stringbuffer是在原数组中操作)；
        System.out.println(sb);
        sb.reverse();//反转数组；
        System.out.println(sb);
        String str=sb.substring(2);//返回的是string值；
        System.out.println(sb);

    }
}

4.运行结果

abcdefgasdafdafzxcvasdfasdfg
abc
abacsc
aacsc
aasc
aaacc
ccaaa
ccaaa

总结

1.区别

String是一个不可变的字符序列
StringBuffer是可变的字符序列

2.优缺点：

String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空间。String的操作都是改变赋值地址而不是改变值操作。
StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。

3.适用范围

● String：是字符常量,适用于少量的字符串操作的情况

● StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

● StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况、

5.Math&Random&System类

System类

System 类包含一些有用的类字段和方法。它不能被实例化。

Math类

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

Random类

此类用于产生随机数

package systemDemo;

import java.util.Arrays;
import java.util.Random;

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.max(10,1));
        System.out.println(Math.min(10,1));
        System.out.println(Math.pow(10,2));
        System.out.println(Math.sqrt(9));
        System.out.println(Math.random());//0-1之间的随机数
        System.out.println(Math.abs(-1));
        System.out.println(Math.floor(10.9));//向下取整
        System.out.println(Math.ceil(10.1));//向上取整
        System.out.println(Math.round(10.4));//四舍五入
        Random random = new Random();
        System.out.println(random.nextBoolean());//true/false随机；
        System.out.println(random.nextInt());//在int中返回随机值
        System.out.println(random.nextInt(100));//在100中返回随机值不包含100
        byte[] bytes = new byte[5];
        random.nextBytes(bytes);
        System.out.println(Arrays.toString(bytes));//生成n个Byte类型的随机值；
        //System类
        long s=System.currentTimeMillis();//1970.1.1到程序运行的时间差；
        System.out.println(s);
        int[]a={1,2,3,5,6};
        int[] ints = new int[10];
        System.arraycopy(a,0,ints,2,3);//src原数组，srcPos原数组开始copy的索引，dest新数组，
        // destPos将原数组在新数组中开始copy的索引，length要从原数组中copy的长度
        System.out.println(Arrays.toString(ints));
        System.exit(0);//退出JVM；
        System.gc();//垃圾回收；


    }
}

运行结果

3.141592653589793
10
1
100.0
3.0
0.8425993335676571
1
10.0
11.0
10
false
247880112
25
[-89, -60, 68, 116, 117]
1638459490798
[0, 0, 1, 2, 3, 0, 0, 0, 0, 0]