黑馬程式員--字元串以及字元串緩沖區

字元串以及字元串緩沖區

String字元串：★★★

java中用String類進行描述。對字元串進行了對象的封裝。這樣的好處是可以對字元串這種常見資料進行友善的操作。對象封裝後，可以定義N多屬性和行為。

如何定義字元串對象呢？String s = "abc";隻要是雙引号引起的資料都是字元串對象。

特點：字元串一旦被初始化，就不可以被改變，存放在方法區中的常量池中。

------------------------------------------------------

String s1 = "abc"; // s1指向的記憶體中隻有一個對象abc。

String s2 = new String("abc"); // s2指向的内容中有兩個對象abc、new 。

System.out.println(s1==s2);//false

System.out.println(s1.equals(s2));//true ，字元串中equals比較的是字元串内容是否相同。

-------------------------------------------------------

字元串的方法：

1：構造方法：将位元組數組或者字元數組轉成字元串。

String s1 = new String();//建立了一個空内容的字元串。

String s2 = null;//s2沒有任何對象指向，是一個null常量值。

String s3 = "";//s3指向一個具體的字元串對象，隻不過這個字元串中沒有内容。

//一般在定義字元串時，不用new。

String s4 = new String("abc");

String s5 = "abc"; 一般用此寫法

new String(char[]);//将字元數組轉成字元串。

new String(char[],offset,count);//将字元數組中的一部分轉成字元串。

2：一般方法：

按照面向對象的思想：

2.1 擷取：

2.1.1：擷取字元串的長度。length();

2.1.2：指定位置的字元。char charAt(int index);

2.1.3：擷取指定字元的位置。如果不存在傳回-1，是以可以通過傳回值-1來判斷某一個字元不存在的情況。

int indexOf(int ch);//傳回第一次找到的字元角标

int indexOf(int ch,int fromIndex); //傳回從指定位置開始第一次找到的角标

int indexOf(String str); //傳回第一次找到的字元串角标

int indexOf(String str,int fromIndex);

int lastIndexOf(int ch);

int lastIndexOf(int ch,int fromIndex);

int lastIndexOf(String str);

int lastIndexOf(String str,int fromIndex);

2.1.4：擷取子串。

String substring(int start);//從start位開始，到length()-1為止.

String substring(int start,int end);//從start開始到end為止。//包含start位，不包含end位。

substring(0,str.length());//擷取整串

2.2 判斷：

2.2.1：字元串中包含指定的字元串嗎？

boolean contains(String substring);

2.2.2：字元串是否以指定字元串開頭啊？

boolean startsWith(string);

2.2.3：字元串是否以指定字元串結尾啊？

boolean endsWith(string);

2.2.4：判斷字元串是否相同

boolean equals(string);//覆寫了Object中的方法，判斷字元串内容是否相同。

2.2.5：判斷字元串内容是否相同，忽略大小寫。

boolean equalsIgnoreCase(string) ;

2.3 轉換：

2.3.1：通過構造函數可以将字元數組或者位元組數組轉成字元串。

2.3.2：可以通過字元串中的靜态方法，将字元數組轉成字元串。

static String copyValueOf(char[] );

static String copyValueOf(char[],int offset,int count);

static String valueOf(char[]);

static String valueOf(char[],int offset,int count);

2.3.3：将基本資料類型或者對象轉成字元串。

static String valueOf(char);

static String valueOf(boolean);

static String valueOf(double);

static String valueOf(float);

static String valueOf(int);

static String valueOf(long);

static String valueOf(Object);

2.3.4：将字元串轉成大小寫。

String toLowerCase();

String toUpperCase();

2.3.5：将字元串轉成數組。

char[] toCharArray();//轉成字元數組。

byte[] getBytes();//可以加入編碼表。轉成位元組數組。

2.3.6：将字元串轉成字元串數組。切割方法。

String[] split(分割的規則-字元串);

2.3.7：将字元串進行内容替換。注意：修改後變成新字元串，并不是将原字元串直接修改。

String replace(oldChar,newChar);

String replace(oldstring,newstring);

2.3.8： String concat(string); //對字元串進行追加。

String trim();//去除字元串兩端的空格

int compareTo();//如果參數字元串等于此字元串，則傳回值 0；如果此字元串按字典順序小于字元串參數，則傳回一個小于 0 的值；如果此字元串按字典順序大于字元串參數，則傳回一個大于 0 的值。

例子：

[java] view plain copy print ?

package pack;
// String類時用于描述字元串事物。
// 那麼他就提供了多個方法對字元串進行操作。
// 常見的操作有哪些？“abcd”
// 1，擷取。
// 1.1：字元串中包含的字元數，也就是字元串的長度。
// int length：擷取長度。
// 1.2：根據位置擷取位置上的某個字元。
// char charAt(int index);擷取某一位置上的字元。
// 1.3：根據字元擷取該字元在字元串中的位置。
// int indexOf(int ch);傳回的是ch在字元串中第一次出現的位置。
// int indesOf(int ch,int fromIndex);從fromIndex指定位置開始，擷取ch在字元串中出現的位置。
// int indexOf(String str);傳回的是str在字元串中第一次出現的位置。
// int indesOf(String str,int fromIndex);從fromIndex指定位置開始，擷取str在字元串中出現的位置。
//
// int lastIndexOf(int ch);反向索引。
// 2，判斷。
// 2.1：字元串中是否包含某一個子串。
// boolean contains(str);判斷字元串是否存在，判斷字元串是否包含。
// 特殊之處：indexOf(str);可以索引str第一次出現的位置，如果傳回-1，表示該str不再字元串中存在。
// 是以，也可以使用對指定判斷是否包含。
// if(str.indexOf("aa"!=-1));而且該方法既可以判斷，又可以擷取出現的位置。
// 2.2：字元串中是否有内容。
// boolean isEmpty();原理就是判斷長度是否為0。
// 2.3：字元串是否是以指定内容開頭。
// boolean startsWith(str);
// 2.4：字元串是否是以指定内容結尾。
// boolean endsWith(str);
// 2.5：判斷字元串内容是否相同。複寫了Object類中的equals方法。
// booleam equals(str);
// 2.6：判斷内容是否相同，并忽略大小寫。
// boolean equalsIgnoreCase();
// 3，轉換。
// 3.1：将字元數組轉成字元串。
// 構造函數：String(char[])
// String(char[],offset,count):将字元數組中的一部分轉成字元串。
// 靜态方法：
// static String copyValueOf(char[]);
// static String copyValueOf(char[] data,int offset,int count);
// static String valueOf(char[]);
// 3.2：将字元串轉成字元數組。**
// char[] toCharArray();
// 3.3：将位元組數組轉成字元串。
// String(byte[]);
// String(byte[],offset,count);将位元組數組中的一部分轉成字元串。
// 3.4：将字元串轉成位元組數組。
// byte[] getBytes();
// 3.5：将基本資料類型轉換成字元串。
// static String valueOf(int);
// static String valueOf(double);
// 3+"";//String.valueOf(3);
// 特殊：字元串和位元組數組在轉換過程中，是可以指定編碼表的。
// 4，替換。
// String replace(dchar,newchar);
// 5，切割。
// String[] split(regex);
// 6，字串。擷取字元串中的一部分。
// String substring(begin);
// String substring(begin,end);
// 7，轉換，去除空格，比較。
// 7.1：将字元串轉成大寫或者小寫。
// String toUpperCase();
// String toLowerCase();
// 7.2：将字元串兩端的多個空格去除。
// String trim();
// 7.3：對兩個字元串進行自然順序的比較。
// int compareTo(string);
class StringMethodDemo{
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args){
}
public static void method_get(){
String s="abcdefg";
sop(s.length());// 列印長度
sop(s.charAt(2));// 根據索引擷取字元。
// 當通路到字元串中不存在的角标時，
// 會發生StringIndexOutOfBoundsException:字元串角标越界異常。
sop(s.indexOf("a"));//根據字元擷取索引。如果沒有找到，傳回-1.
sop(s.lastIndexOf("a"));// 反向索引一個字元出現的位置。角标不被反向。是以列印的還是0角标
}
public static void method_is(){
String s="ArrayTool.java";
sop(s.startsWith("Array"));// 判斷檔案名稱是否是Array單詞開頭。
sop(s.contains("Tool"));// 判斷檔案名中是否包含Tool。
sop(s.endsWith(".java"));// 判斷檔案名稱是否是.java的檔案。
}
public static void method_trans(){
char[] arr={'a','b','c','d','e'};
String s=new String(arr,1,3);// 将位元組數組中的一部分轉成字元串。
sop("s="+s);
String s1="abcdefg";
char[] chs=s1.toCharArray();// 将字元串轉成位元組數組。
for(int x=0; x<chs.length; x++){
sop(chs[x]);
}
}
public static void method_replace(){
String s="Hello JAVA";
String s1=s.replace("a","b");// 如果要替換的字元不存在，傳回的還是原字元串。
sop(s);sop(s1);
}
public static void method_7(){
String s=" Hello JAVA ";
sop(s.toUpperCase());// 将字元串轉成大寫。
sop(s.toLowerCase());// 将字元串轉成小寫。
sop(s.trim());// 去除字元串兩端的空格。
String s1="aaa";
String s2="abc";
sop(s.compareTo(s2));// 對字元串進行比較排序。
}
}

練習1:

[java] view plain copy print ?

package pack;
// 1，模拟一個trim方法，去除字元串兩端的空格。
// 思路：
// 1，判斷字元串第一個位置是否是空格，如果是繼續向下判斷，直到不是空格為止。
// 結尾處判斷空格也是如此。
// 2，當開始和結尾都判斷到不是空格，就是要擷取的字元串。
// 2，将一個字元串進行反轉，将字元串中指定部分進行反轉，"abcdefg";abfedcg.
// 思路：
// 1，曾靜學習過對數組的元素進行反轉。
// 2，将字元串變成數組，對數組進行反轉。
// 3，将反轉後的數組變成字元串。
// 4，隻要将或反轉的部分的開始和結束為止作為參數傳遞即可。
class StringTest1{
public static void main(String[] args){
}
// 練習一：去除字元串兩端空格。
public static String myTrim(String s){
int start=0,end=s.length()-1;
while(start<=end&&s.charAt(start)==' ')
start++;
while(start<=end&&s.charAt(end)==' ')
end--;
return s.substring(start,end+1);
}
// 練習二：将字元串反轉。
// 将字元串變成數組，對數組進行反轉，将數組變成字元串。
public static String reverseString(String s,int start,int end){
char[] chs=s.toCharArray();
reverse(chs,start,end);
return new String(chs);
}
public static String reverseString(String s){
return reverseString(s,0,s.length()-1);
}
public static void reverse(char[] arr,int x,int y){
for(int start=x,end=y; start<end; start++,end--){
swap(arr,start,end);
}
}
public static void swap(char[] arr,int x,int y){
char temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}

練習2：

[java] view plain copy print ?

package pack;
// 3，擷取一個字元串在另一個字元串中出現的次數。
// “adkkkcdkkefkkskk”
// 思路：
// 1，定義一個計數器。
// 2，擷取kk第一次出現的位置。
// 3，從第一次出現的位置後剩餘的字元串中繼續擷取kk出現的位置。
// 每擷取一次就計數一次。
// 4，當擷取不到時，計數完成。
class StringTest2{
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args){
}
// 方式一。
public static int getSubCount(String s,String key){
int count=0;
int index=0;
while((index=s.indexOf(key))!=-1){
sop(s);
s=s.substring(index+key.length());
count++;
}
return count;
}
// 方式二。
public static int getSubString(String s,String key){
int count=0;
int index=0;
while((index=s.indexOf(key,index))!=-1){
sop(index);
index=index+key.length();
count++;
}
return count;
}
}

練習2：

[java] view plain copy print ?

package pack;
// 4，擷取兩個字元串中最大相同子串，第一個動作：将斷的哪個串進行長度一次遞減的子串列印。
// “abcwerthelloyuiodef”
// “cvhellobnm”
// 思路：
// 1，将短的哪個子串按照長度遞減的方式擷取到。
// 2，将每擷取到的子串去長傳中判斷是否包含。
// 如果包含，已經找到。
class StringTest3{
public static void main(String[] args){
String s1="abcwerthelloyuiodef";
String s2="cvhellobnm";
System.out.println(getMaxSubString(s1,s2));
}
public static String getMaxSubString(String s1,String s2){
String max="",min="";
max=(s1.length()>s2.length())?s1:s2;
min=(max==min)?s1:s2;
System.out.println(max);
System.out.println(min);
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);
if(max.contains(temp))
return "相同子串: "+temp;
}
}
return "";
}
}

------------------------------------

StringBuffer字元串緩沖區：★★★

構造一個其中不帶字元的字元串緩沖區，初始容量為 16 個字元。

特點：

1：可以對字元串内容進行修改。

2：是一個容器。

3：是可變長度的。

4：緩沖區中可以存儲任意類型的資料。

5：最終需要變成字元串。

容器通常具備一些固定的方法：

1，添加。

StringBuffer append(data):在緩沖區中追加資料。追加到尾部。

StringBuffer insert(index,data):在指定位置插入資料。

2，删除。

StringBuffer delete(start,end);删除從start至end-1範圍的元素

StringBuffer deleteCharAt(index);删除指定位置的元素

//sb.delete(0,sb.length());//清空緩沖區。

3，修改。

StringBuffer replace(start,end,string);将start至end-1替換成string

void setCharAt(index,char);替換指定位置的字元

void setLength(len);将原字元串置為指定長度的字元串

4，查找。（查不到傳回-1）

int indexOf(string); 傳回指定子字元串在此字元串中第一次出現處的索引。

int indexOf(string,int fromIndex);從指定位置開始查找字元串

int lastIndexOf(string); 傳回指定子字元串在此字元串中最右邊出現處的索引。

int lastIndexOf(string,int fromIndex); 從指定的索引開始反向搜尋

5，擷取子串。

string substring(start); 傳回start到結尾的子串

string substring(start,end); 傳回start至end-1的子串

6，反轉。

StringBuffer reverse();字元串反轉

StringBuilder字元串緩沖區：★★★

JDK1.5出現StringBuiler；構造一個其中不帶字元的字元串生成器，初始容量為 16 個字元。該類被設計用作 StringBuffer 的一個簡易替換，用在字元串緩沖區被單個線程使用的時候（這種情況很普遍）。

方法和StringBuffer一樣；

StringBuffer 和 StringBuilder 的差別：

StringBuffer線程安全。

StringBuilder線程不安全。

單線程操作，使用StringBuilder 效率高。

多線程操作，使用StringBuffer 安全。

//想要使用緩沖區，先要建立對象。

StringBuffer sb = new StringBuffer();

sb.append(12).append("haha");//方法調用鍊。

String s = "abc"+4+'q';

s = new StringBuffer().append("abc").append(4).append('q').toString();

t-size:10.5000pt; mso-font-kerning:1.0000pt; " >

單線程操作，使用StringBuilder 效率高。

多線程操作，使用StringBuffer 安全。

練習：

[java] view plain copy print ?

package pack;
// StringBuffer是字元串緩沖區，是一個容器。特點：
// 1，而且長度是可變化的。
// 2，可以直接操作多個資料類型。
// 3，最終會通過toString方法變成字元串
// c create U update Rread Ddelete
// 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 laseIndexOf(String str);
// int length();
// String substring(int start,int end);
// 4，修改。
// StringBuffer replace(start,end,string);
// void setCharAt(int index,char ch);
// 5，反轉。
// StringBuffer reverse();
// 6，緩沖區中指定資料存在到指定數組中。
// void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)
// 在JDK1.5版本之後出現了StringBuilder
// 不同在于：StringBuffer是線程同步。
// StringBuilder是線程不同步。
// 以後開發，建議使用StringBuilder。
// 更新三個因素：1，提高效率。2，簡化書寫。3，提高安全性。
class StringBufferDemo{
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args){
}
public static void method_add(){
StringBuffer sb=new StringBuffer();
sb.append("abc");sb.append(123);sb.append(true);
StringBuffer sb1=sb.append(123);
sop("sb: "+sb);sop("sb1: "+sb1);
sb.insert(1,"qq");
sop(sb.toString());
sop(sb1.toString());
}
public static void method_delete(){
StringBuffer sb=new StringBuffer("abcdefg");
sb.delete(1,3);
sb.delete(0,sb.length());
sb.delete(2,3);sb.deleteCharAt(2);
sop(sb.toString());
}
public static void method_udapter(){
StringBuffer sb=new StringBuffer("abcdefg");
sb.replace(1,3,"java");
sb.setCharAt(2,'K');
sop(sb.toString());
}
public static void getChars(){
StringBuffer sb=new StringBuffer("abcdefg");
char[] chs=new char[4];
sb.getChars(1,4,chs,1);
for(int x=0; x<chs.length; x++)
sop("chs["+x+"]"+chs[x]+";");
}
}

黑馬程式員--字元串以及字元串緩沖區

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

GridView終極用法(一)

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method