------<ahref="http://www.itheima.com" target="_blank" rel="external nofollow" 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 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在字符串中出现的位置。
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，将数组变成字符串。
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，当获取不到时，计数完成。
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，将每获取到的子串去长串中判断是否包含，如果包含，已经找到。
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位置。
尝试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
该部分内容与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是线程不同步。
以后开发，建议使用StringBuilder
基本数据类型包装类
基本概念
将基本数据类型封装成对象的好处，在于可以在对象中定义更多的功能方法操作该数据。
byte Byte
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的值
![Java小案例——随机数猜测随机数猜测[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)