程序员_Java基础之<六>-String

最新推荐文章于 2023-12-07 22:42:44 发布

李嘉欣-第四维空间

最新推荐文章于 2023-12-07 22:42:44 发布

阅读量799

点赞数

分类专栏： Java程序员-初级

本文链接：https://blog.csdn.net/ljx19900116/article/details/8831313

版权

Java程序员-初级专栏收录该内容

16 篇文章 0 订阅

订阅专栏

/*Java API-String*/
String用于描述字符串事物。那么它提供了多个方法对字符串进行操作。
常见操作：
“abcd”
1.获取。
1.1字符串中的包含的字符数，也就是字符串的长度。
int length（）:获取长度，注意数组中获取长度时，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字符串中出现的位置。
2.判断。
2.1字符串是否包含某一个子串。
boolean contains（str）；
特殊之处：indexOf（str）：可以索引str第一次出现位置，如果返回-1，表示str不在字符串中存在。
所以，也可以用于指定判断是否包含。
if（str.indexOf（"aa"）！=-1）
而且该方法既可以判断，又可以获取出现的位置。
2.2字符串是否有内容
boolean isEmpty（）：原理就是判断长度是否为0
2.3字符串是否是以指定内容开头。
boolean startsWith（str）；
2.4字符串是否是以指定内容结尾。
boolean endsWith（str）；
2.5判断字符串内容是否相同，复写了Object类中的equals方法。
boolean equals（str）；
2.6判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase（）；
3.转换。
3.1将字符数组转换为字符串。
a.构造函数：String(char[])
String(char[],offset.count):将字符数组中的一部分转成字符串。
b.静态方法：
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);包含头，不包含尾。s.substring(0,s.length());
7.转换，去除空格，比较。
7.1将字符串转成大写或者小写。
String toUpperCase();
String toLowerCase();
7.2将字符串两端的多个空格去除。
String trim();
7.3将两个字符串进行自然顺序的比较。
int compareTo(string);从第一个字符开始比较ASC码值，大于返回正数，等于返回0，小于负数

示例：

<span style="font-size:18px;color:#666666;">class StringDemo
{
	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));
	}
	public static void method_sub()
	{
		String s="abcdef";
		sop(s.substring(2));//从指定位置开始到结尾，如果角标不存在，会出现字符串角标越界异常
		sop(s.substring(2));//包含头，不包含尾。s.substring(0,s.length());

	}
	public static void method_split()
	{
		String s="zhangsan,lisi.wangwu";
		String[] arr=s.split(",");
		fou(int x=0;x<arr.length;x++)
		{
			sop(arr[x]);
		}

	}
	public static void method_replace()
	{
		String s="hello java";
		//String s1=s.replace('a','n');
		sop("s="+s);//hello java,字符串一旦被初始化，不会改变。
		String s1=s.replace("java","word");
		sop("s1="+s1);//hello jnvn
	}

	public static void methoe_trans()
	{
	
		char[] arr={'a','b','c','d','e','f'};
		//String s=new  String(arr);
		String s=new  String(arr,1,3);//从下表为1，打印3个，为bcd
		sop("s="+s);
		String s1="xfrggwrg";
		char[] chs=s1.toCharArry();
		for(int x=0;x<chs.length;x++)
		{
			sop("ch="+chs[x]);
		}
	}
	public static void main(String[] args)

	{
		method_get();
		/*String s1="abc";//s1是一个类类型变量，“abc”是一个对象。
						//字符串最大特点：一旦被初始化就不可以被改变。
		String s2=new String("abc");
		String s3="abc";
			//s1和s2有什么区别？？
		
			//s1在内存中有一个对象。s2在内存中有两个对象。
		

		System.out.println(s1==s2);//false,两个是不同的类类型变量
		System.out.println(s1.equals(s2));//true，String类复写了Object类中equals方法，该方法用于判断字符串是否相同。

		System.out.println(s1==s3);//true，因为相同的字符串已经在内存中存在了，为了节约内存，规定s1，s3，指向同一对象。
*/
	}
	public static void method_get()
	{
		String str="abcdeakpf";
		sop(str.length());//长度
		sop(str.charAt(4));//根据索引取字符
		sop(str.indexOf('m',3));//如果没找到，得-1
	sop(str.lastIndexOf("a"));//反向索引一个字符出现的位置
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);

	}
	public static void method_is()
	{
		String str="ArrayDemo.java";
		sop(str.startsWith("Array"));//判断文件名称是否是Array单词开头。
		sop(str.endsWith(".java"));//判断文件名称是否是.java的文件
		sop(str.contains("Demo"));//判断文件中是否包含Demo
	}
}</span>

/*字符串练习1,
	模拟trim方法，去除字符串两端的空格。
	思路：
	1.判断字符串第一个位置是否为空格，如果是继续向下判断，直到不是空格为止。结尾处判断空格也如此。
*/


	class StringTest1
	{
		public static void sop(String str)
		{
			System.out.println(str);
		}
		public static void main(String[] args)
		{
			String s="   ab cd   ";
			sop("("+s+")");
		
			s=myTrim(s);
			sop("("+s+")");


		}
//练习一，去除字符串两端空格
	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);
		}


	}
	//练习2：将字符串反转
	
	
	public static String reverseString(String s,int start,int end)//将字符串部分反转
	{
		char chs=s.toCharArray();//字符串变数组
		reverse(chs,satart,end);//反转数组
		return new String(chs);//将数组变成字符串 




	}
	public static String reverseString(String s)//将字符串全部反转
	{
		return reverseString(s,0,s.length()); 
	}
	
	private static void reverse(char[] arr,int x,int y)
	{
		fou(int start=x;,end=y-1;start<end;start++,end--)//注意：此处习惯性将end写成y-1，因为传值时，只要给其串s.length即可。
			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;
	}
	/*练习3.获取一个字符串在另一个字符串中出现的次数。
	思路：  1，定义一个计数器。
			2，获取kk第一次出现的位置。


	
	
	*/
	public static int getSubCount(String str,String key)//获取str的子串key出现的次数
	{
		int count=0;
		int index=0;
		while((index=str.indexOf(key))!=-1)//str能获取到key的位置，count就+1；
		{
		
			sop("str="+str);
			str=str.substring(index+key.length());
			count++;
		}
		return count;
	}
	/*练习三 方式二*/
	public static int getSubCount_2(String str,String key)
	{
		int count=0;
		int index=0;
		while((index=str.indexOf(key,index))!=-1)
		{
			sop("index="+index);
			index=index + key.length();
			conut++;
		}
	return count;
	}
	/*练习四
	获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度依次递减的子串打印。
	思路：
		1.将短的那个子串按照长度递减的方式获取到。
		2.将每获取到的子串去长串中判断是否包含，如果包含，已经找到！
	*/
	class StringTest3
	{
		public static String getMaxSubString(String s1,String s2)
			String max="",min="";
			max=(s1.length()>s2.length())?s1:s2;
			min=(max==s1)?s2:s1;//将小的赋给min
			for(int x=0;x<min.length();x++)//控制每次选取的子串的长度，length，length-1，。。。1
				for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)//y,z分别表示首尾，


				{
					String temp=min.substring(y,z);//求子串时，包含头不包含尾。
					sop(temp);
					if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
						return temp;
				}
	}

/*StringBuffer:

1.StringBuffer是一个---容器,缓冲区--。
1.长度时可以变化的。
2.可以直接操作多个数据类型。
3.最终会通过toString方法变成字符串。
a.存储。
StringBuffer append():将指定数据作为参数添加已有数据的结尾处。
StringBuffer insert(index,数据)：可以将数据插入到指定index位置
b.删除
StringBuffer delete(int start,int end)删除缓冲区的数据，包含头不包含尾。
StringBuffer delete(index)
c.获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start,int end)
d.修改
StringBuffer replace(start,end,string);
void setCharAt(int index,char ch);
e.反转

StringBuffer reverse();
f.将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin，int srcEnd,char[] dst,int dstBegin)

StringBuilder
作为StringBuffer的一个简易替换，但StringBuffer是同步的，StringBuilder保证不同步，不安全。
多线程用StringBuffer，单线程用StringBuilder（没锁），提高效率。
以后开发建议用StringBuilder。

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

class stringBufferDemo
	{
		public static void main(String[] args)
		{
			
		}
		public static void method_add()
		{
			StringBuffer sb=new StringBuffer();
			sb.append(34).sppend("abc").append(true);//添加。34abctrue
			sb.insert(1,"qq")//在角标为1处添加qq,3qqabctrue
			
			sb.delete(0,sb.length());//清空缓冲区
			sb.deleteCharAt(2);


			sop(sb.toString());
			
		}
		public static void method_del()
		{
			StringBuffer sb=new StringBuffer("abcde");
			sb.delete(1,3);//结果为ade，角标1-3的没了，不包含尾。
			sop(sb.toString());
		}
		public static void method_update()
		{
			StringBuffer sb=new StringBuffer("abcde");
			sb.replace(1,4,"java");//ajavae
			sb.setCharAt(2,'k');//abkde
			sop(sb.toString());
		}
		public static void gerChars()
		{
			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]+";");
			}


		}


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

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

基本数据类型对象包装类的最常见作用：
就是用于基本数据类型和字符串类型之间的转换。

1.基本数据类型转成字符串。
方法：a基本数据类型+“”
b基本数据类型.toString(基本数据类型值)
如：Integer.toString(34);//将34正数变成“34”。

2.字符串转成基本数据类型。
xxx a=Xxx.parseXxx(String);
int a=Integer.parseInt("123");
double b=Double.parseDouble("12.3");
boolean b=Boolean.parseBoolean("true");

十进制转成其他进制。
toaBinaryString();
toHexString();//16进制
toOctalString();

其他进制转成十进制。
parseInt(string,radix)
*/

class IntegerDemo
	{
		public static void main(String[] args)
		{
			//整数类型的最大值。
			//sop("int max:"+Integer.MAX_VALUE);
			//将一个字符串转成整数
			int num=Integer.parseInt("123");//必须传入数字格式的字符串。
			long x=Long.parseLong("123")
			sop("num"+(num+4));
			sop(Integer.toBinaryString(-6));//求-6的二进制
			sop(Integer.toHexString(60));//求-6十六进制


			int x=Integer.parseInt("3c",16)//将字符转换成指定进制的数
				sop("x="+x);


		}
	}
	/*JDk1.5以后的新特性*/
	class IntegerDemo1
	{
		public static void main(String[] args)
		{
			Integer x=new Integer(4);
			Integer x=4;//自动装箱，4相当于new Integer(4)，是上句的替换，新特性，注意Integer型的变量可为null
			x=x/*x.intValue()*/+2;//x+2:x进行了自动拆箱，变成可int型。和2进行加法运算，然后将和进行装箱赋值给x
			


			Integer m=128;
			Integer n=128;
			sop("m==n:"(m==n));
			
			Integer a=127;
			Integer b=127;
			sop("a==b:"(a==b));
			/*结果为true。因为a和b指向了同一个Integer对象.
			因为当数值在byte范围内容，对于新特性，如果该数值已经存在则不会开辟新空间。*/
		}
	}

李嘉欣-第四维空间

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
程序员_Java基础之<六>-String

-----------android培训、java培训、期待与您交流！ ----------------/*Java API-String*/String用于描述字符串事物。那么它提供了多个方法对字符串进行操作。常见操作：“abcd”1.获取。1.1字符串中的包含的字符数，也就是字符串的长度。int length（）:获取长度，注意数组中获取长度时，length
复制链接

扫一扫

专栏目录