嘿，程序员——String

最新推荐文章于 2024-08-14 23:12:09 发布

sea5241

最新推荐文章于 2024-08-14 23:12:09 发布

阅读量451

点赞数

文章标签： java String stringbuffer

本文链接：https://blog.csdn.net/sea5241/article/details/9568573

版权

String类
字符串是一个特殊的对象。
字符串一旦初始化就不可以被改变。

class StringDemo 
{
	public static void main(String[] args) 
	{
		String s1="abc";//s1是一个类类型变量，"abc"是一个对象。
		                //字符串最大特点：一旦被初始化就不可以被改变。
		//s1="kk";//"abc"没有变，还在内存里，只是s1指向的对象变啦，变成指向"kk".
		String s2=new String("abc");
		/*
		面试题：
		s1和s2有什么区别？
		s1在内存中有一个对象
		s2在内存中有两个对象
		*/
		System.out.println(s1==s2);
		System.out.println(s1.equals(s2));//String 类复写了Object类中equals方法，
		                                  //该方法用于判断字符串是否相同。
	}
}

String类是用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作

常见的操作有哪些？
"abcd"
1、获取。
1.1字符串中包含的字符数，也就是字符串的长度。
int length()：获取长度。
1.2根据位置获取位置上某个字符。
char charAt(int index)
1.3根据字符获取该字符在字符串中位置。
int indexof(int ch):返回的是ch在字符串中第一次出现的位置。
int indexof(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexof(String str):返回的是str在字符串中第一次出现的位置。
int indexof(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。
int lastIndexOf(int ch):反向索引，从最后往前查找
2、判断。
2.1 字符串中是否包含某一个字串。
boolean contain(str):
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1，表示该str不在字符串中存在。
所以也可以用于对指定判断是否包含。
if(str,indexOf("aa")!=-1)
而且该方法既可以判断，又可以获取出现的位置。

2.2 字符串中是否有内容.
boolean isEmpty():原理就是判断长度是否为0.
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endWith(str);
2.5 判断字符串的内容是否相同。
boolean aquals(str) 复写了Object类中的aquals方法。
2.6 判断内容是否相同，并忽略大小写。
boolean aqualsIgnoreCase();
3、转换
3.1 将字符数组转成字符串
构造函数：String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串。offset是数组角标
静态方法：static String copyValueOf(char[])
static String copyValueOf(char[] data,int offset,int count)

static String valueOf(char[])：
3.2 将字符串转成字符数组
char[] toCharArray();
3.3 将字节数组转成字符串
String(byte[])
String(byte[],offset,count)
3.4 将字符串转成字符数组
byte[] getBytes():
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static String valueOf(double)
3+"";相当于String.valueOf(3);返回的也是字符串

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
4、替换
String replace(oldchar,newchar)
5、切割
String[] split(regex);
6、子串。获取字符串的一部分
String substring(begin);
String substring(begin,end);
7、转换，去除空格，比较。
7.1 将字符串转成大写或小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除。
String trim();
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);

class StringMethodDemo 
{
	public static void method_7()
	{
		String s="   Hello java   ";
		sop(s.toLowerCase());
		sop(s.toUpperCase());
		sop(s.trim());//去除两端空格


		String s1="abc";
		String s2="aaa";
		sop(s1.compareTo(s2));//比较第一个出现不同的字符编码差值，b是98，a是97，因此结果是：1
	}
	public static void method_sub()
	{
		String s="abcdef";
		sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
		sop(s.substring(2,4));//包含头，不包含尾。结果是：cd 。获取整个s.substring(0,s.length());
	}
	public static void method_split()
	{
		String s="zhangsan,lisi,wangwu";
		String[] arr=s.split(",");
		for(int x=0;x<arr.length;x++)
		{
			sop(arr[x]);
		}
	}
	public static void metod_replace()
	{
		String s="hello java";
		String s1=s.replace('a','n');//如果要替换的字符不存在，返回的是原串。
		sop("s="+s);
		sop("s1="+s1);
	}
    public static void method_tran()
	{
		char[] arr={'a','b','c','d','e'};
		String s=new String(arr,1,3);
		sop("s="+s);
		String s1="zxcvbnm";
		char[] chs=s1.toCharArray();
		for(int x=0;x<chs.length;x++)
		{
			sop("ch="+chs[x]);
		}
	}
	public static void method_get()
	{
		String str="abcdeakpf";
		//长度
		sop(str.length());
		//根据索引获取字符。
		sop(str.charAt(4));
		//根据字符获取索引。
		sop(str.indexOf('a',3));
	}
	public static void main(String[] args) 
	{ 
		method_7();
		//method_split();
		//metod_replace();
		//method_tran();
		//method_get();
		/*String s1="abc";
		String s2=new String("abc");
		String s3="abc";
        System.out.println(s1==s2);//指向两个对象
		System.out.println(s1==s3);//字符串已经在内存中存在，而且不能被改变，
		*/                           //因此不再独立开辟空间，指向同一对象
	}
    public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

练习一：模拟一个trim方法，去除字符串两端的空格。

class  StringTest
{
	public static void sop(String str)
	{
		System.out.println(str);
	}
	public static String myTrim(String str)
	{
		int start=0,end=str.length()-1;
		while(start<=end&&str.charAt(start)==' ')
			start++;
        while(start<=end&&str.charAt(end)==' ')
			end--;
		return str.substring(start,end+1);
	}
	public static void main(String[] args) 
	{
		String s="    a b    ";
		sop("("+s+")");
		s=myTrim(s);
		sop("("+s+")");
	}
}

练习二：将字符串反转。

class  StringTest2
{
	public static void sop(String str)
	{
		System.out.println(str);
	}
	public static String reverseString(String str)
	{
		char[] arr=str.toCharArray();
		reverse(arr);
		return new String (arr);


	}
	public static void reverse(char[] arr)
	{
		for(int start=0,end=arr.length-1;start<end;start++,end--)
		{
			swap(arr,start,end);
		}
	}
	private static void swap(char[] arr,int x,int y)
	{
		char temp=arr[x];
		arr[x]=arr[y];
		arr[y]=temp;
	}
	public static void main(String[] args) 
	{
		String s="  cd  a b ef  ";
		sop("("+s+")");
		s=reverseString(s);
		sop("("+s+")");
	}
}

练习三：获取一个字符串在另一个字符串中出现的次数。

class StringTest3 
{
	//方法一
	public static int getSubCount(String str,String key)
	{
		int count=0;
		int index=0;
		while((index=str.indexOf(key))!=-1)
		{
			sop(str);
			str=str.substring(index+key.length());
			count++;
		}
		return count;
	}
	//方法2
	public static int getSubCount_2(String str,String key)
	{
		int count=0;
		int index=0;
        while((index=str.indexOf(key,index))!=-1)
		{
			index=index+key.length();
			count++;
		}
		return count;
	}
	public static void main(String[] args) 
	{
		String str="abkkcdkkefkkskk";
		sop("count="+getSubCount_2(str,"kk"));
	}
	public static void sop(String str)
	{
		System.out.println(str);
	}
}

练习四：获取一个字符串在另一个字符串中出现的次数。

class StringTest4 
{
	public static String getMax(String s1,String s2)
	{
		String max="";
		if(s1.length()<s2.length())
		{
			max=s2;
		}
		else
			max=s1;
		return max;
	}
	public static String getMin(String s1,String s2)
	{
		String min="";
		if(s1.length()<s2.length())
		{
			min=s1;
		}
		else
			min=s2;
		return min;
	}
	public static String getMaxSubString(String s1,String s2)
	{
		String max=getMax(s1,s2);
		String min=getMin(s1,s2);
		//String max="",min="";
		//max=(s1.length()>s2.length())?s1:s2;
		//min=(max==s1)?s2:s1;
		for(int x=0;x<min.length();x++)
		{
			for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)
			{
				String temp=min.substring(y,z);
				sop(temp);
				if(max.contains(temp))
					return temp;
			}
		}
		return "";
	}
	public static void main(String[] args) 
	{
		String s2="abcwerthelloyuiodef";
		String s1="cvhellobnm";
		sop(getMaxSubString(s1,s2));
	}
	public static void sop(String str)
	{
		System.out.println(str);
	}
}

StringBuffer
StringBuffer可以对字符串内容进行增删。
StringBuffer是字符串缓冲区，是一个容器。
特点：
1、长度是可变化的。
2、可以直接操作多个数据类型。
3、最终会通过toString方法变成字符串。

C create U update R read D delete
1、存储
StringBuffer append()：将指定数据作为参数添加到已有数据结尾处。
StringBuffer insert(index,数据):可以将数据插入到指定index位置。
2、删除
StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。
StringBuffer deleteCharAt(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(start,end,String)
void setCharAt(int index,char ch)
5、反转
StringBuffer reverse()
6、将缓冲区中指定数据存储到指定字符数组中
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

class StringBufferDemo 
{
	public static void sop(String str)
	{
		System.out.println(str);
	}
    public static void method_update()
	{
		StringBuffer sb=new StringBuffer("abcdef");
		sb.replace(1,4,"java");
		sop(sb.toString);
	}
	public static void method_del()
	{
		StringBuffer sb=new StringBuffer("abcdef");
		sb.delete(1,3);//adef,不包含尾
		//清空缓冲区。
		//sb.delete(0,sb.length());
		sb.delete(2,3);
		sb.deleteCharAt(2);//删除一个
		sop(sb.toString);
	}
	public static void method_add()
	{
		StringBuffer sb=new StringBuffer();


        sb.append("abc").append(true).append(34);
		sb.insert(1,"qq");//在第一位处插入qq
		sop(sb.toString());


		//StringBuffer sb1=sb.append(34);
		//sop("sb==sb1=:"+sb==sb1);//结果是true，因为是同一个容器里添加
	}
	public static void main(String[] args) 
	{
		StringBuffer sb=new StringBuffer("abcdef");
		char[] chs=new char[6];
		sb.getChars(1,4,chs,1);
		for(int x=0;x<chs.length;x++)
		{
			sop("chs["+x+"]="chs[x]+";");
		}
	}
}

JDK1.5版本之后出现了StringBuilder
StringBuffer是线程同步。安全，得判断锁，效率低。
StringBuilder是线程不同步。不安全，提高了效率。
以后开发，建议使用StringBuilder

升级三个因素：
1、提高效率。
2、简化书写。
3、提高安全性。

基本数据类型对象包装类
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character

基本数据类型对象包装类的最常见作用。
就是用于基本数据类型和字符串类型之间的转换
基本数据类型转成字符串。
基本数据类型+"";
基本数据类型.toString(基本数据类型值）；
如：Integer.toString(34);
字符串转成基本数据类型。
xxx a=Xxx.parseXxx(String);
int a=Integer.parseInt("123");
boolean b=Boolean.parseBoolean("true");

Integer i=new Integer("123");
int num=i.intValue();非静态的

十进制转成其他进制
toBinaryString();
toOctalString();
toHexString();
其他进制转成十进制
parseInt(String,radix)

class  IntegerDemo
{
	public static void sop(String str)
	{
		System.out.println(str);
	}
	public static void main(String[] args) 
	{
		//整数类型的最大值。
		//sop("int max:"Integer.MAX_VALUE);
		//将一个字符串转成整数。
		//int num=Integer.parseInt("123");//必须传入数字格式的字符串
		//sop("num="+(num+4));


		int x=Integer.parseInt("110",2);//根据指定进制转换前面的数为十进制
		sop("x="+x);
	}
}

JDK1.5版本以后出现的新特性

class  IntegerDemo1
{
	public static void sop(String str)
	{
		System.out.println(str);
	}
	public static void method()
	{
		Integer x=new Integer("123");
		Integer y= new Integer(123);
		sop("x==y:"+(x==y));
		sop("x.equals(y):"+x.equals(y));//比较的是数值
	}
	public static void main(String[] args) 
	{
		//Integer x=new Integer(4);
		Integer x = 4;//自动装箱
		x = x+2;//x+2：x进行自动拆箱，变成了int类型，和2进行加法运算。再将和进行装箱赋给x


		Integer m=128;
		Integer n=128;
		sop("m==n:"+(m==n));//结果为false


		Integer a=127;
		Integer b=127;
		sop("a==b:"+(a==b));//面试题：结果为true，因为a和b指向了同一个Integer对象。
		                    //因为当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会开辟新的空间。-128——127
	}
}

总结：勤加练习，多敲代码，熟练掌握String里各种方法的用法。

sea5241

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
嘿，程序员——String

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------（教13-01）String类字符串是一个特殊的对象。字符串一旦初始化就不可以被改变。class StringDemo { public static void main(String[] args)
复制链接

扫一扫