------<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=)