——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-
字符串是一个特殊的对象
它最大的特点是一旦初始化就不可以被改变
String类是对字符串事物的描述。
该类定义了专门用于操作字符串的方法。
String s1 = “abc”;
String s2 = new String(“abc”);
s1和s2有什么区别?
s1在内存中有一个对象。
s2在内存中有两个对象
字符串常用的方法:
1,获取。
(1) 字符串中的包含的字符数,也就是字符串的长度。
int length():获取长度。
(2) 根据位置获取位置上某个字符。
char charAt(int index):
(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,判断。
(1) 字符串中是否包含某一个子串。
boolean contains(str):
indexOf(str):可以索引str第一次出现位置,如果返回-1.表示该str不在字符串中存在。
所以,也可以用于对指定判断是否包含。
if(str.indexOf(“aa”)!=-1)
而且该方法即可以判断,还可以获取出现的位置。
(2) 字符中是否有内容。
boolean isEmpty(): 原理就是判断长度是否为0.
(3) 字符串是否是以指定内容开头。
boolean startsWith(String str);
(4) 字符串是否是以指定内容结尾。
boolean endsWith(String str);
(5) 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(String str);
(6) 判断内容是否相同,并忽略大小写。
boolean equalsIgnoreCase();
3,转换。
(1) 将字符数组转成字符串。
构造函数: new String(char[])
new String(char[],int offset,int count):将字符数组中的一部分转成字符串。
静态方法:
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[]):
(2) 将字符串转成字符数组。
char[] toCharArray():
(3) 将字节数组转成字符串。
new String(byte[])
new String(byte[],int offset,int count):将字节数组中的一部分转成字符串。
(4) 将字符串转成字节数组。
byte[] getBytes():
(5) 将基本数据类型转成字符串。
static String valueOf(int i)
static String valueOf(double d)
//3+”“;//String.valueOf(3);
字符串和字节数组在转换过程中,是可以指定编码表的。
4,替换
String replace(char oldchar,char newchar);
5,切割
String[] split(String regex);
6,子串。获取字符串中的一部分。
String substring(int begin);
String substring(int begin,int end);
7,转换,去除空格,比较。
(1) 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
(2) 将字符串两端的多个空格去除。
String trim();
(3) 对两个字符串进行自然顺序的比较。
int compareTo(String str);
需求:获取一个字符串在另一个字符串中出现的次数。
“abkkcdkkefkkskk”
思路:
获取目标子串在字符串中出现的次数
1.定义一个计数器
2.在子串存在情况下,获取子串
3.记录可以获取子串的次数
//通过获取子串的次数
class StringTest2
{
public static int getSubCount(String str,String key)
{
int count = 0;
int index = 0;
while((index=str.indexOf(key))!=-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();//从key值出现后的下一个位置再次寻找
count++;
}
return count;
}
public static void main(String[] args)
{
String str = "kkabkkcdkkefkks";
sop("count="+getSubCount_2(str,"kk"));
}
public static void sop(String str)
{
System.out.println(str);
}
}
获取两个字符串中相同的最大子串
“aseivnjfsworlddhgh” “dfjworldecd”
遍历较小的那个字符串,一个个的减少然后和较大的比较
需要把较小的字符串按顺序从最多的子串到最少的子串都要遍历到,然后取相同的部分
0-s.length() 1个 1
0-s.length()-1 2个 11
0-s.length()-2 3个 111
0-s.length()-3 4个 1111
for嵌套循环,外循环是整个长度,内循环有两个变量一个为0,另一个为length()-x
class Test
{
public static String getSubString(String s1,String 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++ )//y-z为满足规定长度的字符串的首尾的角标
{
String s = min.substring(y,z);
// sop(s);
if(max.contains(s))
return s ;
}
}
return "没有相同的字符串";//若return s执行,这句话就不会执行,程序直接停止了
}
public static void main(String[] args)
{
String s1 = "dfjworldecd";
String s2 = "aseivnjfsworlddhgh";
sop(getMaxSubString(s2,s1));
}
public static void sop(String str)
{
System.out.println(str);
}
}
基本数据类型对象包装类
int Integer
short Short
long Long
char Character
double Double
float Float
boolean Boolean
byte Byte
1.基本数据类型转换为字符串
基本数据类型+”“;
Integer.toString(int i);
Long.toString(long l);
Short.toString(short s);
Character.toString(char c);
Byte.toString(byte b);
Double.toString(double d);
Boolean.toString(boolean boo);
Float.toString(float f);
2.字符串转为基本数据类型
Integer.parseInt(“123”); 123
Long.parseLong(“123”); 123
Short.parseShort(“123”); 123
Byte.parseByte(“123”); 123
Double.parseDouble(“12.31”);12.31
Float.parseFloat(“12.31”); 12.31
Boolean.parseBoolean(“true”);true
注意:Character类不具备此功能,因为其本身就是字符
3.十进制转其他进制
Integer.toBinaryString(60); 十进制转二进制
Integer.toHexString(60); 十进制转十六进制
Integer.toOctalString(60); 十进制转八进制
4.其他进制转十进制
Integer.parseInt(“110”,2); 将二进制的110转为十进制
Integer.parseInt(“74”,8); 将八进制的74转为十进制
Integer.parseInt(“60”,10); 将十进制的60转为十进制
Integer.parseInt(“3c”,16); 将十六进制的3c转为十进制
正则表达式:符合一定规则的表达式
作用:用于专门操作字符串
特点:用于一些特定的符号来表示一些代码操作。这样就简化书写
所以学习正则表达式,就是在学些特殊符号的使用
好处:可以简化对字符串的复杂操作
弊端:符号定义越多,正则越长,阅读性越差
具体功能:
1.匹配:String matches方法,用规则匹配整个字符串,只要有一处不符合规则,就匹配结束,返回false
2.切割:String split();
3.替换:String replaceAll(regex,str);如果regex中有定义组,可以在第二参数中通过$符号获取正则表达式中的已有的组。
4.获取:将字符串中的符合规则的子串取出
class RegexDemo
{
public static void main(String[] args)
{
checkTel();
splitDemo("zb,cd,ef",",");//按逗号切割
splitDemo("zb cd hf ge"," +");//按多个空格切割
splitDemo("ab.de.gj.jejje.gd","\\.");//按.切割 正则表达式里的 \. 才表示 . 所以要先用转义字符\将\转义
splitDemo("c:\\abc\\2.txt","\\\\");//按\\切割 java里面的\\都是成对出现的,因为转义字符
splitDemo("abccdessghddfg","(.)\\1");//按叠词切割 . 表示任意字符
splitDemo("vfhhjfiiidessdppppahdhjh","(.)\\1+");//按一个或一个以上的叠词切割
/*
按叠词完成切割
为了可以让规则的结果被重用,可以将规则封装成一个组,用()完成
组的出现都有编号,从1开始,想要使用自己的组可以通过\n(n就是组的编号)的形式获取
(.)\\1 第一位定义的组在第二位再一次的出现了,后一位和前一位的结果是一样的
*/
String str = "gsajg656254144hgueeu1234djgk6789";//将数字替换成*;
eplace(str,"\\d{1,}","*");
String s = "ssdfjjjiwtuossssuwyruydddddtcnfg";//将叠词替换成一个字符
replace(s,"(.)\\1+","#");
String s2 = "ssdfjjjiwtuossssuwyruydddddtcnfg";//将重叠的字符替换成单个字符 如:dddd-->d
replace(s2,"(.)\\1+","$1"); //用$获取组
}
//替换
public static void replace(String str, String regex, String newele)
{
str = str.replaceAll(regex,newele);
System.out.println(str);
}
//切割
public static void splitDemo(String str , String regex)
{
String[] arr = str.split(regex);
for(String s : arr)
{
System.out.println(s);
}
}
/*
需求:
校验一个手机号
13xxxx 15xxxxx 16xxxx 18xxxxx 十一位
*/
//匹配:
public static void checkTel()
{
String tel = "18111211111";
String regex = "1[3568]\\d{9}";
boolean b = tel.matches(regex);
if(b)
System.out.println(tel);
else
System.out.println("不是电话号码");
}
}
获取:将字符串中的符合规则的子串取出。
操作步骤:
1,将正则表达式封装成对象。
2,让正则对象和要操作的字符串相关联。
3,关联后,获取正则匹配对象。
4,通过引擎对符合规则的子串进行操作,比如取出。
import java.util.regex.*;
class RegexDemo2
{
public static void main(String[] args)
{
getDemo();
}
public static void getDemo()
{
String str = "hao xiang qu hei ma xue xi bian cheng";
System.out.println(str);
String reg = "\\b[a-z]{2}\\b";// \\b是单词的边界
//将规则封装成对象。
Pattern p = Pattern.compile(reg);
//让正则对象和要作用的字符串相关联。获取匹配器对象。
Matcher m = p.matcher(str);
//将规则作用到字符串上,并进行符合规则的子串查找
while(m.find())
{
//获取匹配后结果。
System.out.println(m.group());
}
}
}