------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
String类
基本概念:
字符串最大特点:一旦被初始化就不可以被改变。
public class StringDemo {
public static void main(String[] args) {
String s1 = "abc";//s1是一个类类型变量, "abc"是一个对象。
s1 = "kkk";
System.out.println(s1);
//虽然此处会输出kkk,但是并不是abc字符串变了,而是s1变了,指向了新的字符串常量kkk。abc这个对象的内容并未改变
String s2 = new String("kkk");//String构造函数中有一个可以传字符串的构造函数
/*s1和s2有什么区别:虽然使用起来一样,但:
s1在内存中有一个对象。
s2在内存中有两个对象。
*/
System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2));//true
//String类复写了Object类中的equals方法,该方法用于判断字符串是否相同。
//Object类中原来的equals方法是用来比较内存中的地址值的。
}
}
常用操作方法:
获取
1,字符串长度
int length()
2,位置->字符
char charAt(int index):
3,字符->位置
int length()
2,位置->字符
char charAt(int index):
3,字符->位置
int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始,获取ch在字符串中出现的位置。int lastIndexOf(int ch) :返回ch在字符串中最后一次出现的位置。
4,子串->位置
int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexOf(String str, int fromIndex) :从fromIndex指定位置开始,获取str在字符串中出现的位置。
int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexOf(String str, int fromIndex) :从fromIndex指定位置开始,获取str在字符串中出现的位置。
4,位置->子串
String substring(begin)String substring(begin,end)
<pre name="code" class="java">package String;
class StringMethodDemo
{
public static void method_get()
{
String str = "abcdeatpf";
//长度
sop(str.length());//输出:9
//位置->字符。
sop(str.charAt(4));//输出:e,说明从0开始
//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。
//字符->位置
sop(str.indexOf('m',3));//输出:-1
//如果没有找到,返回-1.
//反向字符->索引
sop(str.lastIndexOf("a"));//输出:5
//子串->位置。
sop(str.indexOf("eat",2));//输出:4
//从该字符串的第3位开始找eat这个子串,返回的是eat子串的第一个字符的位置
//位置->子串
sop(str.substring(3, 4));//输出:d(包含头,不包含尾)str.substring(0,str.length())可获得整个字符串
sop(str.substring(3,8));//输出:deatp
}
public static void main(String[] args)
{
method_get();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
判断
1,有无子串?
boolean contains(str):(既要判断又要拿位置用str.indexof("str"))
2,有无内容?
boolean isEmpty(): 原理就是判断长度是否为0.
3,是否以指定内容开头或结尾?
boolean startsWith(str);boolean endsWith(str);
4,内容是否相同?
boolean equals(str);(复写了Object类中的equals方法。)boolean equalsIgnoreCase();(忽略大小写的判断)
package String;
class StringMethodDemo
{
public static void method_is()
{
String str = "ArrayDemo.java";
String str2 = "ARRAYDEMO.JAVA";
//有无内容?
sop(str.isEmpty());//false
//有无子串?
sop(str.contains("java"));//true//如果有一个文件Demo.java.txt,contains返回true,而endsWith返回false
//判断文件名称是否是Array单词开头。
sop(str.startsWith("Array"));//true
//判断文件名称是否是.java的文件。
sop(str.endsWith(".java"));//true
//内容是否相同?
sop(str.equals(str2));//false
sop(str.equalsIgnoreCase(str2));//true
}
public static void main(String[] args)
{
method_is();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
转换
1,字符数组->字符串
构造函数:String(char[]) 字符串初始化时就可以使用String的构造函数将字符数组转成字符串String(char[],offset,count)将字符数组中的一部分转成字符串。静态方法:static String copyValueOf(char[])static String copyValueOf(char[] data, int offset, int count)static String valueOf(char[])
2,字符串->字符数组。
char[] toCharArray()
3,字节数组->字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串。
4,字符串->字节数组
byte[] getBytes()
5,基本数据类型->字符串。
static String valueOf(int)static String valueOf(double)
特殊:字符串和字节数组在转换过程中,是可以指定编码表的。
package String;
class StringMethodDemo
{
public static void method_trans()
{
//字符数组->字符串
char[] arr = {'a','b','c','d','e','f'};
//直接全部转
String c2a_1 = new String(arr);
sop("s = " + c2a_1);//输出:s = abcdef
//转指定位置的一部分
String c2a_2 = new String(arr,1,3);
sop("s = " + c2a_2);//输出:s = bcd
//使用静态方法copyValueOf
String sta_c2a = String.copyValueOf(arr);//此处使用valueOf(arr)效果一致,但valueOf还能将基本数据类型转成字符串
sop("s = " + sta_c2a);
//字符串->字符数组
String s1 = "zxcvbnm";
//转换
char[] chs = s1.toCharArray();
//打印
for(int x = 0; x < chs.length; x++)
{
sop("ch="+chs[x]);
}
/*
ch=z
ch=x
ch=c
ch=v
ch=b
ch=n
ch=m
*/
//字符串->字节数组
String s2 = "zdf32432";
//转换
byte[] bytes = s2.getBytes();//byte[]不能写成Byte[]
//打印
for(int x = 0; x < bytes.length; x++){
sop("byte = " + bytes[x]);
}
/*
byte = 122
byte = 100
byte = 102
byte = 51
byte = 50
byte = 52
byte = 51
byte = 50
*/
}
public static void main(String[] args)
{
method_trans();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
替换
String replace(oldchar,newchar)
String replace(CharSequence target, CharSequence replacement)
package String;
class StringMethodDemo
{
public static void method_replace()
{
String s = "hello java";
String s2 = s.replace('q','n');//如果要替换的字符不存在,返回的还是原串。
sop("s2 = " + s2);//输出:s2 = hello java
String s1 = s.replace("java","world");
sop("s = "+s);//字符串一旦初始化不会被改变。输出:s = hello java
sop("s1 = "+s1);//输出:s1 = hello world
}
public static void main(String[] args)
{
method_replace();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
切割
String[] split(regex);
class StringMethodDemo
{
public static void method_split()
{
String s = "zhagnsa,lisi,wangwu";
String[] arr = s.split(",");//定义了一个字符串数组,根据逗号切割s字符串,逗号作为切割符
//把切割完的字符串子串分别存到该字符串数组中
for(int x = 0; x < arr.length; x++)
{
sop(arr[x]);//打印该数组
/*
zhagnsa
lisi
wangwu
*/
}
}
public static void main(String[] args)
{
method_split();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
处理与比较
1,大写<->小写。
String toUpperCase()String toLowerCase()
2,去除两端的多个空格
String trim()
3,对两个字符串进行自然顺序的比较。
int compareTo(string)
package String;
class StringMethodDemo
{
public static void method_others()
{
String s = " Hello Java ";
//大写 <-> 小写
sop(s.toLowerCase());//输出:" hello java "
sop(s.toUpperCase());//输出:" HELLO JAVA "
//去除空格
sop(s.trim());//输出:"Hello Java"
//比较
String s1 = "a1c";
String s2 = "aaa";
String s3 = "abc";
/*
小于返回负数,大于返回正数
*/
sop(s1.compareTo(s2));//输出:-48(1是49,a是97,此处第一位一样,然后从第二位开始比较)
sop(s2.compareTo(s3));//输出:-1
sop(s3.compareTo(s2));//输出:1(a是97,b是98,b比a大1,所以abc比aaa大1)
}
public static void main(String[] args)
{
method_others();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
字符串常用操作方法的应用
模拟trim方法
package String;
class StringTest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = " ab cd ";
sop("("+s+")");//输出:( ab cd )
s = myTrim(s);
sop("("+s+")");<span style="font-family: Arial, Helvetica, sans-serif;">//输出:(ab cd)</span>
}
public static String myTrim(String str)
{
int start = 0,end = str.length()-1;//因为脚标是从0开始的,最末尾的元素的脚标是"长度-1"
while(start <= end && str.charAt(start) == ' ')//当str的值为""时,start == end
start++;
while(start <= end && str.charAt(end) == ' ')
end--;
return str.substring(start,end+1);//取的时候包含头,不包含尾,如果要把end处的元素也取入,需要end加1
}
}
将字符串进行反转
思路:
1,将字符串变成数组。
2,对数组反转。
3,将数组变成字符串。
1,将字符串变成数组。
2,对数组反转。
3,将数组变成字符串。
class StringTest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = "012345";
sop("("+s+")");//输出:(012345)
sop("("+reverseString(s)+")");//输出:(543210)
sop("("+reverseString(s,0,2)+")");//输出:(102345) 012->102,说明转的范围不包含尾,因为一般尾代表是整个长度,比最后脚标大1
sop("("+reverseString(s,1,4)+")");//输出:(032145) 1234 -> 3214
}
public static String reverseString(String s,int start,int end)//倒转指定部分
{
//1,字符串变数组
char[] chs = s.toCharArray();//存在名为chs的字符数组中
//2,反转数组
reverse(chs,start,end);
//3,将数组变成字符串。
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)
{
for(int start = x,end = y-1; start < end ; start++,end--)//整个倒转时的写法:start = 0, end = arr.length -1
{
swap(arr,start,end);//end代表最后一个脚标
}
}
获取一个字符串在另一个字符串中出现的次数
思路:
1,定义个计数器。
2,获取子串第一次出现的位置。
3,从第一次出现位置后剩余的字符串中继续获取子串出现的位置。每获取一次就计数一次。
4,当获取不到时,计数完成。
1,定义个计数器。
2,获取子串第一次出现的位置。
3,从第一次出现位置后剩余的字符串中继续获取子串出现的位置。每获取一次就计数一次。
4,当获取不到时,计数完成。
package String;
class StringTest2
{
//练习三, 方法一:"kk"所截子串的脚标
public static int getSubCount(String str,String key)
{
int count = 0;//初始化一个计数器
int index = 0;//记录索引的值
while((index = str.indexOf(key))!=-1)//index[0] = 0;
{
sop("str="+str);
str = str.substring(index+key.length());
//根据子串的起始位置返回子串。第一次是str.substring(0 + 2),从脚标2开始返回,包含头
count++; //计数器加1,记录获得到的子串个数
}
return count;
}
//练习三,方法二:仅跳"kk"的脚标
public static int getSubCount_2(String str,String key)
{
int count = 0;
int index = 0;
while((index = str.indexOf(key,index))!=-1)//对比:while((index = str.indexOf(key))!=-1)
{
sop("index = " + index);//对比:sop("str="+str);
index = index + key.length();//对比:str = str.substring(index+key.length());
//System.out.println(str.indexOf("kk", 2)),结果是4,含义是第二次出现kk时的脚标的值是4
count++;
}
return count;
}
public static void main(String[] args)
{
String str = "kkabkkcdkkefkks";
///sop("count====="+str.split("kk").length);不建议使用。
sop("count = " + getSubCount(str,"kk"));
/*
str=kkabkkcdkkefkks
str=abkkcdkkefkks
str=cdkkefkks
str=efkks
count = 4
*/
sop("count="+getSubCount_2(str,"kk"));
/*
index=0
index=4
index=8
index=12
count=4
*/
}
public static void sop(String str)
{
System.out.println(str);
}
}
求两个字符串最大相同的子串
思路:
1,将短的那个子串按照长度递减的方式获取到。
2,将每获取到的子串去长串中判断是否包含,如果包含,已经找到。
1,将短的那个子串按照长度递减的方式获取到。
2,将每获取到的子串去长串中判断是否包含,如果包含,已经找到。
package String;
class StringTest3
{
/*
练习四。
*/
public static String getMaxSubString(String s1,String s2)
{
String max = "",min = "";//初始化了两个变量max和min
//以下语句是为了让max是s1,min是s2
max = (s1.length()>s2.length())?s1: s2;
min = (max==s1)?s2: s1;
// sop("max="+max+"...min="+min);
/*
0到length-0:1
0到length-1:11
0到length-2:111
0到length-3:1111
*/
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);
/*
sop(temp)的输出结果:
cvhellobnm
cvhellobn
vhellobnm
cvhellob
vhellobn
hellobnm
cvhello
vhellob
hellobn
ellobnm
cvhell
vhello
hellob
ellobn
llobnm
cvhel
vhell
hello
*/
//这句语句的意思是,如果长的字符串中含有短的字符串中截取出的最大的子串,则返回该子串
if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
return temp;
}
}
return "";//从debug情况看,此处的return并没有执行到,在内循环时,已经return了temp,这里写null也没事
}
public static void main(String[] args)
{
String s1 = "abcwerthelloyuiodef";
String s2 = "cvhellobnm";
sop(getMaxSubString(s2,s1));
}
public static void sop(String str)
{
System.out.println(str);
}
}
StringBuffer
基本概念
StringBuffer是字符串缓冲区,是一个容器。
特点:
1,长度是可变化的。2,可以直接操作多个数据类型。3,最终会通过toString方法变成字符串。
C create 增 U update 改 R read 查D delete删
常用操作方法
增加:
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。
StringBuffer insert(index,数据):可以将数据插入到指定index位置。
StringBuffer insert(index,数据):可以将数据插入到指定index位置。
尝试1:在StringBuffer中添加元素
因为sb和sb1都是指向同一个对象,没有必要通过这种方式来添加元素
class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb = new StringBuffer();
StringBuffer sb1 = sb.append(34);
sop(sb.toString());//34
sop(sb1.toString());//34
sop("sb == sb1: " + (sb == sb1));//sb == sb1: true
//sb 和 sb1 指向同一个对象,盆还是那个盆
}
public static void sop(String str)
{
System.out.println(str);
}
}
改进:
package String;
class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb = new StringBuffer();
//append方法
sb.append("abc").append(34).append(true);//方法调用链,因为sb.append("abc")方法执行之后,返回的还是本类的对象
sop(sb.toString());//输出:abc34true,将指定数据作为参数添加到已有数据结尾处。
//StringBuffer sb1 = sb.append(34);
//insert方法
sb.insert(1, "bac");
sop(sb.toString());//输出:abacbc34true,插入在1脚标位置,其后顺延
}
public static void sop(String str)
{
System.out.println(str);
}
}
删除:
StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end。StringBuffer deleteCharAt(index):删除指定位置的字符。
package String;
class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb = new StringBuffer("abcde");
sop(sb.toString());//输出:abcde
//delete(start,end)
sb.delete(1,3);
sop(sb.toString());//输出:ade
//脚标从1开始,1、2的元素被删除。包含头,不包含尾。
//清空缓冲区:sb.delete(0,sb.length());
//sb.delete(2,3);//StringIndexOutOfBoundsException
//deleteCharAt(index)
sb.deleteCharAt(2);
sop(sb.toString());//输出:ad
//脚标为2的字符被删除
}
public static void sop(String str)
{
System.out.println(str);
}
}
获取:
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start, int end) :该方法返回的是String,而不是StringBuffer
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start, int end) :该方法返回的是String,而不是StringBuffer
该部分内容与String中获取的用法一致
修改:
StringBuffer replace(start,end,string);void setCharAt(int index, char ch) ;
class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb = new StringBuffer("abcde");
//replace(start,end,string);
sb.replace(1,4,"java");//不包含尾,则脚标从1-3的三个元素bcd被替换成了java
sop(sb.toString());//输出:ajavae
//setCharAt(int index, char ch) ;
sb.setCharAt(2,'k');//脚标为2的元素替换为k,该方法不返回StringBuffer,替换完就结束
sop(sb.toString());//输出:ajkvae
}
public static void sop(String str)
{
System.out.println(str);
}
}
反转:
StringBuffer reverse();class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb = new StringBuffer("abcde");
//StringBuffer reverse();
sb.reverse();
sop(sb.toString());//输出:edcba
}
public static void sop(String str)
{
System.out.println(str);
}
}
特殊增加:
将缓冲区中指定数据存储到指定字符数组中
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
class StringBufferDemo
{
public static void main(String[] args)
{
StringBuffer sb = new StringBuffer("abcde");
char[] chs = new char[6];
sb.getChars(1,4,chs,1);//把abcde中1-3脚标对应的字符,在chs字符数组中脚标为1的位置插入存储
for(int x = 0; x < chs.length; x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
/*
chs[0]=
chs[1]=b;
chs[2]=c;
chs[3]=d;
chs[4]=
chs[5]=
*/
}
public static void sop(String str)
{
System.out.println(str);
}
}
StringBuilder
JDK1.5 版本之后出现了StringBuilder.
StringBuffer和StringBuilder区别:
StringBuffer和StringBuilder区别:
StringBuffer是线程同步。StringBuilder是线程不同步。
以后开发,建议使用StringBuilder
基本数据类型包装类
基本概念
将基本数据类型封装成对象的好处,在于可以在对象中定义更多的功能方法操作该数据。
byte
Byte
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
常用方法
基本数据类型转字符串
/*
基本数据类型 + ""
基本数据类型.toString(基本数据类型值);
*/
34 + "";
Integer.toString(34);//将34整数变成"34";
字符串转基本数据类型
//xxx a = Xxx.parseXxx(String);静态转换方式
int a = Integer.parseInt("123");
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
//先把字符串或者整数封装成Interger对象,然后用intValue返回该Interger的值
Integer i = new Integer("123");
int num = i.intValue();//intValue:以int类型,返回该Interger的值