一、字符串String的應用
字符串的特點：
1.String s1 = "abc";
s1是一個類類型變量，"abc"是一個對象。
2.字符串最大的特點：一旦被初始化就不可以被改變。
String s2 = new String("abc");
3.s1和s2有什麼區別？
s1在內存中有一個對象。
s2在內存中有兩個對象。(一個是new對象，一個是構造函數中的對象)
4.String類複寫了Object類中的equals方法。
該方法用於判斷字符串是否相同
示例代碼
class StringDemo
{
public static void main(String[] args)
{
String s1 = "abc";
String s2 = new String("abc");
System.out.println(s1 == s2); //結果爲false
System.out.println(s1.equals(s2)); //結果爲true
}
}
/*
String適用於描述字符串事物。
那麼它就提供了多個方法對字符串進行操作。
常見的操作有哪些呢？
1、獲取
1.1 字符串中的包含的字符數，也就是字符串的長度。
int leneth(); 用返回值爲int類型的無參數的函數length();來獲取長度
1.2 根據位置獲取位置上某個字符。
char charAt(int index); 用返回值爲char類型的參數爲int的函數charAt()來獲取某個位置上的字符。
1.3 根據字符獲取該字符在字符串中位置
int indexOf(int ch); 返回值類型爲int，參數爲int類型的函數來獲取字符在字符串中第一次出現的位置
int indexOf(int ch, int fromIndex); 獲取從某個位置(fromIndex)開始，往後某個字符(ch)所在的位置
int indexOf(String str); 返回的是某個子字符串在字符串中第一次出現的位置
int indexOf(String str, int fromIndex); 獲取子字符串從某個位置開始。往後的字符串中第一次出現的位置
int lastIndexOf(int ch); 反向索引。
2、判斷
2.1 字符串中是否包含某一個子串。
boolean contains(str);
特殊之處：indexOf(str);可以索引str第一次出現的位置，如果返回-1，表示該str不在字符串中存在。
所以，也可以用於對指定判斷是否包含某個字符串
示例代碼：
if(str.indexOf("aa") != -1) 假如aa不等於-1就說明存在於字符串中，如果要查包含字符串出現的位置
最好用indexOf
而且該方法既可以判斷，又可以獲取出現位置
2.2 字符串是否有內容。
boolean isEmpty(); 原理就是判斷一下字符串的長度是否爲0。爲0則表示沒有內容
2.3 字符串是否以指定的內容開頭
boolean startsWith(str); 通過該方法判斷是否一此內容開頭。是的話就true。反之爲false
2.4 字符串是否是以指定內容結尾
boolean endsWith(str); 通過該方法判斷是否一此內容結尾。是的話就true。反之爲false
2.5 判斷字符串內容是否相同，複寫了Object類中的equals方法。
boolean equals(str);
2.6 判斷內容是否相同。並忽略大小寫
boolean equalsIgnoreCase();
3.轉換
3.1 將字符數組轉成字符串。
構造函數：String(char[]) 把一個字符數組當成實參傳遞給構造函數String即可
String(char[], offset,count);將字符數組中的一部分轉成字符串。offset(數組的角標起始位);count(把幾個字符轉換成字符串)
靜態方法：
static String copyValueOf(char[]);
static String copuValueOf(char[],offest,count);和構造函數相似
3.2 將字符串轉成字符數組
char[] toCharArray();
3.3 將字節數組轉成字符串。
Sting(byte[]);
String(byte[],offset,count);將自己餓數組的一部分轉成字符串，原理和字符數組轉成字符串相似
3.4 將字符串轉成字節數組
byte[] getBytes();
3.5 將基本數據類型轉換成字符串
static String valueOf(int); //將int類型的數值轉換成字符串
static String valueOf(double); //將double類型的數轉換成字符串
特殊：字符串和字節數組在轉換過程中，是可以編碼表的。
4、替換
String replace(oldChar, newChar); //oldChar要被替換內容，newChar替換舊內容的新內容
5、切割
String[] split(regex); //把字符串切割後，返回類型是字符串數組，regex是要被切割的標記。可以是任意的字符串
6、子串，獲取字符串中的一部分
String substring(begin); //這個的意思是獲取從begin角標開始到字符串結束的所有字符
String substring(begin, end); //這個是獲取從begin到end的字符.注：並不包括end本身所代表的角標位上的字符
7、轉換，去除空格，比較。
7.1 將字符串轉成大寫活小寫。
String toUpperCase(); //把字符串轉換成大寫
String toLowerCase(); //把字符串轉換成小寫
7.2 將字符串兩端的多個空格去除。
String trim(); //調用方法就可以去除空格。
7.3 對兩個字符串進行自然順序的比較
int compareTo(String);
如果參數字符串等於此字符串，則返回值 0；如果此字符串按字典順序小於字符串參數，則返回一個小於 0 的值；
如果此字符串按字典順序大於字符串參數，則返回一個大於 0 的值。
*/
class StringDemo1
{
public static void main(String[] args)
{
//huoQu();
//panDuan();
//zhuanHuan();
//tiHuan();
//qieGe();
//ziChuan();
xue_7();
}
//寫一個轉換，去除空格，比較
public static void xue_7()
{
String s = " Java Exception ";
p(s.toUpperCase()); //轉換成大寫
p(s.toLowerCase()); //轉換成小寫
p(s.trim()); //去除空格
String s1 = "abc";
String s2 = "aaa";
p(s1.compareTo(s2));
}
//寫一個子串的類。也就是子字符串的一部分
public static void ziChuan()
{
String s = "abcdefghij";
String s1 = s.substring(3);
String s2 = s.substring(3, 5); //包含頭，不包含尾
p(s1);
p(s2);
}
//寫一個切割的類。把一個字符串中的名字切割出來
public static void qieGe()
{
String s = "zhang,li,hong";
String[] s1 = s.split(",");
for(int i = 0; i < s1.length; i++)
{
p(s1[i]);
}
}
//寫一個替換的函數
public static void tiHuan()
{
String s = "abcdef";
String s1 = s.replace("ab", "dd");
p(s);
p(s1);
}
//寫一個字符串之間轉換的函數
public static void zhuanHuan()
{
char[] arr = {'a','b','c','d','e','f','g','h','i','j','k'};
//字符數組轉換成字符串
String s1 = new String(arr);
p(s1); //運用構造函數轉換
p(String.copyValueOf(arr, 3, 3)); //運用靜態函數轉換
//字符串轉換成字符數組
char[] chs = s1.toCharArray();
for(int i = 0; i < chs.length; i++)
{
p("chs = " + chs[i]);
}
}
//寫一個判斷字符串的函數
public static void panDuan()
{
String s = "abcdefghijabcd"; //定義字符串
String s1 = "abCdefghijabcd"; //定義字符串
p(s.contains("abc")); //查看字符串s中是否包含子字符串abc
p(s.isEmpty()); //判斷字符串中是否有內容.而且沒有內容返回true。有內容則返回false
p(s.startsWith("abc")); //判斷字符串是否以abc開頭
p(s.endsWith("bcd")); //判斷字符串是否已bcd結尾
p(s.equals(s1)); //判斷兩個字符串是否相同
p(s.equalsIgnoreCase(s1)); //判斷兩個字符串中的內容是否相同
}
//寫一個獲取的函數
public static void huoQu()
{
String s = "abcdefghijabcd"; //定義字符串
p(s.length()); //獲取字符串的長度
p(s.charAt(4)); //獲取某個位置上的字符
p(s.indexOf('a')); //如果有返回位置，沒有則返回-1；
p(s.indexOf('a', 3)); //獲取從角標位置爲3的位置起。往後的字符串中字母a所在的角標位置
p(s.indexOf("abc")); //獲取字符串abc在字符串s中第一次出現的角標位置
p(s.indexOf("abc", 3)); //獲取從角標3往後的字符串中子字符串第一次出現的角標位置
p(s.lastIndexOf('a')); //從後往前面查。查看字符a第一次出現的角標位置。
}
public static void p(Object obj)
{
System.out.println(obj);
}
}
//字符串示例代碼
1.去除空格示例
需求：模擬一個trim方法，去除字符串兩端的空格。
思路：
1，判斷字符串第一個位置是否是空格，如果繼續向下判斷，知道不是空格爲止。
結尾處判斷空格也是如此。
2，當開始和結尾都判斷到不是空格時，就是要獲取的字符串
class MyTrim
{
public static void main(String[] args)
{
String s = " aaa ddd ";
String s1 = MyTrim.myTrim(s);
System.out.println(s); //去掉空格前
System.out.println(s1); //去掉空格後
}
//寫一個屬於我的去掉空格的函數myTrim
public static String myTrim(String str)
{
int start = 0, end = str.length() - 1; //定義前後角標的值
while(start <= end && str.charAt(start) == ' ') //charAt就是獲取字符串一個start位置上的字符
start++;
while(start <= end && str.charAt(end) == ' ')
end--;
//調用substring函數獲取角標值start到end+1的字符。因爲這個獲取方式包含頭不包含尾。所以讓end+1
return str.substring(start, end + 1);
}
}
2.字符串反轉示例
需求：把一個字符串進行反轉
思路：
1.把字符串變成字符數組
2.把字符數組反轉
3.把字符數組變成字符串
class FanZhuanTest
{
public static void main(String[] args)
{
String s = "abcdefghijklmn";
String s1 = FanZhuanTest.reverseString(s);
System.out.println(s);
System.out.println(s1);
}
//定義一個函數對字符串進行反轉
public static String reverseString(String str, int start, int end)
{
char[] chs = str.toCharArray(); //將字符串變成字符數組
reverse(chs, start, end); //調用將字符串數組反轉的函數。並規定反轉字符串的頭和尾
return new String(chs); //用String類的構造函數。將字符數組變成字符串
}
//定義一個只有一個參數的字符串反轉函數
public static String reverseString(String str)
{
return reverseString(str, 0, str.length());
}
//定義字符串反轉的函數
private static void reverse(char[] arr, int start, int end)
{
for(int i = start, j = end - 1; i < j; i++, j--)
{
swap(arr, i, j); //運用swap函數將字符數組中的指定位置的字符反轉
}
}
//定義一個將字符調換的函數
private static void swap(char[] chs, int start, int end)
{
char temp = chs[start];
chs[start] = chs[end];
chs[end] = temp;
}
}
3.獲取子串出現次數的示例
需求：獲取一個字符串在另一個字符串中出現的次數。
"abkkedfkkskka"
思路：
1，定義一個計數器
2，獲取kk第一次出現的位置。
3，從第一次出現位置偶剩餘的字符串中繼續獲取kk出現的位置。
每獲取一次就計數一次。
4，當獲取不到時，技術完成
class ChaZhaoTest
{
public static void main(String[] args)
{
String s = "abkkedfkkskkakk";
System.out.println(getSubString(s, "kk"));
}
//獲取一個子字符串在字符串中出現的次數 方法一
public static int getSubString(String str, String key) //str要傳入的參數字符串 key要被查找的字符串
{
int count = 0; //計數器
int index = 0; //記錄角標位
while((index = str.indexOf(key))!= -1) //str.indexOf(key)是查找要被查找的字符串的起始位，只要不等於-1就代表裏面還有字符
{
count++; //記錄出現的次數
//substing獲取一個從index+key.length()角標位開始的子字符串
str = str.substring(index + key.length());
}
return count;
}
//獲取一個子字符串在字符串中出現的次數 方法二
public static int getSubString_1(String str, String key)
{
int count = 0; //計數器
int index = 0; //記錄角標位
while((index = str.indexOf(key, index)) != -1) //indexOf(key, index)key代表要被查找的字符串。index代表下一個角標位的開始角標位
{
index = index + key.length(); //index是要查找字符串的起始位。計算key字符串的長度。並加上查找字符串的起始位
count++;
}
return count;
}
}
4.獲取最大相同子串示例
需求：獲取兩個字符串中最大相同子串，第一個動作，將短的那個串進行長度依次遞減的子串打印
"abcwertherlloyuiodef"
"vhelloobn"
思路:
1，將短的的那個子串按照長度依次遞減的方式獲取到。
2，將每獲取到的子串去長串中判斷是否包含。
如果包含，已經找到
class XTZiChuanTest
{
public static void main(String[] args)
{
String s1 = "abcwerthelloyuiodef";
String s2 = "vhelloobn";
String s3 = "zq";
System.out.println(getMaxSubString(s1, s3));
}
//寫一個判斷兩個字符串中最大子串的函數
public static String getMaxSubString(String str, String key)
{
String max, min;
max = (str.length() > key.length()) ? str : key;
min = (max == str) ? key : str;
for(int i = 0; i < min.length(); i++) //依次遍歷短的的字符串
{
//j代表短字符串的開頭角標，z代表結尾角標，因爲取子串包含頭不包含尾，所以z的長度不需要減1，
//判斷條件爲只要j不大於短字符串的長度就可以 繼續往下運算
//z = min.lenth() - i;代表短字符串的長度在依次遞減
//因爲字符串是隨着循環的次數而依次遞減。所以z要自增，直到等於短字符串的長度就結束循環
for(int j = 0, z = min.length() - i; z != min.length() + 1; j++, z++)
{
String temp = min.substring(j, z); //取出起始角標爲j,結束角標爲z的子串並賦值給變量temp；
if(max.contains(temp)) //判斷取出來的子串是否屬於長的字符串
return temp; //屬於長的字符串就把該子串反出去
}
}
return "兩個字符串沒有相同子串";
}
}二、容器StringBuffer的使用
StringBuffer是一個字符串緩衝區。
也可以說成是一個容器
特點：
1。它的長度是可變化的
2.可以直接操作多個數據類型。
3，最終會通過toString方法變成字符串
1,存儲。
StringBuffer append(); //將指定的數據作爲參數添加到已有數據結尾處。
StringBuffer insert(index, 數據); //可以將數據插入到指定的index位置
2,刪除。
StringBuffer delete(start, end) 刪除緩衝區中的數據。包含start，不包含恩end.
StringBuffer deleteCharAt(index) 刪除指定位置的字符
3,獲取。
char charAt(int Index) 獲取緩衝區中指定位置的字符
int indexOf(String str) 返回一個字符串在字符串中第一次出現的角標位
int lastIndexOf(String str) //返回最右邊出現的指定子字符串在此字符串中的位置
int length(); 獲取緩衝區的長度
String substring(int start, int end) 獲取緩衝區中從start開始到end結束的字符串(但是字符串並不包括end角標上的)
4,修改。
StringBuffer replace(start, end, string) start替換內容的開始角標位，end替換內容的結束角標位(但並不包括end),string(要替換進去的內容)
5,反轉
StringBuffer reverse(); //調用此函數就可以把字符串反轉過來
6，將緩衝區中指定數據存儲到指定字符數組中
void getChars(int sreBegin, int srcEnd, char[] dst, int dstBegin)
sreBegin 要被提取出來的字符的角標位開始角標
srcEnd 要被提取出來的字符的角標位結束角標
dst 要把字符存進的字符數組
dstBegin 提取出來的字符從數組的那個位置開始存儲
class StringBufferDemo
{
public static void main(String[] args)
{
//add(); //調用添加函數
//delete();
//update();
//xiuGai();
//fanZhuan();
charAdd();
}
//寫一個把緩衝區中的數據存儲到指定位置的字符數組
public static void charAdd()
{
StringBuffer s = new StringBuffer("abdedabdffd"); //定義一個容器
char[] a = new char[5];
s.getChars(1, 4, a, 1); //將字符串中角標位1到角標爲4(但是不包括4)的數據存儲到字符數組中從1角標開始往後存儲
for(int i = 0; i < a.length; i++)
{
p("a[" + i + "]" + a[i]);
}
}
//寫一個反轉緩衝區的函數
public static void fanZhuan()
{
StringBuffer s = new StringBuffer("abdedabdffd"); //定義一個容器
p(s); //打印字符串反轉前
StringBuffer ss = s.reverse(); //把字符串反轉
p(ss); //打印反轉後
}
//寫一個修改緩衝區內容的函數
public static void xiuGai()
{
StringBuffer s = new StringBuffer("abdedabdffd"); //定義一個容器
StringBuffer ss = s.replace(3, 4, "aa");
p(ss);
}
//寫一個獲取的函數
public static void update()
{
StringBuffer s = new StringBuffer("abdedabdffd"); //定義一個容器
char s1 = s.charAt(3); //獲取指定位置的字符
int i = s.indexOf("ag"); //返回一個字符串在字符串中第一次出現的角標位
int ii = s.lastIndexOf("ff"); //返回最右邊出現的指定子字符串在此字符串中的位置
String ss = s.substring(3,6); //獲取緩衝區中從start開始到end結束的字符串(但是字符串並不包括end角標上的)
p(ss);
}
//寫一個刪除函數
public static void delete()
{
StringBuffer s = new StringBuffer("abdedagdffd"); //定義一個容器
//StringBuffer s1 = s.delete(1, 3);
StringBuffer s2 = s.deleteCharAt(4);
//p(s1.toString());
p(s2.toString());
}
//寫一個添加函數
public static void add()
{
StringBuffer s = new StringBuffer(); //定義一個容器
StringBuffer s1 = s.append("a");
StringBuffer s2 = s.append("bbbb");
p("s = " + s.toString()); //加上toString把s變成字符串
p("s1 = " + s1.toString());
p("s2 = " + s2.toString()); //其實所有的StringBuffer對象指向的都是同一個對象
}
public static void p(Object obj)
{
System.out.println(obj);
}
}---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Unity開發</a>、<a href="http://edu.csdn.net"target="blank">.Net培訓</a>、期待與您交流！ ----------------------
詳細請查看：<a href="http://edu.csdn.net" target="blank">http://edu.csdn.net</a>