Java - 常用api的使用方法

kenvie

发布于 2022-01-20 15:11:55

4170

发布于 2022-01-20 15:11:55

文章被收录于专栏：kenviekenvie

简介

只记录了简单使用方法

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!!!
    }
}

版权属于：kenvie

本文链接：https://cloud.tencent.com/developer/article/1937601

商业转载请联系作者获得授权，非商业转载请注明出处。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2021 年 05 月，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

编程算法

登录后参与评论

0 条评论

热度