String、Integer、StringBuffer和API类中的常用方法

最新推荐文章于 2024-02-26 16:56:23 发布

淡_漠

最新推荐文章于 2024-02-26 16:56:23 发布

阅读量825

点赞数

文章标签： string stringbuffer

本文链接：https://blog.csdn.net/sinat_20602107/article/details/46926121

版权

String类：

String是final类型的（最终类），String类不可以有子类

字符串是一个特殊的对象

字符串一旦被初始化，就不可以改变

String str1="abc";
String str2=new String("abc");
/*
 * str1和str2的区别：
 * str1在在常量池中有一个对象:"abc"
 * str2在内存中有堆内存有一个对象并引用了常量池中的"abc"地址
 * str1==str2    
 * 结果为：false
 * str1.equals（str2）    结果为：true
 * 因为：String类复写了Object类中equals方法，该方法用于判断字符串是否相等
 */

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

String类提供的方法：

常用操作方法：

1，获取

字符串的长度：length（）

根据位置获取某个字符：charAt（int ）

根据字符串获取在字符串中的位置：indexOf（String str）

如果indexOf返回值为”—1“，则表示该str不在字符串中

从指定位置开始获取字符在字符串中的位置：indexOf（String str，int fromIndex）

根据字符获取在字符串中的位置：lastIndexOf（String str）

从指定位置开始获取字符在字符串中的位置：lastIndexOf（String str，int fromIndex）

根据字符获取在字符串中的位置： indexOf（int ch）

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

2，判断

字符串中是否包含某一个字符串： contains

字符串是否为空：isEmpty（）：原理就是判断长度是否为”0“

字符串的开始是否是指定内容：startsWith（”字符串“）

字符串的末尾是否是指定内容：endsWith（”字符串“）

比较字符串的大小：compareTo（”字符串“），不包含，返回值为”-1“

判断字符串内容是否相同：equals（”字符串“），复写了Object中的equals方法

判断字符串内容是否相同（忽略大小写）：equalsIsIgnoreCase（”字符串“）

3，转换

将字符数组转成字符串：String（char [ ]）

String（char[ ]，起始位置，个数）：从指定位置转换指定个数

另一种方法是：调用Arrays.toString（）方法：String str=Arrays.toString(arr);

将字符串转换成字符数组： char [ ] toCharArray（）

将字节数组转成字符串：String（byte [ ]）

将字符串转成字节数组：byte [ ] getBytes（）

将基本数据类型转换成字符串：String valueOf（数据类型）

4、替换

replace（”旧字符串“，”新字符串“） 如果要替换的字符串不存在，则返回原串

5、切割

split（”规则“）

/*
 * 例如：String str="zhangsan lisi wangwu"
 */
String [] arr=str.split(" ");//按空格切，切的值存入到数组中
for(int i=0;i<arr.length-1;i++)
{
	System.out.println(arr[i]);
}

6、从指定位置开始截取一部分字符串：substring（begin，end），如果省略end，则截取到末尾

String str="abcdef"

String str1=str.substring(1,2); （包含头，不包含尾）

7、转换

转换为小写：toLowerCase()

转换成大写：toUpperCase()

去除空格：

trim（）：去除字符串两端空格

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

compareTo（）：如果两个字符串相等，则返回”0“

如果A字符串大于B字符串，则返回两数相减的正数

如果A字符串小于B字符串，则返回两数相减的负数

以上重要方法练习：

class  StringMethodDemo
{
	public static void method_7()
	{
		String s = "    Hello Java     ";
		sop(s.toLowerCase());<span style="white-space:pre">	</span>//将字符串转换为小写字母
		sop(s.toUpperCase());<span style="white-space:pre">	</span>//将字符串转换为大写字母
		sop(s.trim());<span style="white-space:pre">		</span>//取出字符串的前后空格
		String s1 = "a1c";
		String s2 = "aaa";
		sop(s1.compareTo(s2));<span style="white-space:pre">	</span>//compareTo比较两个字符串
	}
	//截取
	public static void method_sub()
	{
		String s = "abcdef";
		sop(s.substring(2));<span style="white-space:pre">	</span>//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
		sop(s.substring(2,4));<span style="white-space:pre">	</span>//包含头，不包含尾 s.substring(0,s.length());
	}
	//切割
	public static void  method_split()
	{
		String s = "zhagnsa,lisi,wangwu";
		String[] arr  = s.split(",");<span style="white-space:pre">	</span>//切割后，返回的是一个字符串数组
		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','n');//如果要替换的字符不存在，返回的还是原串。
		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,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_is()
	{
		String str = "ArrayDemo.java";		
		//判断文件名称是否是Array单词开头。
		sop(str.startsWith("Array"));
		//判断文件名称是否是.java的文件。
		sop(str.endsWith(".java"));
		//判断文件中是否包含Demo
		sop(str.contains(".java"));
	}
	//获取
	public static void method_get()
	{
		String str = "abcdeakpf";
		//长度
		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_trans();
		method_is();
		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);
	}
}

字符串操作练习：

获取一个字符串在另一个字符串中出现的次数

/*
 * 字符串操作练习：
 * 获取一个字符串在另一个字符串中出现的次数。
 * 思路：
 * 1、定义个计数器。
 * 2、获取kk第一次出现的位置。
 * 3、从第一次出现位置后剩余的字符串中继续获取kk出现的位置，每获取一次就计数一次。
 * 4、当获取不到时，计数完成。
 */
class  StringTest
{
	public static int getSubCount(String str,String key)
	{
		int count = 0;<span style="white-space:pre">	</span>//计数器
		int index = 0;<span style="white-space:pre">	</span>//索引位置

		while((index=str.indexOf(key))!=-1)<span style="white-space:pre">	</span>//在字符串中查找另一个字符串的起始位置
		{
			sop("str="+str);
			str = str.substring(index+key.length());<span style="white-space:pre">	</span>//截取字符串并赋予字符串
			count++;	//如果找到，统计出现的次数
		}
		return count;
	}
	public static void main(String[] args) 
	{
		String str = "kkabkkcdkkefkks";
		sop("count="+getSubCount(str,"kk"));
	}

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

Integer类

MIN_VALUE：Integer类型的最小值

MAX_VALUE：Integer类型的最大值

toBinaryString（60）：将60转换为二进制

toOtcalString（60）：将60转换为8进制

toHexString（60）：将60转换为16进制

//int（数值型） --- String（字符串）
int num = 100
//通过+""
String s=num+""
//通过String类中的valueOf()
String s=String.valueOf（num）
//通过Integer类中的toString方法
String s  =Integer.toString（num）；
//String（字符串） --- int（数值型）
String s="100"
//Integer的构造方法
Integer i =  new Integer（s）
int num  = i . intValue（）
//通过Integher类中的parseInt
int num = Integer . parseInt（s）//静态方法

StringBuffer：

是字符串缓冲区（面盆理论，不管怎么向缓冲区中添加，始终还是StringBuffer对象）

是一个容器

StrinbBuffer的特点：

1，长度是可变的（数组不可变）

2，可以直接操作多个数据类型（数组只能操作一个类型）

3，最终会通过toString方法变成字符串

StringBuffer sb=new StringBuffer("abc");
sb.append("d");
sb.delete();sb.replace(1,2,"java");

String和StringBuffer的区别：

String ：一旦被赋值，就不能被改变

StringBuffer：采用的是缓冲区机制，随着数据的增多，还可以继续开辟空间，增大

StringBuffer的初始容量为：16个字符

String和StringBuffer可以通过构造函数进行转换

StringBuffer （String str）StringBuffer构造函数，将字符串转换为StringBuffer

String（StringBuffer sb）String构造函数，将StringBuffer转换为String

StringBuffer常用方法

1、存储

append（）；将数据添加到已有数据的结尾

insert（位置，数据）：将数据插入到指定位置

2、删除

delete（start，end）：删除缓冲区中的数据，包含start，不包含end

deleteCharAt（index）：删除指定位置的字符

3、获取

charAt（位置）：获取指定位置的字符

indexOf（字符串）：获取字符串所在缓冲区的位置

lastIndexOf（字符串）：从右开始，获取字符串所在缓冲区的位置

length（）：获取缓冲区字符串的长度

substring（开始，结束）：从缓冲区中获取指定的开始—结束字符串

4、修改

replace（开始，结束，字符串）：指定要修改的起始位置，结束位置和要修改的字符串

setCharAt（位置，字符）：替换某一个字符

5、翻转

reverse（）

6、将缓冲区中的指定数据存储到指定字符数组中

getChars（开始，结束，目的地的开始）

例：

StringBuffer sb=new StringBuffer("abcd");
char [] arr=new char[ 4 ];
sb.getChars(1,4,arr,1)：将缓冲去中的数据存入到字符数组arr中

JDK1.5之后，出现了StringBuilder

StringBuffer：是线程同步（安全）

StringBuilder：是线程不同步（不安全）

Java的升级三个因素：

1、提高效率

2、提高安全性

3、简化书写

API常用类的方法：

1、Object

toString（）：一般都复写此方法

equals（）：默认比较的是地址值，一般都重写，按照自己的比较方式重写

2、Math

floor（）：小于等于参数的最大整数

ceil（）：大于等于参数的最小整数

round（）：四舍五入，原理：+0.5

random（）产生随机数【0.0 ~ 1.0】

pow（x，y） x的y次方

sqrt（）平方根

3、Random

nextInt（int n）：随机产生【0 ~ n】之间的随机数

4、Scanner

nextInt：从键盘获取Int类型的数据

next：从键盘获取一个数据

5、String

equals（）：判断是否相等

6、StringBuffer：

append（）：添加

insert（）：插入

reverse（）：翻转

7、System

exit（0）：退出

8、Arrays

sort（）：排序

binarySearch（）：二分查找

9、Integer

parseInt（）：转换为Int类型

parseDouble（）：转换为Double类型

淡_漠

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
String、Integer、StringBuffer和API类中的常用方法

String类：String是final类型的（最终类），String类不可以有子类字符串是一个特殊的对象字符串一旦被初始化，就不可以改变 String str1=”abc“ String str2=new String(”abc“) str1和str2的区别：str1在内存中有一个对象
复制链接

扫一扫