黑马程序员java基础之字符串

最新推荐文章于 2024-06-19 11:00:59 发布

yueye12

最新推荐文章于 2024-06-19 11:00:59 发布

阅读量388

点赞数

本文链接：https://blog.csdn.net/yueye12/article/details/44489051

版权

------- android培训、java培训、期待与您交流！ ---------

String 类是最终类，没有类

字符串最大特点：一旦被初始化，不会再改变

class StringDemo 
{
	public static void main(String[] args) 
	{
		String s="abc";		//s是一个类类型变量，“abc”是一个对象
		String s1=new String("abc");

		System.out.println(s.equals(s1));<span style="white-space:pre">	</span>
		System.out.println(s1==s);
	}
}

执行结果是：

true

false

因为s指向的是“abc”对象，而s1指向了一个新的字符串对像，所以s==s1是false，这个比较的是字符串内存地址值

而字符串复写了Object的equals方法，比较两个字符串的内容是否相同

对于上面，s代表1个对象，s1有两个对象（new就新建一个对象，而“abc”又是一个字符串对象）

class StringDemo 
{
	public static void main(String[] args) 
	{
		String s="abc";		//s是一个类类型变量，“abc”是一个对象
		String s1=new String("abc");
		String s2="abc";

		System.out.println(s.equals(s1));
		System.out.println(s1==s);
		Systetm.out.println(s==s2);
	}
}

执行结果是：

true

false

true

说明s2不会在开辟一片空间存储“abc”，因为其已经存在了，所以s2也指向了"abc"，所以s==s3

字符串的常见操作

1.获取：

获取字符串中字符的个数，即字符串的长度：int length();

根据位置获取位置上的某个字符：char charAt(int index);

根据字符获取字符在字符串中的位置：int indexOf(int ch);()里面是字符对应的ASC码，所以是Int类型的，返回的是第一次出现字符的位置

int indexOf(int ch,int fromIndex)获取从指定位置fromIndex开始出现的字符位置

int indexOf(String str)获取字符串中首次出现str的位置

int indexOf(String str,int fromIndex)获取str在字符串从指定索引处fromIndex处开始出现的位置

class StringDemo 
{
	public static void main(String[] args) 
	{
		String s="abc";		//s是一个类类型变量，“abc”是一个对象
		String s1=new String("abc");
		String s2="abc";

		method_get();
		System.out.println(s.equals(s1));
		System.out.println(s1==s);
		System.out.println(s==s2);
	}
	public static void method_get()
	{
		String str="abcdegha";

		//长度
		sop(str.length());	//此处可以将int型的基本数据类型作为Object对象传入，是因为JDK1.5版本之后出现的新特性：基本数据类型的提升，装箱

		//根据索引获取字符
		sop(str.charAt(3));
		//根据字符获取索引，如果没有，返回-1
		sop(str.indexOf('a',3));
		//反向索引一个字符出现位置,从后面开始找，但是角标不会变
		sop(str.lastIndexOf('a'));

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

2判断：

字符串中是否包含某个子串:boolean contains(str)

因为indexOf(str)，如果str不存在于字符串中，那么就返回-1，所以此方法也可以用于判断是否包含某字符串：if(str.indexOf("abc") !=-1),此方法不止可以判断，还可以获取角标

字符串中是否有内容:boolean isEmpty()注意，此方法在jdk1.6之后出现原理就是判断长度是否为0

字符串是否以指定内容开头:boolean startWith(str);

字符串是否以指定内容结尾 :boolean endsWith(str);

判断字符串的内容是否相同：boolean equals(str);

判断内容是否相同，并忽略大小写： boolean equalsIgnoreCase();

class StringDemo 
{
	public static void main(String[] args) 
	{
		String s="abc";		//s是一个类类型变量，“abc”是一个对象
		String s1=new String("abc");
		String s2="abc";

		method_get();
		method_if();
	}
	public static void method_if()
	{
		String str="StringDemo.java";

		//判断字符串是否以“String”开头
		sop(str.startsWith("String"));

		//判断字符串是否以“.java”结束
		sop(str.endsWith(".java"));

		//判断字符串中是否包含“Demo”
		sop(str.contains("Demo"));
	}
	
	public static void method_get()
	{
		String str="abcdegha";

		//长度
		sop(str.length());	//此处可以将int型的基本数据类型作为Object对象传入，是因为JDK1.5版本之后出现的新特性：基本数据类型的提升，装箱

		//根据索引获取字符
		sop(str.charAt(3));
		//根据字符获取索引，如果没有，返回-1
		sop(str.indexOf('a',3));
		//反向索引一个字符出现位置,从后面开始找，但是角标不会变
		sop(str.lastIndexOf('a'));

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

3.转换

将字符数组转为字符串：

构造函数：String(char[ ])

String(char [ ],int offset,int count):将字符数组中的一部分转换为字符串，offset表示偏移量，count表示要转换的字符个数

static String :valueCopyOf(char[])

static String valueCopyOf(char[],int offset,int count)

static StringvalueOf(char[])

static String valueOf(char[],int offset,int count)

将字符串转为字符数组：

char[]: toCharArray(),括号中的对象就是字符串，相当于省略了this

将字节数组转为字符串：

String(byte[])

String(byte[],int offset,int count)

将字符串转为字节数组：

byte[] getBytes()

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

static String:valueOf(int)3+" ",String.valueOf(3)，这两种都是将数字3转换为字符串

static String valueOf(double)

static String valueOf(char[],int offset,int count)

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

class StringDemo 
{
	public static void main(String[] args) 
	{
		String s="abc";		//s是一个类类型变量，“abc”是一个对象
		String s1=new String("abc");
		String s2="abc";

		method_get();
		method_if();
		method_change();
	}
	public static void method_change()
	{
		String str="abcde";
		char[] ch={'h','e','l','l','o','y','o','u'};
		//通过构造函数转换字符数组为字符串
		String s=new String(ch);
		String s1=new String(ch,5,3);	//转换字符数组中的指定的一些字符

		char[] c=str.toCharArray();
		for(int x=0;x<c.length;x++)
		{
			System.out.println(c[x]);
		}
		sop(s);
		sop(s1);
	}
	public static void method_if()
	{
		String str="StringDemo.java";

		//判断字符串是否以“String”开头
		sop(str.startsWith("String"));

		//判断字符串是否以“.java”结束
		sop(str.endsWith(".java"));

		//判断字符串中是否包含“Demo”
		sop(str.contains("Demo"));
	}
	
	public static void method_get()
	{
		String str="abcdegha";

		//长度
		sop(str.length());	//此处可以将int型的基本数据类型作为Object对象传入，是因为JDK1.5版本之后出现的新特性：基本数据类型的提升，装箱

		//根据索引获取字符
		sop(str.charAt(3));
		//根据字符获取索引，如果没有，返回-1
		sop(str.indexOf('a',3));
		//反向索引一个字符出现位置,从后面开始找，但是角标不会变
		sop(str.lastIndexOf('a'));

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

4.替换

Stringnreplace(oldchar,newchar) 将字符串中的某个字符oldchar替换为newchar

5.切割

String[] split(regex) 将字符串按照一定的规则切割形成字符串数组

6.子串

String substring(int begin); //获取字符串中的子串,从索引begin处开始到结束

String substring(int begin,int end) //获取字符串中指定的子串，包含头begin不包含尾end
7.去除空格，比较

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

String toUpperCase()

String toLowerCase()

将字符串两端的多个空格去掉

String trim()

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

int compareTo(String)

str1.compareTo(str2):如果字符串按照字典顺序，str1要大于str2，则返回正数，如果小于则返回负数，注意是按照字符串中的字符顺序比较的，如果已经比较出来了，后面的字符不再参与比较

字符串练习：

1.模拟一个字符串的trim方法，去除字符串两端的空格

思路：建立两个头尾指针，分别从头尾开始检测，当遇到了空格，指针进行自增自减，最后获取两个指针之间的内容，就是去除了两端空格的字符串

class StringTest1 
{
	public static void main(String[] args) 
	{
		String str="     mytrim    ";
		System.out.println(str);
		System.out.println(mytrim(str));
	}
	public static String mytrim(String str)
	{
		int sta=0,end=str.length()-1;	//建立两个标志位，分别从头尾开始，
		while(sta<=end && str.charAt(sta)==' ')	//检测到了头部有空格，头部指针自增
		{
			sta++;
		}
		while(sta<=end && str.charAt(end)==' ')	//检测到了尾部有空格，尾部指针自减
		{
			end--;
		}
		String s=str.substring(sta,end+1);	//注意获取子串方法是包含头不包含尾，所以end需要+1来获取最后一个有效字符串
		return s;
	}
}

2.将字符串中指定的内容进行反转，如：“abcde” "adcbe"

思路：将字符串转换为字符数组，可以根据数组角标首尾交换位置，完成数组的反转，然后再将转换了的数组转换为字符串

class StringTest2 
{
	public static void main(String[] args) 
	{
		String str="abcdefg";
		System.out.println(ReverseString(str,2,4));
	}
	public static String ReverseString(String str,int sta,int end)	//完成字符串反转的功能
	{
		//将字符串转换成字符数组
		char[] ch=str.toCharArray();

		//对数组进行反转
		reverse(ch,sta,end);

		//将新字符数组转换为字符串
		return String.valueOf(ch);

	}
	private static void reverse(char[] ch,int x,int y)	//完成字符数组反转的方法
	{
		for(int sta=x,end=y-1;sta<=end;sta++,end--)		//end=y-1表示包含头不包含尾
		{
			swap(ch,sta,end);
		}
	}
	private static void swap(char[] ch,int x,int y)	//调换位置的方法
	{
		char temp=ch[x];
		ch[x]=ch[y];
		ch[y]=temp;
	}
}

练习3：获取一个字符串在另一个字符串中出现的位置

思路：既要判断字符串是否存在于母字符串中，又要获取字符串在母串中的位置，使用indexOf(),使用计数器，获取一次，计数器增加一次，然后母串从获取到的位置重新找子串

class StringTest3
{
	public static void main(String[] args) 
	{
		String str="abbcdefbbhgblbb";
		String key="bb";
		System.out.println(getLocation_2(str,key));
	}
	public static int getLocation(String str,String key)
	{
		int index=0;	//定义初始角标
		int count=0;	//定义计数器

		while((index=str.indexOf(key,index))!=-1)		//当indexOf的返回值不为-1,则说明子串存在于母串中，并且同时获取到了子串在母串中的角标
		{
			str=str.substring(index+key.length());	//母串不断从新的角标处开始获取
			
			System.out.println(str);
			count++;
		}
		return count;
	}
	public static int getLocation_2(String str,String key)
	{
		int index=0;	//初始化角标
		int count=0;	//初始化计数器

		while((index=str.indexOf(key,index))!=-1)	//使用indexOf(str,int offset)方法，不断的变换角标，当找到初始位置时，角标就从key存在于母串中之后的位置开始找
		{
			index=index+key.length();	//角标位从找到子串并超越子串之后的位置查找，这样就不用在内存中不断开辟空间存取新的字符串
			System.out.println(index);
			count++;
		}
		return count;
	}
}

练习四：获取两个字符串的最大相同子串

思路：用短的字符串和长字符串作对比，如果不相同，短的字符串长度递减，依旧和长字符串作对比，直到获取最长相同子串为止

class StringTest4
{
   public static void main(String[] args)
   {
      String s1="abcwerthelloyuiodef";
      String s2="zs";
      sop(getMaxSbuString(s1,s2));
    }

   public static String getMaxSbuString(String s1,String s2)
   {
	   //初始化两个字符串，用于表示长短字符串
	   String max="";
	   String min="";
	   max=(s1.length()>s2.length())?s1:s2;		//将长字符串赋给max
	   min=(max==s1)?s2:s1;						//将短字符串赋给min
	   for(int x=0;x<min.length();x++)		//外循环控制整个循环的次数，x=0的时候就是整个s2进行内循环
	   {
		   	//定义每次与长字符串s2比较的子串的头指针y,尾指针z，注意，并不包含z,而是子串到z-1,因为z要取到s2的长度，这样才能获取到最后一个字符，所以z!=s2.length+1
			for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)	
		   {
				//用临时字符串变量记录每次获取的s2的子串，好用来和长字符串作比较
				String temp=min.substring(y,z);	

				if(max.contains(temp))	//判断s1中是否包含子串
					return temp;
		   }
	   }
	   return " ";	//如果循环没有找到相同字符串，就返回空的字符串
   }
   public static void sop(String str)
	{
		System.out.println(str);
   }
}

StringBuffer

StringBuffer是字符缓冲区，是一个容器,长度可变，可以直接操作多个数据类型

最终可以通过toString()方法变成字符串

在这个容器中可以存储，删除，获取，修改

存储：StringBuffer append()将指定数据添加到已有数据的结尾处

StringBuffer insert(index,obj) 在指定位置添加元素

删除：StringBuffer delete(int start,int end) //包含头不包含尾
StringBuffer deleteCharAt(index) //删除指定位置的字符

获取：

char charAt(index) 获取指定位置的字符

int indexOf(String str); 获取字符串在StringBuffer中的位置

int lastIndexOf(String str) 反向获取str在StringBuffer中的位置

int length() 获取长度

String substring(int start,int end) //获取指定位置的字符串

修改：

StringBuffer replace(int start,int end,String str) 将容器中指定位置之间的数据替换成str

void setCharAt(int index,char ch) 将指定位置的字符替换成新字符ch，注意此方法没有明确的返回值，只要修改就可以了

反转：

StringBuffer reverse();

class StringBufferDemo 
{
	public static void main(String[] args) 
	{
		update_method();
	}

	public static void update_method()
	{
		StringBuffer sb=new StringBuffer("abcde");
		sb.replace(0,3,"hello");	//将容器中的指定位置间的元素替换成指定元素
		sop(sb.toString());
		sb.setCharAt(1,'o');	//注意此方法没有明确的返回值，只要修改了就好了
		sop(sb.toString());
	}
	public static void delete_method()
	{
		StringBuffer sb=new StringBuffer("abcde");

		//sb.delete(0,3);		//包含头不包含尾
		sop(sb.toString());
		//sb.delete(0,sb.length());	//清除缓冲区
		sb.deleteCharAt(1);	//删除指定位置的字符
		sop(sb.toString());
	}
	public static void add_method()
	{
		StringBuffer sb=new StringBuffer();
		sb.append("abc");	//返回的还是StringBuffer对象
		
		sb.append(34).append(true).append('b');	//方法调用链，因为返回的仍然是本类对象
		sop(sb.toString());
		sb.insert(2,"hello");	//在2号角标位插入元素
		sop(sb.toString());
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

JDK1.5版本之后，出现了StringBuilder,与StringBuffer功能相似，不同之处是StringBuffer是线程同步的，安全，而StringBuilder线程不同步

基本数据类型包装类

其他数据类型转换为十进制：parseInt(String,radix),radix代表要转换的进制，值为2,8,16

十进制转换为其他进制：toHexString(),toBinaryString();

class IntDemo 
{
	public static void main(String[] args) 
	{
		int x=Integer.parseInt("3c",16);	//将3c转换为10十进制
		System.out.println(x);
		int y=Integer.parseInt("123");	//将字符串"123"转换为整数型123
		System.out.println(y+4);

		System.out.println(Integer.toHexString(12));	//将10进制转换为16进制
	}
}

JDK1.5版本之后出现了新特性，基本数据类型的自动升级，自动装箱

出现此新特性之后，Integer x=null.是成立的

class IntDemo1
{
	public static void main(String[] args) 
	{
		Integer x=4;	//自动装箱，4是一个对象，但是可以直接参与运算，相当于Integer x=new Integer(4)
		
		int y=x+2;	//进行自动拆箱，相当于x.intValue(x)+2,intValue()是获取int型的数

		Integer a=new Integer("123");
		Integer b=new Integer(123);

		System.out.println("a==b="+(a==b));	//结果为false，因为是新建了两个新对象，所以不同
		System.out.println("a.equals(b)="+a.equals(b));	//Integer复写了equals方法，比较两个对象中的数值是否相同

		Integer c=128;
		Integer d=128;
		System.out.println("c==d="+(c==d));	//结果为false,因为相当于重建了两个对象，指向不同

		Integer e=127;
		Integer f=127;
		System.out.println("e==f="+(e==f));	//结果为真，因为这是JDK1.5版本之后的特点，值在byte范围内，如果之前的对象存在，就不会新建对象，而指向之前的对象
	}
}