简介

只记录了简单使用方法

byte

说明:字节数组构造字符串

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        byte[] bytes = {97, 98, 99};   //定义一个字节数组bytes,存入数据97,98,99
        String str = new String(bytes);   //new一个String类型的str3,存入字节数组bytes
        System.out.println("str3 = " + str);  //打印结果:str3 = abc
    }
}

char

说明:字符数组构造字符串

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:char
         * 字符数组构造字符串
         */
        char[] chars = {'a','b','v','y'};   //定义一个字符数组chars,存入数据a,b,v,y
        String str4 = new String(chars);  //new一个String类型的str3,存入字节数组bytes
        System.out.println("str4 = " + str4);   //打印结果:str4 = abvy
    }
}

equals

说明:判断str1和str2是否相等

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 判断str1和str4是否相等
         */
        String str1 = "Hello";
        String str2 = "world";

        boolean equals = str1.equals(str2);   //定义布尔型equals,判断str1和str2是否相等
        System.out.println("equals = " + equals);  //打印结果:equals = false

        //判断str1和str3是否相等
        String str3 = "Hello";  //定义一个String类型为str3,存入数据Hello
        boolean equals1 = str1.equals(str3);  //定义布尔型equals1,判断str1和str3是否相等
        System.out.println("equals1 = " + equals1);  //打印结果:equals1 = true
    }
}

equalsIgnoreCase

说明:判断当前字符串与给定字符串是否相同,不区分大小写

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:equalsIgnoreCase
         * 判断当前字符串与给定字符串是否相同,不区分大小写
         * str1 = Hello
         * str2 = Hello
         * str1和str2相同,结果应为 true
         */
        String str1 = "Hello";
        String str2 = "Hello";
        boolean b = str1.equalsIgnoreCase(str2);  //定义一个布尔型b,判断str1和str2是
        System.out.println("b = " + b);  //结果:b = true
    }
}

toUpperCase

说明:将字符串小写字符转换为大写

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:toUpperCase
         * 将字符串小写字符转换为大写
         * str1 = Hello
         * 把str1中的小写字母转换为大写字母,结果应为str6 = HELLO
         */
        String str1 = "Hello";
        String str2 = str1.toUpperCase();  //将str1中的小写字母转换为大写
        System.out.println("str1 = " + str1);  //str1此时为 str1 = Hello
        System.out.println("str6 = " + str2);  //转换大写完毕后的str6为 str6 = HELLO
    }
}

startsWith

说明:检测字符串是否以指定的前缀开始

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:startsWith
         * 检测字符串是否以指定的前缀开始
         * str1 = Hello,Java!!!
         * 判断str1中开头是否为Hello
         * Hello,Java!!!开头是Hello,所以应返回 true
         */
        String str1 = "Hello,Java!!!";  //定义String类型str1,存入字符串Hello,Java!!!
        boolean starts = str1.startsWith("Hello");  //判断str7中开头是否为Hello,返回布尔型
        System.out.println("starts = " + starts);  //结果:starts = true
    }
}

length

说明:获取字节长度

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:length
         * 获取字节长度
         * str1 = Hello,Java!!!
         * str1一共13个字符,所以应该输出13
         */
        String str1 = "Hello,Java!!!";
        int length = str1.length();  //定义整型length,检测str7占几个字节长度
        System.out.println("length = " + length);  //打印结果:length = 13
    }
}

charAt

说明:返回指定索引处的字符。索引范围为从 0 到 length()- 1

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:charAt
         * 返回指定索引处的字符。索引范围为从 0 到 length()- 1
         * str1 = Hello,Java!!!
         * 指定索引8,所以返回字符 v
         */
        String str1 = "Hello,Java!!!";
        char c = str1.charAt(8);  //定义char型c,在str7上索引8
        System.out.println("c = " + c);  //打印结果:c = v
    }
}

indexOf

说明:返回指定字符在字符串中第一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:indexOf
         * 返回指定字符在字符串中第一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1
         * str1 = Hello,Java!!!
         * 在Hello,Java!!!中寻找o出现的第一个位置
         */
        String str1 = "Hello,Java!!!";
        int indexOf = str1.indexOf("o");  //定义整型indexOf,在str1中索引o,返回第一次出现处
        System.out.println("indexOf = " + indexOf);  //打印结果:indexOf = 4
    }
}

lastIndexOf

说明:返回指定字符在此字符串中最后一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:lastIndexOf
         * 返回指定字符在此字符串中最后一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1
         * str1 = Hello,Java!!!
         * 在Hello,Java!!!中寻找a出现的最后一个位置
         */
        String str1 = "Hello,Java!!!";
        int lastIndexOf = str1.lastIndexOf("a");  //定义整型lastIndexOf,在str1中索引a,返回最后一次出现处
        System.out.println("lastIndexOf = " + lastIndexOf);  //打印结果:lastIndexOf = 9
    }
}

substring

说明:定义一个位置,打印这个位置之后的字符串

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:substring
         * 返回字符串的子字符串。
         * str1 = Hello,Java!!!
         * 1、Hello,Java!!!第7个是a,所以输出a和之后的字符串
         * 2、Hello,Java!!!第7个是a,第10个是第一个!
         */

        String str1 = "Hello,Java!!!";
        //第一种,返回字符串规定位置之后的字符串
        String substring = str1.substring(7);  //定义String类型substring,返回7及7之后的字符串
        System.out.println("substring = " + substring); //打印结果:substring = ava!!!

        //第二种,返回字符串规定位置之内的字符串
        String substring1 = str1.substring(7, 10);   //定义String类型substring1,返回7和10之内的字符串
        System.out.println("substring1 = " + substring1);  //打印结果:substring1 = ava
    }
}

getBytes

说明:使用平台的默认字符集将字符串编码为 byte 序列,并将结果存储到一个新的 byte 数组中。

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:getBytes
         * 使用平台的默认字符集将字符串编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
         * str8中a,b,c,ASCII格式转入一个新的byte数组中
         */
        byte[] bytes = {97, 98, 99};   //定义一个字节数组bytes,存入数据97,98,99
        String str8 = "abc";  //定义String类型str8,存入字符串abc
        byte[] bytes1 = str8.getBytes(); //定义一个byte数组,将str8以ASCII格式存入新的数组bytes1中
        for (int i = 0; i < bytes1.length; i++) {   //i从0开始输出第一个数据,慢慢叠加,i不会超过bytes1的字节长度
            System.out.println("bytes[" + i + "] = " + bytes[i]);   //打印结果:bytes[0] = 97 bytes[1] = 98 bytes[2] = 99
        }
    }
}

toCharArray

说明:将字符串转换为字符数组。

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:toCharArray
         * 将字符串转换为字符数组。
         * 将字符串str1存入chars1字符数组
         */
        String str1 = "Hello";  //定义String类型str1,存入字符串Hello
        char[] chars1 = str1.toCharArray();  //定义一个char数组,将str1存入新的数组chars1中
        for (int i = 0; i < chars1.length; i++) {   //i从0开始输出第一个数据,慢慢叠加,i不会超过chars1的字节长度
            System.out.println("chars1[" + i + "] = " + chars1[i]);  //打印结果:chars1[0] = H chars1[1] = e chars1[2] = l chars1[3] = l chars1[4] = o
        }
    }
}

valueOf

说明:返回给定参数的原生 Number 对象值,参数可以是原生数据类型, String等,该方法是静态方法。该方法可以接收两个参数一个是字符串,一个是基数。

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:valueOf
         * 返回给定参数的原生 Number 对象值,参数可以是原生数据类型, String等
         * 该方法是静态方法。该方法可以接收两个参数一个是字符串,一个是基数。
         */
        double d = 1999.99;  //定义一个double类型d,存入数据1999.99
        double d1 = d + 1;   //定义一个double类型d1,存入数据d+1
        System.out.println("d1 = " + d1);  //输出d1的值(1999.99+1)结果:d1 = 2000.99
        String s = String.valueOf(d);  //定义String类型s,将双浮点型d返回至String类型的s
        System.out.println("s = " + s);  //打印结果:s = 1999.99
        String s1 = s + 1;  //定义String类型s1, 此时s=1999.99,再+1是拼接
        System.out.println("s1 = " + s1);  //打印结果:s1 = 1999.991
    }
}

replace

说明:替换字符串中出现的所有自定字符,并返回替换后的新字符串。

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:replace
         * 替换字符串中出现的所有自定字符,并返回替换后的新字符串。
         * Hello,Java!!!把Java替换成Welcome,实现输出Hello,Welcome!!!
         */
        String str1 = "Hello,Java!!!";  //定义String类型str1,存入字符串Hello,Java!!!
        String replace = str1.replace("Java", "Welcome");  //再str1中寻找所有Java,替换成Welcome
        System.out.println("replace = " + replace);  //打印结果:replace = Hello,Welcome!!!
    }
}

split

说明:根据给出的特殊字符拆分字符串

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:split
         * 根据给出的特殊字符拆分字符串
         * str11中H,e,l,l,o,根据“,”拆分字符串,并存入split字符数组中输出
         */
        String str1 = "H,e,l,l,o";  //定义String类型str1,存入字符串H,e,l,l,o
        String[] split = str1.split(",");  //定义String类型数组split,用给出特殊字符“,”划分字符存入字符数组split
        for (int i = 0; i < split.length; i++) {
            System.out.println("split[" + i + "] = " + split[i]);  //打印数组中的字符 打印结果:split[0] = H split[1] = e split[2] = l split[3] = l split[4] = o
        }
    }
}

trim

说明:用于删除字符串的头尾空白符。

package com.kenvie.demo1;

public class ApiJiHe {
    public static void main(String[] args) {
        /**
         * 关键字:trim
         * 用于删除字符串的头尾空白符。
         * 结果头尾的空白符都被删除了,但字符串中间的没有被删除
         */
        String str1 = "        Hello,Jav   a!!!     ";  //定义String类型str1,头尾已经中都添加了空格
        System.out.println("str12 = " + str1);   //输出str1中的字符串
        String trim = str1.trim();  //删除str12字符串的头尾空白符,存入String类型的trin中
        System.out.println("trim = " + trim);  //打印结果:Hello,Jav   a!!!
    }
}
最后修改:2021 年 06 月 28 日
如果觉得我的文章对你有用,请随意赞赏