Spring类API_spring api-优快云博客

本文链接：https://blog.youkuaiyun.com/XiaoLinguiwei/article/details/130378179

API是应用程序编程接口，简化了程序员与操作系统或库之间的交互。例如，C语言的fopen()用于文件操作，而在Java中，String类提供了多种方法如length(),trim(),toUpperCase()等，方便对字符串进行处理。API使得复杂的底层操作变得简单易用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

`API`(工具)

从文件操作开始谈API。

以C语言为例，我们使用fopen()函数可以打开一个文件，感觉非常简单。文件保存在硬盘上，要经过复杂的处理才能显示，这些细节对我们来说是透明的，由操作系统完成。也就是说，我们调用fopen()函数来通知操作系统，让操作系统打开一个文件。

那么，我们如何告诉操作系统打开文件呢？

看似简单的操作到底层都非常复杂，打开文件首先要扫描硬盘，找到文件的位置，然后从文件中读取一部分数据，将数据放进I/O缓冲区，放进内存；这些数据都是0、1序列，还要对照ASCII表或Unicode表”翻译“成字符，再在显示器上显示出来。这个过程如果要让程序员来完成，那简直是噩梦！

怎么办呢？操作系统想了一个很好的办法，它预先把这些复杂的操作写在一个函数里面，编译成一个组件（一般是动态链接库），随操作系统一起发布，并配上说明文档，程序员只需要简单地调用这些函数就可以完成复杂的工作，让编程变得简单有趣。这些封装好的函数，就叫做API(Application Programming Interface)，即应用程序编程接口。

说得更加通俗易懂一些，别人写好的代码，或者编译好的程序，提供给你使用，就叫做API。你使用了别人代码（或者程序）中的某个函数、类、对象，就叫做使用了某个API。

1.`String`类中常用的方法

英文	翻译
`data`	数据
`Charset`	字符集
`Standard Charsets`	标准字符集
`length`	长度
`trim`	修剪
`to Upper Case`	大写
`toLowerCase`	小写
`char At`	字符在
`last`	最后的
`substring`	子字符串

构造方法

String(byte[] data,Charset charset)

作用:将一个字节数组还原为字符串

将给定的字节数组data中所有字节按照给定的字符集转换为字符串。

byte[] nums={'d','f','t','r','q','o'};
String numd= new String(nums, StandardCharsets.UTF_8);
System.out.println(numd);//dftrqo

String(byte[] data,int offset,int len,Charset charset)

作用:将给定的字节数组data从下标offset处开始的连续len个字节按照指定的字符集转换为字符串

字符集:StandardCharsets.UTF_8 [参数charset一般都是StandardCharsets.UTF_8]

String ji=new String(nums,2,3,StandardCharsets.UTF_8);
System.out.println(ji);//trq

`length`()

English—长度
作用:获取字符串的长度(字符个数)

没有参数,返回值是int类型

String str = "我爱Java!";
int len = str.length(); //获取str的长度
System.out.println(len); //7

如果File表示一个具体文件，则length方法返回这个文件的字节大小
如果File表示一个目录，则length方法的返回值不确定
如果File表示的目录或文件不存在，则length方法的返回值为0L。

`trim`()

English—修剪
作用:去除当前字符串两边的空白字符,中间的空白字符则不会去除

没有参数,返回值是String类型

String str = "    hello world       ";
System.out.println(str); //    hello world
str = str.trim(); //去除str两边的空白字符，并将去除之后的新的对象存储到str中
System.out.println(str); //hello world

`toUpperCase()/toLowerCase()`

English—要大写/要小写
作用:将当前字符串中的英文部分给转换为全大写/全小写;

没有参数,返回值是String类型

String str = "我爱Java!";
String upper = str.toUpperCase(); //将str中的英文部分转换为全大写，并存入upper中
System.out.println(upper); //我爱JAVA!

String lower = str.toLowerCase(); //将str中的英文部分转换为全小写，并存入lower中
System.out.println(lower); //我爱java!

`charAt`()

English—字符
作用:返回当前字符串指定位置上的字符----根据位置找字符;
参数就是int类型,也就是字符串的下标.返回值是char类型,也就是字符型,八大基本类型.

如果返回值用int接收的话,接收回来的就是该字符对应的Unicode字符编码

//                      111111----和下面的连成10/11/12/13/14/15
//            0123456789012345
String str = "thinking in java";
char c = str.charAt(9); //获取str中下标9所对应的字符
System.out.println(c); //i

`indexOf()/lastIndexOf()`

English—指数/最后一个指数;在java里,index是下标的意思
作用:检索给定字符串在当前字符串中第一次/最后一次出现的位置，根据字符串找位置

参数就是String类型,返回值是int类型

//                      111111
//            0123456789012345
String str = "thinking in java";
int index = str.indexOf("in"); //检索in在str中第1次出现的位置
System.out.println(index); //2
//从下标为3的位置开始找in第1次出现的位置
index = str.indexOf("in",3);
System.out.println(index); //5
index = str.indexOf("abc"); //若字符串在str中不存在，则返回-1
System.out.println(index); //-1

index = str.lastIndexOf("in"); //找in最后一次出现的位置
System.out.println(index); //9

`substring`()

English—子字符串
作用:截取当前字符串中指定范围内的字符串(含头不含尾–包含start，但不包含end)

2个参数,是int类型,返回值也是String类型

//                      1
//            01234567890
String str = "www.tedu.cn";
int start = str.indexOf(".")+1; //4，获取第1个点之后的下标
int end = str.lastIndexOf("."); //8，获取最后一个点的下标
String name = str.substring(start,end); //截取下标4到下标7之内的字符串
System.out.println(name); //tedu

name = str.substring(4); //从下标4一直到最后
System.out.println(name); //tedu.cn

`char[] toCharArray()`

作用:将字符串转化为char数组,由字符串引用调用该方法

没有参数

String str="成本算不发芽诶cdrtyd";
char[] c=str.toCharArray()

静态方法`valueOf()`

valueOf “…的等价” ,value"等价"
将其它数据类型转换为String

由于是静态方法,所以只能由String类名点出,返回值也是String类型

int a = 123;
String s1 = String.valueOf(a); //将int型变量a转换为String类型并赋值给s1
System.out.println(s1); //123---字符串类型

double b = 123.456;
String s2 = String.valueOf(b); //将double型变量b转换为String类型并赋值给s2
System.out.println(s2); //123.456---字符串类型

String s3 = b+""; //任何类型与字符串相连，结果都变为字符串类型，效率低(一会儿讲)
System.out.println(s3); //123.456---字符串类型

`String`支持与正则表达式相关的方法

正则表达式是以String类型的字符串形势出现的

`matches`()副

English—匹配（match 的第三人称单数形式）；匹敌,匹配的意思
作用:使用给定的正则表达式(regex)验证当前字符串的格式是否符合要求，若符合则返回true，否则返回false
1个参数,是由==要进行验证的字符串点出matches()方法,==参数就是正则表达式

演示

邮箱正则表达式:[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-zA-Z]+)+
注意:\.中的这个\是正则表达式中的转义符
\\.中的第1个\，是在转义正则表达式中的\

public class MatchesDemo {
    public static void main(String[] args) {
        String email = "wangkj@tedu.cn";
        String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
        //使用regex匹配email是否符合格式要求
        boolean match = email.matches(regex);
        if(match){
            System.out.println("是正确的邮箱格式");
        }else{
            System.out.println("不是正确的邮箱格式");
        }
    }
}

`replaceAll`()副

English—替换所有
作用:将当前字符串中满足正则表达式(regex)的部分给替换为给定的字符串(s)

2个参数,都是String类型的字符串,第一个参数就是要替换的条件,第二个就是要替换的内容,返回值是String类型

public class ReplaceAllDemo {
    public static void main(String[] args) {
        String line = "abc123def456ghi78";
        line = line.replaceAll("[0-9]+","#NUMBER#");
        System.out.println(line);
    }
}

`split()`副

English—分裂
作用:将当前字符串按照满足正则表达式(regex)的部分进行拆分，将拆分出的以String[]形式来返回

有1个参数.参数是正则表达式,就是要进行拆分的条件.

既然是把字符串进行拆分,那么字符串就会变为数组,但是在输出的时候就会使用toString()方法转化为字符串进行输出.

public class SplitDemo {
    public static void main(String[] args) {
        String line = "abc123def456ghi";
        String[] data = line.split("[0-9]+"); //按数字拆分(数字就拆没了)
        System.out.println(Arrays.toString(data)); //将data数组转换为字符串并输出
        line = "123.456.78";
        data = line.split("\\."); //按.拆(.就拆没了)
        System.out.println(Arrays.toString(data));

        //最开始就是可拆分项(.)，那么数组第1个元素为空字符串------------""
        //如果连续两个(两个以上)可拆分项，那么中间也会拆出一个空字符串----""
        //如果末尾连续多个可拆分项目，那么拆出的空字符串被忽略
        line = ".123.456..78........";
        data = line.split("\\."); //按.拆(.就拆没了)
        System.out.println(Arrays.toString(data));
    }
}

重载方法

public class SplitDemo {
    public static void main(String[] args) {
        String line="1=2=3=4=5=6===";

        //忽略后面所有拆分出来的空字符串
        String[] data=line.split("=");
        System.out.println(Arrays.toString(data));

        //表达仅拆分出2项.
        data=line.split("=",2);
        System.out.println(Arrays.toString(data));

        //表达仅拆分出3项
        data=line.split("=",3);
        System.out.println(Arrays.toString(data));

        //当limit的值大于可拆分项时,仅保留所有可拆分项
        data=line.split("=",100);
        System.out.println(Arrays.toString(data));

        //如果limit=0,那么效果与一个参数的split一致
        data=line.split("=",0);
        System.out.println(Arrays.toString(data));

        //如果limit小于0,则为应拆尽拆,经所有可拆分出的内容全部保留
        data=line.split("=",-1);
        System.out.println(Arrays.toString(data));
    }
}

结果

        [1, 2, 3, 4, 5, 6]
        [1, 2=3=4=5=6===]
        [1, 2, 3=4=5=6===]
        [1, 2, 3, 4, 5, 6, , , ]
        [1, 2, 3, 4, 5, 6]
        [1, 2, 3, 4, 5, 6, , , ]

		小于0和100的那个不是一样的,不严谨