Java字符串——String类和StringBuilder类

最新推荐文章于 2024-07-26 12:28:02 发布

Sleeping God

最新推荐文章于 2024-07-26 12:28:02 发布

阅读量283

点赞数

文章标签： java 字符串

本文链接：https://blog.csdn.net/weixin_47678894/article/details/118718486

版权

String类
String类在java.lang包下，使用的时候不需要导包
String类代表字符串。Java程序中的所有字符串文字都被实现为此类的实例
也就是说，Java程序中所有的双引号字符串，都是String类的对象

字符串的特点：
字符串不可变，它们的值在创建后不能被更改
虽然String的值是不可变的，但是它们可以被共享
字符串效果相当于字符数组（char[]），但是底层原理是字节数组（byte[]）

String构造方法

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
String s=“abc”;	直接赋值的方法创建字符串对象，内容就是abc

//String类的构造方法
public class StringDemo {
	public static void main(String[] args) {
		// public String() 创建一个空白字符串对象，不含有任何内容
		String s1 = new String();
		System.out.println("s1:" + s1);
		// public String(char[] chs)根据字符数组的内容，来创建字符串对象
		char[] chs = { 'a', 'b', 'c' };
		String s2 = new String(chs);
		System.out.println("s2:" + s2);
		// public String(byte[] bys)根据字节数组的内容，来创建字符串对象
		byte[] bys = { 97, 98, 99 };// 97,98,99即对应a,b,c
		String s3 = new String(bys);
		System.out.println("s3:" + s3);
		// String s="abc";直接赋值的方法创建字符串对象，内容就是abc
		String s4 = "abc";
		System.out.println("s4:" + s4);
	}
}

运行结果：
在这里插入图片描述
String对象的特点

通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同

char[] chs = { 'a', 'b', 'c' };
String s1 = new String(chs);
String s2 = new String(chs);

上面代码中，JVM会首次创建一个字符数组，然后每一次new的时候都会有一个新地址，只不过s1和s2参考的字符串内容是相同的

以“”的方式给出的字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护

String s3 = "abc";
String s4 = "abc";

在上面的代码中，针对第一行代码，JVM会建立一个String对象放在字符串池中，并给s3参考，第二行则让s4直接参考字符串池中的String对象，也就是说它们本质上是同一个对象

代码如下：

// 比较字符串对象地址值是否相同
		// 构造方法的方法得到对象
		char[] chs = { 'a', 'b', 'c' };
		String s1 = new String(chs);
		String s2 = new String(chs);
		System.out.println(s1 == s2);
		// 直接赋值的方法得到对象
		String s3 = "abc";
		String s4 = "abc";
		System.out.println(s3 == s4);
		System.out.println(s1 == s3);

运行结果：
在这里插入图片描述
字符串的比较
使用==做比较：
基本类型：比较的是数据值是否相同
引用类型：比较的是地址值是否相同

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫equals()
public boolean equals(Object anObject):将此字符串与指定对象进行比较，由于我们比较的是字符串对象，所以参数直接传递一个字符串

		char[] chs = { 'a', 'b', 'c' };// 构造方法的方法得到对象
		String s1 = new String(chs);
		String s2 = new String(chs);
		String s3 = "abc";// 直接赋值的方法得到对象
		String s4 = "abc";

		// 比较字符串对象地址值是否相同
		System.out.println(s1 == s2);
		System.out.println(s3 == s4);
		System.out.println(s1 == s3);
		System.out.println("-----------");

		// 比较字符串内容是否相同
		System.out.println(s1.equals(s2));
		System.out.println(s3.equals(s4));
		System.out.println(s1.equals(s3));

运行结果：
在这里插入图片描述
String中的方法

方法名	说明
public boolean equals(Object anObject)	比较字符串的内容，严格区分大小写（用户名和密码）
public char charAt(int index)	返回指定索引处的char值
public int length()	返回此字符串的长度

案例：用户登录

需求：已知用户名和密码，请用程序实现模拟用户登录，总共给三次机会，登录之后，给出相应提示

package hello;

import java.util.Scanner;

//用户登录
//需求：已知用户名和密码，请用程序实现模拟用户登录，总共给三次机会，登录之后，给出相应提示
public class Loading {
	public static void main(String[] args) {
		String name = "aaaaaa";
		String password = "aaa123";
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < 3; i++) {
			System.out.println("请输入用户名：");
			String s1 = sc.nextLine();
			System.out.println("请输入密码：");
			String s2 = sc.nextLine();
			if (name.equals(s1) && password.equals(s2)) {
				System.out.println("登陆成功");
				break;
			} else if (i == 2) {
				System.out.println("输入次数已达上限");
			} else {
				System.out.println("登陆失败，你还有" + (2 - i) + "次机会");
			}
		}
	}
}

在这里插入图片描述

案例：遍历字符串

需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串

//遍历字符串
//需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
public class BianLiString {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		// 获取字符串中的每一个字符
		// public char charAt(int index)返回指定索引出的char值
		// 获取字符串长度s.length()
		for (int i = 0; i < s.length(); i++) {
			System.out.println(s.charAt(i));
		}
	}
}

运行结果：
在这里插入图片描述

案例：统计字符次数

需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数（不考虑其他字符）

import java.util.Scanner;

//统计字符次数
//需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数（不考虑其他字符
public class TongJiStringTime {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		int a = 0, b = 0, c = 0;// 定义字符个数的统计变量，小写，大写，数字
		// 获取字符串中的每个字符，遍历字符数组
		for (int i = 0; i < s.length(); i++) {
//			System.out.println(s.charAt(i));
			if (s.charAt(i) >= 'a' && s.charAt(i) <= 'z') {
				a++;
			} else if (s.charAt(i) >= 'A' && s.charAt(i) <= 'Z') {
				b++;
			} else if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
				c++;
			}
		}
		System.out.println("小写字符的个数：" + a);
		System.out.println("大写字符的个数：" + b);
		System.out.println("数字字符的个数：" + c);

	}
}

运行结果：
在这里插入图片描述

案例：拼接字符串

需求:定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果，例如，数组为int[] arr={1,2,3};，执行方法后的输出结果为：[1,2,3]

//拼接字符串
//需求:定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，
//调用该方法，并在控制台输出结果，例如，数组为int[] arr={1,2,3};，
//执行方法后的输出结果为：[1,2,3]

public class PingJieString {
	public static String pingJie(int[] arr) {
		String s = "";
		s += "[";
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				s += arr[i];
			} else {
				s += arr[i];
				s += ",";
			}
		}
		s += "]";
		return s;
	}

	public static void main(String[] args) {
		int[] arr = { 11, 22, 33, 44, 55 };
		System.out.println(pingJie(arr));
	}
}

运行结果：
在这里插入图片描述

案例：字符串反转

需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出

import java.util.Scanner;

//字符串反转
//需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出
public class FanZhuanString {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		char[] chs = new char[s.length()];
		for (int i = 0; i < s.length(); i++) {
			chs[i] = s.charAt(i);
		}
		System.out.print("反转前：");
		for (int i = 0; i < chs.length; i++) {
			System.out.print(chs[i]);
		}
		System.out.println();
		System.out.print("反转后：");
		System.out.println(fanZhuan(chs));
	}

	public static String fanZhuan(char[] chs) {
		String s = "";
		for (int i = chs.length-1; i>-1; i--) {
			s += chs[i];
		}
		return s;
	}
}

运行结果：
在这里插入图片描述

StringBuilder

StringBuilder概述

		String s = "hello";
		s += "world";
		System.out.println(s);

如果对字符串进行拼接，每次拼接，都会构建一个新的String对象，即耗时，又浪费内存空间，而这种操作还不可避免。我们可以通过Java提供的StringBuilder类来解决这个问题

StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器
这里的可变指的是StringBuilder对象中的内容是可变的

String和StringBuilder的区别：
String:内容是不可变的
StringBuilder:内容是可变的

StringBuilder构造方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

public class StringBuilderDemo {
	public static void main(String[] args) {
		// public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
		StringBuilder sb = new StringBuilder();
		System.out.println("sb：" + sb);
		System.out.println("sb.length:" + sb.length());
		
		// public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象
		StringBuilder sb2 = new StringBuilder("hello");
		System.out.println("sb2：" + sb2);
		System.out.println("sb2.length:" + sb2.length());
	}
}

运行结果：
在这里插入图片描述
StringBuilder的添加和反转方法

方法名	说明
public StringBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	返回相反的字符序列
public String toString()	通过toString()就可以实现把StringBuilder转换为String

		// StringBuilder的添加和反转方法
		// public StringBuilder append(任意类型) 添加数据，并返回对象本身
		StringBuilder sb = new StringBuilder();
//		StringBuilder sb3=sb.append("hello world");
//		System.out.println("sb：" + sb);
//		System.out.println("sb3：" + sb3);
//		System.out.println(sb==sb3);

//		sb.append("hello");
//		sb.append("world");
//		sb.append("100");

		// 链式编程
		sb.append("hello").append("world").append("100");
		System.out.println("sb：" + sb);

		// public StringBuilder reverse()返回相反的字符序列
		sb.reverse();
		System.out.println("sb：" + sb);

运行结果：
在这里插入图片描述
StringBuilder和String相互转换

StringBuilder转换为String
public String toString():通过toString()就可以实现把StringBuilder转换为String
String转换为StringBuilder
public StringBuilderr(String s):通过构造方法就可以实现把String转换为StringBuilder

public class StringBuilderDemo2 {
	public static void main(String[] args) {
//		StringBuilder转换为String
		StringBuilder sb = new StringBuilder();
		sb.append("hello");
		// String s=sb;//这个是错误的
		String s = sb.toString();
		System.out.println(s);

//		String转换为StringBuilder
		String ss = "hello";
		// StringBuilder sb1=ss;//这个是错误的
		StringBuilder sb1 = new StringBuilder(ss);
		System.out.println(sb1);

	}
}

运行结果：
在这里插入图片描述

案例：拼接字符串升级版

public class PinJieStringBuilder {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3 };
		System.out.println(pinJie(arr));
	}

	// 用StringBuilder方法进行拼接
	public static String pinJie(int[] arr) {
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				sb.append(arr[i]);
			} else {
				sb.append(arr[i]);
				sb.append(",");
			}
		}
		sb.append("]");
		// 结果转成String返回
		String s = sb.toString();
		return s;
	}
}

运行结果：
在这里插入图片描述

案例：字符串反转升级版

需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出

public class FanZhuanStringBuilder {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		System.out.println(fanZhuan(s));
	}

	public static String fanZhuan(String s) {
		StringBuilder sb = new StringBuilder(s);//用StringBuilder的反转方法
		sb.reverse();
		s = sb.toString();//转换为String
		return s;
//		return new StringBuilder(s).reverse().toString();
	}
}

运行结果：
在这里插入图片描述

Sleeping God

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java字符串——String类和StringBuilder类

String类String类在java.lang包下，使用的时候不需要导包String类代表字符串。Java程序中的所有字符串文字都被实现为此类的实例也就是说，Java程序中所有的双引号字符串，都是String类的对象字符串的特点：字符串不可变，它们的值在创建后不能被更改虽然String的值是不可变的，但是它们可以被共享字符串效果相当于字符数组（char[]），但是底层原理是字节数组（byte[]）String构造方法方法名说明public String()创建一个空
复制链接

扫一扫