（每日一转）黑马程序员----跟着老毕学Java之String类

最新推荐文章于 2023-09-09 22:49:50 发布

莱茵阿尔法

最新推荐文章于 2023-09-09 22:49:50 发布

阅读量640

点赞数

分类专栏： java学习

java学习专栏收录该内容

26 篇文章 0 订阅

订阅专栏

————————————————————————————————————————————

概述

字符串的特性

String类是final类型的，所以不能被被继承，方法不能被覆盖。它是一个引用数据类型，它的对象是一个字符串，程序中用””标示的都是字符串。字符串对象最大的特点是它为一个常量，一经初始化，永远不会改变，这是它跟其它引用数据类型最大的不同之处。

字符串常量池

是内存中的一块特殊的区域，用于存储字符串常量，其内部是一个char[]数组，存放一个个的字符。例如，对于String s1=“abc”；String s2 =“efg”；，这时字符串常量池中，会用char[]数组存储’a’、’b’、’c’、’e’、’f’、’g’6个字符，如果此时String s3 = “acg”，那么它会从常量池中拿出这个 a c g这三个字符，组成一个字符串对象赋给s3。

equals方法

String类复写了父类Object中的equals方法，比较的不再是内存地址，而是字符串对象的内容。

示例代码1：

[java] view plain copy print ?

package bxd.day13;
class StringDemo
{
public static void main(String[] args)
{
String s = new String();
String s1 = "abc";//知识点一:s1是一个类类型变量，所以“abc”是一个对象，这样赋值它存在常量池张。
//知识点二：字符串最大的特点：一旦被初始化就不可以被改变。
String s2 = new String("abc");//这样赋值它存在于堆内存中
<SPAN style="COLOR: black"> String s3="abc";</SPAN>
/*
知识点三：si和s2有什么区别？
s1在内存中有一个对象；
s2在内存中有两个对象(是在注释s1的情况下),一个在方法区的常量池张，一个在堆内存中。
字符串在内存中有个常量池，这个池是个数组，用于存放‘a’‘b’‘c’等的字符；
*/
// s2=s2.intern();//不注释这句话，则s1==s2结果为true。
//上边这句话的操作是：判断s2指向的字符串是否在常量池中，如果在则返回常量池中的引用，如果不在则把该字符串对象加入常量池中并返回常量池中的对象的引用。
System.out.println(s1==s2);
System.out.println(s1.equals(s2));//知识点四：String类复写了Object类中的equals方法，
//定义了自己的独特内容，该法方法用于判断字符串是否相同。
System.out.println(s1==s3);//结果为true，s3不再开辟空间。
}
}

package bxd.day13;
class StringDemo 
{
	public static void main(String[] args) 
	{
		String s = new String();
		String s1 = "abc";//知识点一:s1是一个类类型变量，所以“abc”是一个对象，这样赋值它存在常量池张。
						//知识点二：字符串最大的特点：一旦被初始化就不可以被改变。
		
		String s2 = new String("abc");//这样赋值它存在于堆内存中
		String s3="abc";
		/*
			知识点三：si和s2有什么区别？
						s1在内存中有一个对象；
						s2在内存中有两个对象(是在注释s1的情况下),一个在方法区的常量池张，一个在堆内存中。

			字符串在内存中有个常量池，这个池是个数组，用于存放‘a’‘b’‘c’等的字符；
		*/
//		s2=s2.intern();//不注释这句话，则s1==s2结果为true。
		//上边这句话的操作是：判断s2指向的字符串是否在常量池中，如果在则返回常量池中的引用，如果不在则把该字符串对象加入常量池中并返回常量池中的对象的引用。
		System.out.println(s1==s2);
		System.out.println(s1.equals(s2));//知识点四：String类复写了Object类中的equals方法，
												//定义了自己的独特内容，该法方法用于判断字符串是否相同。
		System.out.println(s1==s3);//结果为true，s3不再开辟空间。

	}
}

注意：学习String类，主要就是掌握它的特性跟方法。

String的常见功能

String类适用于描述字符串事物。

那么它就提供了多个方法对字符串进行操作。

1.获取（非常重要）

1.1字符串中的包含的字符数，也就是字符串的长度。

intlength():获取长度(数组中的长度是数组的一个属性)

1.2根据位置获取位置上的某个字符。

charcharAt(int index):

1.3根据字符获取该字符在字符串中的位置。

intindexOf(int ch):放回的ch在字符串中第一次出现的位置。

intindexOf（int ch，int fromIndex）：从fromIndex指定位置开始，获取ch在字符串中的位置。

intindexOf(String str):返回的是str在字符串中第一次出现才位置。

intindexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。

2.判断

2.1字符串中是否包含某一个子串

boolean contains(CharSequence s)

特殊之处：indexOf(str):可以所以str第一次出现的位置，如果返回-1，表示str不在字符串中存在。

所以，也可以用于判断指定判断是否包含。

if(str.indexOf("aa"!=-1));

而且该方法，既可以判断，也可以获取出现的位置。

2.2字符串中是否有内容。

booleanisEmpty():原理就是判断长度是否为零。

2.3字符串是否是以指定内容开头。

booleanstartsWith(str)

2.4字符串知否以指定内容结尾。

booleanendsWith(str)

2.5判断字符串的内容是否相同，复写了Object类中equals方法。

booleanequals（str）

2.6判断内容是否相同，并忽略大小写。

booleanequalsignoreCase();

3.转换

3.1将字符数组转成字符串。

构造函数：String(char[])

String(char [],offset,count):将字符数组中的一部分转成字符串。

静态方法：

static String copyValueOf(char [])

static String copyValueOf(char [] data,intoffset ,int count)

static String valueOf(char []);

3.2将字符串转成字符数组。

char[]toCharArray();

3.3将字节数组转成字符串。

String(byte[])

String(byte[],offset,count):将字节数组中的一部分转成字符串。

3.4将字符串转换成字节数组。

byte[]getBytes();

3.5将基本数据类型转成字符串。

staticString valueOf(int );

staticString valueOf(double);

//3+"";//String.valueOf(3);

注意：字符串和字节数组在转换过程中，是可以指定编码表的。

4.替换

Stringreplace(oldchar,newchar);

5.切割

String[]split(regex);(后边正则表达式)

6.子串，获取字符串中的一部分。

String substring(int beginIndex)

String substring(int beginIndex, int endIndex)

7.大小写转换，去除空格，比较。

7.1，将字符串转成大写或者小写。

StringtoUpperCase();

StringtoLowerCase();

7.2将字符串两端的多个空格去除。

Stringtrim();

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

intcompareTo(String)

忽略大小写比较，其实即使全部转成小写或大写，然后再比较。

代码2：（String方法使用示例）

[java] view plain copy print ?

class StringMethodDemo
{
public static void method_7()
{
String s = " Hello Java ";
sop(s.toUpperCase());
sop(s.toLowerCase());
sop(s.trim());//比如用户登录时，多了空格，最好使用trim去除一下。
String s1 = "a1c";
String s2 = "aaa";
sop(s1.compareTo(s2));
}
public static void method_sub()
{
String s = "abcdef";
sop(s.substring(2));//从指定位置开始到结尾，如果角标不存在，会出现字符角标越界异常。
sop(s.substring(2,4));//包含头不包含尾，s.substring(0,s.length());
}
public static void method_split()
{
String a = "zhangsan,lisi,wangwu";
String [] arr =a.split(",");
for(int x =0;x<arr.length;x++)
{
sop(arr[x]);
}
}
public static void method_replace()
{
String s = "hello java";
//String s1 = s.replace('q','c');//如果要替换的字符不存在，那么返回的是原字符串。
String s1 = s.replace("java","world");
sop("s="+s);
sop("s1="+s1);
}
public static void method_trans()
{
char [] arr = {'a','b','c','d','e','f'};
String s = new String(arr,1,4);
sop("s="+s);
String s1="erqwerwewr";
char [] chr = s1.toCharArray();
for(int x =0;x<chr.length;x++)
{
sop(chr[x]);
}
}
public static void method_is()
{
String str = "ArrayDemo.java";
sop(str.startsWith("Array"));
sop(str.endsWith(".java"));
sop(str.contains("Demo"));
}
public static void method_get()
{
String str = "abcd efad ddfe hg";
//长度
sop(str.length());
//根据索引获取字符
sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。
//根据字符获取索引
sop(str.indexOf('m',3));//如果没有找到返回-1；
//反向索引一个字符出现的位置：
sop(str.lastIndexOf("a"));
}
public static void main(String[] args)
{
// method_7();
method_sub();
//method_split();
//method_replace();
//method_trans();
//method_get();
//method_is();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

class StringMethodDemo 
{
	public static void method_7()
	{
		String s = "    Hello Java  ";
		sop(s.toUpperCase());
		sop(s.toLowerCase());
		sop(s.trim());//比如用户登录时，多了空格，最好使用trim去除一下。

		String s1 = "a1c";
		String s2 = "aaa";
		sop(s1.compareTo(s2));
	}
	public static void method_sub()
	{
		String s = "abcdef";
		sop(s.substring(2));//从指定位置开始到结尾，如果角标不存在，会出现字符角标越界异常。
		sop(s.substring(2,4));//包含头不包含尾，s.substring(0,s.length());
	}
	public static void method_split()
	{
		String a = "zhangsan,lisi,wangwu";
		String [] arr =a.split(",");
		for(int x =0;x<arr.length;x++)
		{
			sop(arr[x]);
		}
	}
	public static void method_replace()
	{
		String s = "hello java";

		//String s1 = s.replace('q','c');//如果要替换的字符不存在，那么返回的是原字符串。
		
		String s1 = s.replace("java","world");
		sop("s="+s);
		sop("s1="+s1);

	}
	public static void method_trans()
	{
		char [] arr = {'a','b','c','d','e','f'};

		String s = new String(arr,1,4);
		sop("s="+s);
		String s1="erqwerwewr";
		char [] chr = s1.toCharArray();
		for(int x =0;x<chr.length;x++)
		{
			sop(chr[x]);
		}
	}
	public static void method_is()
	{
		String str = "ArrayDemo.java";
		sop(str.startsWith("Array"));
		sop(str.endsWith(".java"));
		sop(str.contains("Demo"));
	}
	public static void method_get()
	{
		String str = "abcd efad ddfe hg";

		//长度
		sop(str.length());
		//根据索引获取字符
		sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。
		//根据字符获取索引
		sop(str.indexOf('m',3));//如果没有找到返回-1；
		//反向索引一个字符出现的位置：
		sop(str.lastIndexOf("a"));

	}
	public static void main(String[] args) 
	{
//		method_7();
		method_sub();
		//method_split();
		//method_replace();
		//method_trans();
		//method_get();
		//method_is();
		
		
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

StringBuffer

特点

StringBuffer，即字符串缓冲区，它跟数据一样，是一种容器，其特点是：

1.长度是可变化的

2.可以直接操作多个数据类型。

3.最终会通过toString()方法变成字符串。

容器的共性操作

容器有一些共性的操作，可以简单的总结为CRUD，即：

C create

U update

R read

D delete

StringBuffer的常见操作

1.存储

StringBufferappend():将指定的数据作为参数添加到已有数据的尾处。

StringBufferinsert(index,String str):可以将数据插入到指定index位置。

2.删除

StringBufferdelete(start,end):删除缓冲区中的数据，包含start，不包含end。

StringBufferdeleteCharAt(index):删除指定位置的字符。

3.获取

char charAt(int index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start, int end)

4.修改。

StringBuffer replace(int start, int end,String str)

void setCharAt(int index, char ch)

5.反转

StringBufferreverse();

void getChars(int srcBegin, int srcEnd, char[]dst, int dstBegin)

将字符从此序列复制到目标字符数组 dst。

代码示例3(StringBuffer方法使用)

[java] view plain copy print ?

class StringBufferDemo
{
public static void main(String[] args)
{
//method_update();
//method_del();
//method_add();
StringBuffer sb = new StringBuffer("abcde");
char[] chs = new char[6];
sb.getChars(1,4,chs,1);
for(int x =0;x<chs.length;x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
}
public static void method_update()
{
StringBuffer sb = new StringBuffer("abcde");
sop(sb.toString());
//sb.replace(1,4,"java");
sb.setCharAt(2,'k');
sop(sb.toString());
}
public static void method_del()
{
StringBuffer sb = new StringBuffer("abcde");
sop(sb.toString());
//sb.delete(1,3);
//清空缓冲区
//sb.delete(0,sb.length());
sb.deleteCharAt(2);
sop(sb.toString());
}
public static void method_add()
{
StringBuffer sb = new StringBuffer();
//1.存储功能
sb.append("abc").append(true).append(34);//方法调用链。
sop(sb.toString());
sb.insert(1,"qq");
sop(sb.toString());
/*
StringBuffer sb1 = sb.append(14);
sop("sb==sb1"+(sb==sb1));//结果为true
sop(sb.toString());
sop(sb.toString());
*/
}
public static void sop(String str)
{
System.out.println(str);
}
}

class StringBufferDemo 
{
	public static void main(String[] args) 
	{
		//method_update();
		//method_del();
		//method_add();		

		StringBuffer sb = new StringBuffer("abcde");		
		char[] chs = new char[6];
		sb.getChars(1,4,chs,1);
		for(int x =0;x<chs.length;x++)
		{
			sop("chs["+x+"]="+chs[x]+";");
		}
		
	}
	public static void method_update()
	{
		StringBuffer sb = new StringBuffer("abcde");
		sop(sb.toString());
		//sb.replace(1,4,"java");
		sb.setCharAt(2,'k');
		sop(sb.toString());


	}
	public static void method_del()
	{
		StringBuffer sb = new StringBuffer("abcde");
		sop(sb.toString());
		//sb.delete(1,3);

		//清空缓冲区
		//sb.delete(0,sb.length());
		sb.deleteCharAt(2);
		sop(sb.toString());
	}
	public static void method_add()
	{
		StringBuffer sb = new StringBuffer();
		//1.存储功能
		sb.append("abc").append(true).append(34);//方法调用链。
		sop(sb.toString());
		sb.insert(1,"qq");
		sop(sb.toString());

		/*
		StringBuffer sb1 = sb.append(14);
		sop("sb==sb1"+(sb==sb1));//结果为true
		sop(sb.toString());
		sop(sb.toString());
		*/

	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}

注意：在Java中，在容器中取一段元素，都是包含头不包含尾的。
冲

StringBuilder

JDK 1.5版本后出现了StringBuilder，它是StringBuffer的简易替代方案，它与StringBuffer的不同之处：

StringBuffer是线程同步，用于多线程。

StringBuilder是线程不同步的，单线程使用效率高，多线程要自己加同步。

建议在使用时优先考虑StringBuilder。

JDK升级的三个核心

1.提高效率。

2.简化书写。

3.提高安全性。

莱茵阿尔法

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
（每日一转）黑马程序员----跟着老毕学Java之String类

————————————————————————————————————————————概述字符串的特性String类是final类型的，所以不能被被继承，方法不能被覆盖。它是一个引用数据类型，它的对象是一个字符串，程序中用””标示的都是字符串。字符串对象最大的特点是它为一个常量，一经初始化，永远不会改变，这是它跟其它引用数据类型最大的不同之处。字符串常量池是内存中的一块特殊的
复制链接

扫一扫

专栏目录