java8 String类常用方法讲解和实例

最新推荐文章于 2024-05-28 00:21:46 发布

厚积博发

最新推荐文章于 2024-05-28 00:21:46 发布

阅读量776

点赞数

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/meichangshu/article/details/103741376

版权

java基础专栏收录该内容

30 篇文章 2 订阅

订阅专栏

构造方法（Constructor and Description）

String()创建

初始化新创建的 String对象，使其表示空字符序列。

//        eg
        String string = new String();
        String string1;
        String string3 = "this is a str";
        System.out.println(string);
//        System.out.println(string1);//没有被初始化会报错。
        System.out.println(string3);

byte[]相关

大同小异，这类就是将一个字节数组转换为字符串，基本都是用下面的方式构成。

byte[] bytes = {'h', 'e', 'l', 'l', 'o',' ', 'w', 'o', 'r', 'l', 'd'};
String str = new String(bytes);
System.out.println(str);
/**
byte[] bytes = {122,122};
System.out.println(new String(bytes));

byte[] bytes = {'h', 'e', 'l', 'l', 'o',' ', 'w', 'o', 'r', 'l', 'd'};        String un_iso=new String(bytes, "ISO8859-1");
        String un_gbk=new String(bytes, "GBK");
        String un_utf8=new String(bytes, "utf-8");
*/

String(byte[] bytes)

通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。

String(byte[] bytes, Charset charset)

构造一个新的String由指定用指定的字节的数组解码charset 。
String(byte[] bytes, int offset, int length)
通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String 。
String(byte[] bytes, int offset, int length, Charset charset)
构造一个新的String通过使用指定的指定字节子阵列解码charset 。
String(byte[] bytes, int offset, int length, String charsetName)
构造一个新的 String通过使用指定的字符集解码指定的字节子阵列。
String(byte[] bytes, String charsetName)
构造一个新的String由指定用指定的字节的数组解码charset 。

char[]相关

char[] chars = {'h', 'e', 'l', 'l', 'o',' ', 'w', 'o', 'r', 'l', 'd'};
String str = new String(chars);
System.out.println(str);

String(char[] value)
分配一个新的 String ，以便它表示当前包含在字符数组参数中的字符序列。
String(char[] value, int offset, int count)
分配一个新的 String ，其中包含字符数组参数的子阵列中的字符。

String(int[] codePoints, int offset, int count)
int[] ints = {20320, 38750, 24120, 26834, 65281};
String str = new String(ints, 0, 5);
System.out.println(str);

分配一个新的 String ，其中包含 Unicode code point数组参数的子阵列中的字符。

其他

1.String(String original)
初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。
2.String(StringBuffer buffer)
分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。
3.String(StringBuilder builder)
分配一个新的字符串，其中包含当前包含在字符串构建器参数中的字符序列。

public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("你好");
        StringBuilder stringBuilder = new StringBuilder();
        stringBuffer.append("我好");
        String str1 = new String(stringBuffer);
        System.out.println(str1);
        String str2 = new String(stringBuilder);
        System.out.println(str2);
//        补充,此方法同上面两种方法效果一样。
        String str3 = stringBuffer.toString();
    }

常见的两种创建字符串的方式

   public static void main(String[] args) {
        String s1 = "JavaEE";
        String s2 = "JavaEE";
        //通过new+构造器的方式：此时s3、s4保存的地址值是数据在堆空间中开辟地址值
        String s3 = new String("JavaEE");
        String s4 = new String("JavaEE");
        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false
         System.out.println("******************面试题********************");
        String str1 = "javaEE";
        String str2 = "hadoop";
        String str3 = "javaEEhadoop";
        String str4 = "javaEE"+"hadoop";
        String str5 = str1+"hadoop";
        String str6 = "javaEE"+str2;
        String str7 = str1 + str2;
        //有对象参加拼接地址值就再堆空间
        System.out.println( str3 == str4);//true
        System.out.println( str3 == str5);//false
        System.out.println( str3 == str6);//false
        System.out.println( str5 == str6);//false
        System.out.println( str6 == str7);//false
    }

（常用顺序）方法

1.equals

boolean equals(Object anObject)
将此字符串与指定对象进行比较。

String str = "123";
String str2 = "123";
int i = 123;

//因为String有一个字符串池来存这些数据，所以为true。这样减少了内存的消耗。
System.out.println(str.equals(str2));
//对比对象，一定为false
//总结String继承并从写了equals方法，对象不同为false，都是字符串就比连接池。
System.out.println(str.equals(i));

2.spilt

split(String regex)/ split(String regex, int limit)
String str = "姓名,学号,密码;姓名1,学号1,密码1;姓名2,学号2,密码3;";
String[] strings = str.split(";");
for (String string : strings) {
    System.out.println(string);
    //我们可以通过改变limit的值发现第二次循环的的输出结果。它是用来控制次数用的。
    String[] split = string.split(",", 2);
    for (int i = 0; i < split.length; i++) {
        System.out.println(split[i]);
    }
}

3. substring

substring(int beginIndex)
返回一个字符串，该字符串是此字符串的子字符串。
substring(int beginIndex, int endIndex)
返回一个字符串，该字符串是此字符串的子字符串。

String str = "hello world";
System.out.println(str.substring(3));
System.out.println(str.substring(2,7));

4.replace

replace(char oldChar, char newChar)
返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。

replace(CharSequence target, CharSequence replacement)
将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。

replaceAll(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。

replaceFirst(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。

String str = "马上0202年了，要跟上步伐";
String string = str.replaceAll("02", "20");
System.out.println(string);
String string2  = str.replace('0', '2');
System.out.println(string2);
String string3 = str.replaceFirst("0","〇");
System.out.println(string3);
System.out.println(str);

5.toCharArray()、copyValueOf

String str = "马上0202年了，要跟上步伐";
char[] chars = str.toCharArray();
//你要的每个字符就出来了
 for (char aChar : chars) {
     System.out.print(aChar);
 }

char[] chars ={'h','e','l','l','o'};
String string = String.copyValueOf(chars);
System.out.println(string);

String testStr = new String();
char[] chars ={'h','e','l','l','o'};
String string = String.valueOf(chars);
System.out.println(string);

6.String contains方法（包含）

String str = "马上0202年了，要跟上步伐";
//一个简单又好用的方法。
 System.out.println(str.contains("02"));

but 效率测试

{
    public static void main(String[] args) {
        long l = 0;
        l = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            ContainsAndOr.testOr("1003");
        }
        System.out.println(System.currentTimeMillis()- l);
        long l2 = 0;
        l2 = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            ContainsAndOr.testContains("1003");
        }
        System.out.println(System.currentTimeMillis()- l2);
    }
    public static void testOr(String str){
        boolean flag = false;
        if("1001".equals(str) || "1002".equals(str) ||"1003".equals(str) || "1004".equals(str) || "1005".equals(str) || "1006".equals(str) ||"1007".equals(str) || "1008".equals(str)){
            flag = true;
        }
    }
    public static void testContains(String str){
        String string = "1001,1002,1003,1004,1005,1006,1007,1008";
        boolean flag = string.contains(str);
    }
}

结果你看
在这里插入图片描述

7. trim(去空格)

String str = "  去头  去尾  ";
//一个简单又好用的方法。
 char[] chars = str.trim().toCharArray();
 for (char aChar : chars) {
     System.out.println(aChar);
 }

在这里插入图片描述

8. valueOf将基本数据类型转化为String类型

都是静态方法
在这里插入图片描述

9. String 大小写转换toUpperCase()、toLowerCase()

String testStr = "AaBbCcDd";
System.out.println(testStr.toUpperCase());
System.out.println(testStr.toLowerCase());
/*
 * 原代码，按照相应规则进行转换。
 *  public String toUpperCase() {
 *             return toUpperCase(Locale.getDefault());
 *         }
 */
String testStr1 = "我是中文和&就不行了";
System.out.println(testStr1.toUpperCase());
System.out.println(testStr1.toLowerCase());

10、String indexOf、LastIndexOf方法

  /**
     * 根据中文文档可以看出这两类方法的作用，现在开始验证一下
     */
    @Test
    public void testIndexOfAndLastIndexOf(){
        String str = "这是一串很有意义(真的有意思)的字符串，0202年就这么过去了，新年加油！";
//        lastIndexOf(int ch)
//        返回指定字符的最后一次出现的字符串中的索引。
        System.out.println(str.indexOf(48));//48是根据编码的值，out：20
//        lastIndexOf(int ch, int fromIndex)
//        返回指定字符的最后一次出现的字符串中的索引，从指定的索引开始向后搜索。
        System.out.println(str.indexOf(48,21));//22
//        lastIndexOf(String str)
//        返回指定子字符串最后一次出现的字符串中的索引。
        System.out.println(str.indexOf("0"));//20
//        lastIndexOf(String str, int fromIndex)
//        返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。
        System.out.println(str.indexOf("0",21));//20
        System.out.println("****************************************************");
//        indexOf(int ch)
//        返回指定字符第一次出现的字符串内的索引。
        System.out.println(str.lastIndexOf(48));//22
//        indexOf(int ch, int fromIndex)
//        返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。
        System.out.println(str.lastIndexOf(48,21));//20
//        indexOf(String str)
//        返回指定子字符串第一次出现的字符串内的索引。
        System.out.println(str.lastIndexOf("0"));//22
//        indexOf(String str, int fromIndex)
//        返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
        System.out.println(str.lastIndexOf("0",21));//20
    }

11. contentEquals

//很有趣的方法，因为再后期如果你想考虑速度方法就用用到StringBuffer相关类

   @Test
    public void test1() {
        String testStr = "找规律题";
        StringBuffer sb = new StringBuffer("找规律题");
        //如字符串与指定 StringBuffer 表示相同的字符序列，则返回 true；否则返回 false。
        boolean b = testStr.contentEquals(sb);
        System.out.println(b);
    }

友情连接（参考网站）

连接：
http://www.matools.com/api/java8
https://www.runoob.com/java/java-string.html
https://docs.oracle.com/javase/8/docs/api/
https://blog.csdn.net/lsssss_/article/details/92826368

其实大家看着两个文档就可以了，但为自我提升我还是喜欢表达出来、并且自己总结一下，请赐教。谢谢！

厚积博发

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java8 String类常用方法讲解和实例

构造方法（Constructor and Description）String()初始化新创建的 String对象，使其表示空字符序列。// eg String string = new String(); String string1; String string3 = "this is a str"; Sys...
复制链接

扫一扫

专栏目录