Java知识总结-字符串

最新推荐文章于 2023-03-30 16:52:20 发布

撄宁

最新推荐文章于 2023-03-30 16:52:20 发布

阅读量802

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/u013335720/article/details/18054213

版权

java基础专栏收录该内容

26 篇文章 0 订阅

订阅专栏

说明：其实之所以写这篇文章总结字符串的知识点，纯粹是因为关于字符串所涉及到的方法太多，所以多写几次这些方法加深自己的记忆和运用。本文将列举字符串常见的方法及其应用。

一，String类

1.1 String类对象的创建

Java中每个字符串都是String类的一个实例化对象。且每个字符串本身都是一个常量，其值不会改变，当我们将这些常量赋值给String类型的变量时，称为对字符串对象的应用。其格式如：

String str1=“Hello World”；

当多个String型变量所赋值的字符串相同时：

String s1="Hello Java";
String s2="Hello Java";

系统并未重复创建String类对象，而是将同一个对象的内存地址值赋给了不同的变量，所以这些String变量引用的是同一个字符串，他们具有相同的实体。

原理：当程序创建一个新的字符串变量时，会先将这个变量所对应的字符串对象与内存中存放字符串的常量池中已有字符串进行比较，当发现这个字符串已经存在于常量池中，系统会直接将这个字符串的地址赋给新建的String型变量。若常量池中没有发现与这个新建字符串相同的对象，则会新建一个字符串对象，然后将这个字符串对象的地址值赋给新建的String型变量。

字符串对象创建的另一种方式：

String str2=new String("Hello World");

需要注意的是：通过这两种不同方式创建出的String类对象是有区别的，str1在内存中只有一个对象，它只指向一个地址，而str2在内存中有两个对象，它指向两个地址值。
所以此时虽然str1和str2所指向的字符串内容相同，但他们所应用的地址值并不是相等的：

public class Test {
	public static void main(String[] args) {
        String str1="Hello World";
        String str2=new String("Hello World");
        System.out.println(str1.equals(str2));  //结果为true，两个字符串内容相同
        System.out.println(str1==str2);   //结果为false,两变量所应用的地址值有区别
	}
}

运行结果：

true
false

1.2 String类常见方法举例

1.2.1 获取：

lengt()：获取字符串长度，返回值类型int，示例：

public class Test {
	public static void main(String[] args) {
        String str="Hello World";
        int len=str.length();  //获取字符串长度
        System.out.println(len);
	}
}

运行结果;

注：length()在String类中是一个方法，而数组中同样有获取数组长度的属性length，一个是方法，一个是属性，注意两者区别。

charAt(int index):获取指定位置上的字符，返回值类型char，示例：

public class Test {
	public static void main(String[] args) {
        String str="Hello World";
        char c=str.charAt(4);  //获取位置为4的字符
        System.out.println(c);  //结果为字符'o'
	}
}

运行结果：

同时，通过循环该方法，可以遍历字符串中的所有字符：

public class Test {
	public static void main(String[] args) {
        String str="Hello World";
        for (int i = 0; i < str.length(); i++) {  //通过for循环遍历
			char c=str.charAt(i);
			System.out.println(c);
		}
        
	}
}

运行结果：

H
e
l
l
o
 
W
o
r
l
d

indexOf(int ch):获取指定字符在字符串中首次出现的位置，返回值类型int,示例：

public class Test {
	public static void main(String[] args) {
        String str="Hello World";
        int index=str.indexOf('o');  //获取字符'o'首次在字符串中出现的位置
        System.out.println(index);   //结果为4
        
	}
}

运行结果：

当indexOf()方法所传入的参数字符不属于指定字符串时，方法返回值为-1，示例：

public class Test {
	public static void main(String[] args) {
        String str="Hello World";
        int index=str.indexOf('a');   //获取字符'a'在字符串中首次出现的位置
        System.out.println(index);    //返回值为-1
        
	}
}

运行结果

-1

index(int ch)方法有另一种常见重载形式：index(int ch,int fromIndex)：该方法表示从指定位置fromIndex开始获取字符ch首次出现在字符串中的位置，示例：

public class Test {
	public static void main(String[] args) {
        String str="Hello World";
        int index=str.indexOf('o',5);   //从位置5开始查询字符'o'在后面字符串首次出现位置
        System.out.println(index);    //结果为7，表明此时获取的位置并不是str中的第一个'o'
        
	}
}

运行结果：

注：该方法查询是从fromIndex这个位置开始的，也就是说fromIndex指定位置也包含在查询的范围内。同样，如果查询未发现存在与参数字符ch相同字符时，返回-1.

indexOf()同样也可以获取一个子字符串首次出现的位置，这就是该方法的另一种重载：

indexOf(String str);

同样也可以从指定位置开始查询子字符串首次出现的位置：

indexOf(String str,int fromIndex);

示例：

public class Test {
	public static void main(String[] args) {
        String str="abcdefabcdef";
        int index=str.indexOf("cde");  //获取子字符串"cde"在str中首次出现的位置
        int index2=str.indexOf("cde",5);  //获取子字符串在位置5之后首次出现的位置
        System.out.println(index);
        System.out.println(index2);
        
	}
}

运行结果：

2
8

lastIndexOf(int ch):获取指定字符ch在字符串最后一次出现的位置，返回值类型int,

lastIndexOf(int ch,int fromIndex)：从指定位置开始进行反向搜索，获取字符ch最后一次出现的位置，

lastIndexOf(String str)：获取指定子字符串最后一次出现的位置，

lastIndexOf(String str,int fromIndex)：从指定位置开始进行反向搜索，找到子字符串最后一次出现的位置。

示例：

public class Test {
	public static void main(String[] args) {
        String str="abcdefabcdefabc";
        int index1=str.lastIndexOf('f'); //获取字符'f'在字符串最后一次出现的位置
        int index2=str.lastIndexOf('f',10);  //从位置10开始反向获取字符'f'最后一次出现位置
        int index3=str.lastIndexOf("ab");  //获取子字符串最后一次位置
        int index4=str.lastIndexOf("ab",10);  //从位置10开始反向获取子字符串最后一次出现位置
        System.out.println(index1);
        System.out.println(index2);
        System.out.println(index3);
        System.out.println(index4);
	}
}

运行结果：

substring(int beginIndex):从指定位置到字符串结尾获取字符串的一个子串，

substring(int bdginIndex,int endIndex):从指定开始位置到指定结束位置，获取原字符串的一个子串。

注：当指定角标不存在，则会出现字符串角标越界异常。

注：上面两个方法的结果是一个新的字符串，并不覆盖原字符串，原字符串值不变。且生成的子串包含beginIndex所对应的字符，但是不包含endIndex所对应的字符（包含头不包含尾）示例：

public class Test {
	public static void main(String[] args) {
      String str="how are you";
      //获取从角标3到结尾的子串
      String str2=str.substring(3);
      //获取从角标4到角标7的子串
      String str3=str.substring(4,7);
      System.out.println("str2="+str2);
      System.out.println("str3="+str3);
	}
}

运行结果：

str2= are you
str3=are

1.1.2 判断
startsWith(String prefix):判断字符串是否以指定的前缀开始，返回值类型boolean；

endsWith(String suffix):判断字符串是否以指定的后缀结束,返回值类型boolean;

isEmpty():判断字符串是否为空，返回值l类型boolean；

contains(String str)：判断字符串是否包含指定的字符串str，返回值类型boolean;

equals(Object obj)：判断两字符串内容是否相同，返回值类型boolean;

注：String类中的equals()方法是覆盖Object类中equals()方法的，所以该方法的形式参数仍然为Object类对象。同样，任意类复写这个方法时，形参都是Object类的。
下面是使用上述方法的简单示例：

public class Test {
	public static void main(String[] args) {
       String str="asdfghjkl";
       //判断str是否以"asd"作为前缀开始
       System.out.println(str.startsWith("asd"));
       //判断str是否以"fgh"作为后缀结束
       System.out.println(str.endsWith("fgh"));
       //判断字符串是否为空
       System.out.println(str.isEmpty());
       //判断str字符串是否包含"abc"
       System.out.println(str.contains("abc"));
       //判断str是否与"asdjkl"内容相同
       System.out.println(str.equals("asdjkl"));
	}
}

运行结果：

true
false
false
false
false

1.1.3 转换

将字符数组转换为字符串：

方法一：构造函数
String(char[] value)：通过将字符数组作为参数传递给String类构造函数的方式，创建一个字符串，这个字符串的内容包含字符数组中所有字符;

String(char[] value,int offset,int count)：从从数组指定位置offest开始获取count个元素，作为参数传入String类构造函数，从而创建出包含着部分元素的字符串；示例：

public class Test {
	public static void main(String[] args) {
       char[] value={'a','b','c','d','e','f','g','h'};
       //将字符数组转换为字符串
       String str1=new String(value);
       System.out.println("str1="+str1);
       //将字符数组中部分元素转换为字符串
       String str2=new String(value,2,3);
       System.out.println("str2="+str2);
	}
}

运行结果：

str1=abcdefgh
str2=cde

方法二：

copyValueOf(char[] data): 静态方法，返回值类型String，将字符数组转换为字符串；

copyValueOf(char[] data,int offest,int count):从数组指定位置offest开始获取count个元素，转换为字符串；示例：

public class Test {
	public static void main(String[] args) {
       char[] data={'a','b','c','d','e','f','g','h'};
       //将字符数组转换为字符串
       String str1=String.copyValueOf(data);
       System.out.println("str1="+str1);
       //将字符数组中部分元素转换为字符串
       String str2=String.copyValueOf(data,2,3);
       System.out.println("str2="+str2);
	}
}

运行结果：

str1=abcdefgh
str2=cde

将字符串转换为字符数组：

toCharArray():返回值类型char[]；示例：

public class Test {
	public static void main(String[] args) {
       String str="How are you";
       //将字符串转换为字符数组
       char[] c=str.toCharArray();
       //打印字符数组
       printCharArray(c);
	}
	//创建一个方法实现打印字符数组的功能
	public static void printCharArray(char[] c){
		System.out.print("[");
		for (int i = 0; i < c.length; i++) {
			if(i==c.length-1)
			System.out.print("'"+c[i]+"'");
			else
			System.out.print("'"+c[i]+"'"+",");
		}
		System.out.print("]");
	}
}

运行结果

['H','o','w',' ','a','r','e',' ','y','o','u']

将字节数组转换为字符串：

String（byte[] bytes）;

String(byte[] bytes,int offest,int length);
上述方法与字符数组转换为字符串中的方法类似，这里就不复述了；

将字符串转换为字节数组：

getBytes()：返回值类型byte[];

上述方法示例：

public class Test {
	public static void main(String[] args) {
       byte[] bytes={97,115,105,100};
       //字节数组转换为字符串
       String str=new String(bytes);
       String str2="asdfghj";
       //字符串转换为字节数组
       byte[] b=str2.getBytes();
	}
}

将基本数据类型的数据转换为字符串：

valueOf()：静态方法，返回值类型String,该方法有多种重载形式，可以将各种基本数据类型数据作为参数传递给该方法。将这些基本数据转换为字符串形式:

public class Test {
	public static void main(String[] args) {
       int i=456;
       //int型数据转换为字符串
       String s1=String.valueOf(i);
       boolean b=true;
       //boolean型数据转换为字符串
       String s2=String.valueOf(b);
       char c='a';
       //char型数据转换为字符串
       String s3=String.valueOf(c);
       long l=3214;
       //long型数据转换为字符串
       String s4=String.valueOf(l);
       float f=12.34f;
       //float型数据转换为字符串
       String s5=String.valueOf(f);
       double d=789.456;
       //double型数据转换为字符串
       String s6=String.valueOf(d);
	}
}

将字符串转换成大写或小写：

toUpperCase():将字符串中所有字符都转换为大写，返回值类型String;

toLowerCase():将字符串中所有字符都转换为小写，返回值类型String；

注：上面两个方法生成的结果字符串是一个新的字符串，有字符串值不变，示例;

public class Test {
	public static void main(String[] args) {
      String str1="how are you";
      //将字符串str1中所有字符改为大写
      String str2=str1.toUpperCase();
      String str3="ABCDEFG";
      //将字符串str3中所有字符改为小写
      String str4=str3.toLowerCase();
      System.out.println("str2="+str2);
      System.out.println("str4="+str4);
	}
}

运行结果：

str2=HOW ARE YOU
str4=abcdefg

1.1.4 替换

replace(char oldChar,char newChar)：用新的字符newChar替换字符串中所有oldChar字符。返回值类型String；

replace(String oldstr,String newstr)：用新的子串替换字符串中指定的子串，返回值类型String；

注：上述方法生成的字符串是一个新的字符串，被操作的原有字符串本身值并不改变，当被替换的字符和子串不存在于原有字符串，则返回原字符串，不生成新字符串；

示例：

public class Test {
	public static void main(String[] args) {
      String str="aaabbbcccaabbcc";
      //将字符串str中字符'a'全部替换为'z'，生成新的字符串
      String str2=str.replace('a', 'z');
      //将字符串str中子串"ab"全部替换为"xy",生成新的字符串
      String str3=str.replace("ab", "xy");
      System.out.println("str2="+str2);
      System.out.println("str3="+str3);
      //字符串str值不变，仍为原字符串
      System.out.println("str="+str);
	}
}

运行结果：

str2=zzzbbbccczzbbcc
str3=aaxybbcccaxybcc
str=aaabbbcccaabbcc

1.1.5 切割

split(String regex)：以regex为切割点，将原字符串分割为多个字符串，regex不存在于结果中，返回值类型String[]:

示例：

public class Test {
	public static void main(String[] args) {
      String str="aaa,bbb,ccc,aa,bb,cc";
      //以","作为切割点，切割字符串，生成字符串数组
      String[] s=str.split(",");
      //对生成的字符串数组进行遍历
      for (int i = 0; i < s.length; i++) {
		System.out.println(s[i]);
      }
	}
}

运行结果：

aaa
bbb
ccc
aa
bb
cc

当选定的切割点regex不存在于被切割的字符串中，该方法返回的是单元素字符串数组，这个元素就是原字符串。示例：

public class Test {
	public static void main(String[] args) {
      String str="aaa,bbb,ccc,aa,bb,cc";
      //以"q"作为切割点，切割字符串，生成字符串数组
      String[] s=str.split("q");
      //生成的字符串数组长度为1，证明只有一个元素
      System.out.println(s.length);
      //打印这个数组唯一的元素
      System.out.println("生成数组的唯一元素是："+s[0]);
	}
}

运行结果：

1
生成数组的唯一元素是：aaa,bbb,ccc,aa,bb,cc

1.1.6 去除字符串两端的空格

trim():返回值类型String，示例：

public class Test {
	public static void main(String[] args) {
      String str1="      abc     ";
      //出去字符串str1两端空格
      String str2=str1.trim();
      //打印去除空格前字符串
      System.out.println("去除空格前字符串"+"\""+str1+"\"");
      //打印去除空格后字符串
      System.out.println("去除空格后字符串"+"\""+str2+"\"");
	}
}

运行结果：

去除空格前字符串"      abc     "
去除空格后字符串"abc"

1.1.7 对两个字符串进行自然顺序比较

compareTo(String anotherString)：返回值类型 int；

说明；s1.compareTo(s2);

结果为正数：按字典顺序s1在s2之后

结果为0：两字符串相等

结果为负数：按字典顺序s1在s2之前

示例：

public class Test {
	public static void main(String[] args) {
      String s1="aaa";
      String s2="abc";
      //对两字符串进行自然顺序比较
      int i=s1.compareTo(s2);
      System.out.println(i);
	}
}

运行结果：

-1

撄宁

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java知识总结-字符串

说明：其实之所以写这篇文章总结字符串的知识点，纯粹是因为关于字符串所涉及到的方法太多，所以多写几次这些方法加深自己的记忆和运用。本文将列举字符串常见的方法及其应用。一，String类1.1 String类对象的创建Java中每个字符串都是String类的一个实例化对象。且每个字符串本身都是一个常量，其值不会改变，当我们将这些常量赋值给String类型的变量时，成为对字符串对象的应用。其
复制链接

扫一扫