-----------android培訓、java培訓、java學習型技術博客、期待與您交流！------------
Scanner
位於java.util包中,是鍵盤的輸入類最早出現在 出現在JDK1.5版本。
創建：
new Scanner(System.in)
傳遞InputStream類型,傳遞是InputStream類的對象
傳遞的是子類對象
Scanner(InputStream source)
nextInt() 接收int類型數據
nextLine() 接收字符串一整行
測試用例：
import java.util.Scanner;//倒包
public class ScannerDemo {
public static void main(String[] args) {
method_1();
}
public static void method_1(){
Scanner sc = new Scanner(System.in);
//接收鍵盤輸入的一行
String line = sc.nextLine();
System.out.println(line);
//接收鍵盤輸入整數
int x = sc.nextInt();
System.out.println(x);
----------------------------------------------------------------
//接收整數
int x = sc.nextInt();//123 回車鍵 \r\n
System.out.println(x);
sc = new Scanner(System.in);
//接收鍵盤一行
String line = sc.nextLine();//接收 \r\n
System.out.println(line);
}
/*
* boolean hasNextXXX()
* boolean hasNextInt() 判斷出,輸入的類型是不是int
* 如果是返回true,不是返回false
*/
public static void method(){
Scanner sc = new Scanner(System.in);
//接收int參數,但是保險,必須對輸入的內容,判斷一下
//hasNextInt()
if(sc.hasNextInt()){
int x = sc.nextInt();
System.out.println(x);
}
}
}
Object類
Object是所有類的父類,包括數組，也就是說任何的類都直接或者間接的繼承了Object類，用老師的話說，它就是一個“上帝類”。
構造方法
public Object(){} 第一行絕對不是super()，因爲Object是最高父類
Object類中的方法
protected Object clone() 克隆對象
public boolean equals(Object obj) 對象之間的比較性
public int hashCode() 返回對象的哈希值
public String toString() 返回對象的字符串表現形式
public void wait() 導致當前線程等待
public void notify() 喚醒等待中的線程
public void nofifyAll() 喚醒全部等待中的線程
protected void finalize() 垃圾回收器
public Class getClass() 返回類的class文件對象
private static native void registerNatives();
native 本地
內存圖: 棧,堆,方法區,本地方法棧,寄存器
凡是被native修飾的方法,運行時期,進入本地方法棧中運行
本地方法:
這樣的方法,非JAVA代碼編寫,C++寫的
本地方法,調用操作系統中的功能
面試細節
clone finalize 方法權限受保護
Object所有類的父類,爲什麼方法權限受保護
受保護權限:對外中的子類,可以調用,必須持有super才能調用
父類構造保護的方法,只能是子類方法中super才能調用
問 == 和equals區別
== 基本類型 引用類型
基本類型,比較符合兩邊具體數值
引用類型,比較的對象的內存地址
equals 默認比較也是對象內存地址
重寫equals建立自己的對象的比較方式
Object類方法
返回字符串,方法名toString()
輸出語句中sop,默認調用對象的toString()方法
瞭解Object類的方法toString的源代碼
通過toString方法看到的是對象的地址
對於使用者來講,看對象的地址,沒有意義
測試用例：重寫父類方法toString(),建立自己的字符串表現形式,不想用戶看到地址
看到的應該是類中的成員變量的值
方法toString裏面,就是返回類的成員變量
如果用戶直接打印對象,看到的是成員變量的數值,不是地址了
方便用戶觀看,僅此而已
不能修改成員
//定義Person類做演示
class Person extends Object{
private String name;
private int age;
Person(String name,int age){
this.age = age;
this.name = name;
}
public String toString(){
/*
* getClass().getName()運行結果 包名.類名
* @
* Integer.toHexString 類名調用的靜態方法,將十進制轉成十六進制
* hashCode() 返回對象的哈希值碼,計算結果就是一個十進制數而已
*/
//return getClass().getName()+"@"+Integer.toHexString(hashCode());
return name +"..."+age;
}
}
public class ObjectDemo1 {
public static void main(String[] args) {
Person p = new Person("lisi",23);
System.out.println(p);
//Person類繼承Object類,可以直接使用父類方法toString()
System.out.println(p.toString());
String s = "abc";
System.out.println(s);
}
}
/*
* Object類的方法equals(Object obj)
* 返回布爾值,參數類型 Object obj
* 對象之間的比較性,用來比較對象的
* 剖析Object類的方法 equals源代碼
* Object類的源代碼中,equals方法默認比較的是對象中的地址
*
* 既然對象都是new出來的,所以地址肯定也是不同的
* 比較對象的地址有意義嗎
*
* 重寫equals方法,建立對象自己的比較方式
* 比較的成員變量的值
*/
class Cat{}
class Student{
private int age;
Student(int age){
this.age = age;
}
//重寫equals方法,建立Student類自己的比較方式
//兩個對象中成員變量age的值,如果一樣返回true
public boolean equals(Object obj){
//判斷obj是不是null,如果是,就不需要比較
if(obj == null)
return false;
//判斷this和obj是不是同一個對象,如果是不要比較
if(this == obj)
return true;
// return this == obj ;
//this.age == obj.age
//將提升父類類型的obj,轉成Student類型
//目標類型 變量 = (目標類型)要被轉換的變量;
//強制轉換之前,判斷,傳遞的參數obj是不是Student類型
//如果是,可以強轉,不是Student類型,不要比了
if(obj instanceof Student){
Student s = (Student)obj;
return this.age == s.age;
}
return false;
}
}
public class ObjectDemo2 {
public static void main(String[] args) {
//建立2個Student類的對象
Student s1 = new Student(15);
Student s2 = new Student(15);
//調用方法equals進行比較
boolean b = s1.equals(s1);
System.out.println(b);
}
}
/*
* 對Object 類的方法,進行整理
* 重寫 toString equals 依賴類成員變量
*/
//定義工作者類
class Worker{
private String name;
private int age;
Worker(String name,int age){
this.age = age;
this.name = name;
}
/*
* 重寫父類方法equals
* 重寫目的,建立Worker類自己的比較方法,比較兩個對象的年齡
*/
public boolean equals(Object obj){
//判斷參數是不是null
if( obj == null )
return false;
//判斷this和obj是不是同一個對象
if(this == obj )
return true;
//判斷參數obj是不是Worker類對象,如果是就強制轉換
if(obj instanceof Worker){
Worker w = (Worker)obj;
return this.age == w.age;
}
return false;
}
/*
* 重寫父類的方法toString
* 重寫目的,打印對象的時候,直接輸出成員變量的值
* 重寫方法中,直接返回成員變量值
*/
public String toString(){
return "Worker "+ name + ".." + age;
}
}
public class ObjectDemo3 {
public static void main(String[] args) {
Worker w1 = new Worker("花千骨", 356);
Worker w2 = new Worker("白子畫", 356);
// System.out.println(w2);
boolean b = w1.equals(w2);
System.out.println(b);
}
}
/*
* 對象變成垃圾後,垃圾回收器調用方法finalize
* 垃圾收取,自動方式,不需要開發人員去處理
* Object
* final finalize finally
*/
class Teacher{
public void finalize(){
System.out.println("對象被收垃圾了");
}
}
public class ObjectDemo4 {
public static void main(String[] args) {
new Teacher();
new Teacher();
new Teacher();
new Teacher();
new Teacher();
new Teacher();
System.gc();
new Teacher();
new Teacher();
new Teacher();
}
}
String類
概述
String是字符串的類類型，用於描述字符串事物。字符串是一個特殊的對象。
構造方法
String(byte[] bytes)傳遞字節數組 byte -128-127
將參數字節數組變成字符串
String(bytes[] bytes,int offset,int length)傳遞字節數組,兩個整數
將字節數組中的一部分變成字符串
String(char[] ch) 傳遞字符數組
將字符數組變成字符串
String(char[] ch,int offset,int length)傳遞字符數組
將字符數組一部分轉成字符串
第一個參數開始索引,第二個參數獲取幾個
特點
字符串是常量,它的值在創建之後不能更改。
JAVA語言中,只要寫個雙引號 "" 字符串對象, 就是String類的對象
可以"".String類的方法
字符串的底層實現原理：
其實可以將字符串看成是一個字符數組 char[]
private final char value[]
String類,字符串表示,用的是字符數組 "abc" char[] value = {'a','b','c'}
數組建立好了,變成最終數組,長度,還是裏面的內容,不可改變
演示用例：
證明String的不變性
public static void main(String[] args) {
String s = "abc";
System.out.println(s);
method(s);
System.out.println(s);
}
public static void method(String s){
s = s +"w";
}
}
注意：
區分 String s1 = "abc";
String s2 = new String("abc");
public static void main(String[] args) {
String s1 = "abc";
String s2 = new String("abc");
System.out.println(s1);
System.out.println(s2);
System.out.println(s1==s2);//false
/*
* String s1 = "abc"創建了1個字符串對象abc
* String s2 = new String("abc")創建了2個對象
* 1個對象是new String(),第二個對象是"abc"
*
* s1直接指向abc對象
* s2指向的是new String()對象
*/
System.out.println(s1.equals(s2));
/*
* s1.equals是真
* String類繼承Object,重寫了方法equals比較的是字符的實際內容
* 不是地址
*/
}
常見操作方法
1. String類中判斷方法 -- 計算結果都是真假 boolean
1.1 public boolean equals(Object obj)
String類繼承Object,重寫equals方法,建立字符串自己的比較方式
比較的不是字符串的內存,而是比較實際的字符的具體內容,是不是完全相等,如果全等返回true。
/*
* String類判斷兩個字符串是不是全等
* equals("") 適合於密碼驗證
*/
public static void method(){
String s1 = "abc";
String s2 = new String("abc");
//s1對象,調用String類的方法equals傳遞s2
boolean b = s1.equals(s2);
System.out.println(b);
}
1.2 public boolean equalsIgnoreCase(String s)
比較兩個字符串是否相等,忽略大小寫
/*
* String類判斷兩個字符串是不是相等
* 忽略大小寫
* equalsIgnoreCase("") 做驗證碼
*/
public static void method_1(){
String s1 = "hello";
String s2 = "HELLo";
//s1對象,調用String類的方法equalsIgnoreCase傳遞s2
boolean b = s1.equalsIgnoreCase(s2);
System.out.println(b);
}
1.3 public boolean contains(String s)
判斷一個字符串中,是否包含另一個字符串,全包含返回true
/*
* String類判斷一個字符串中是否包含另一個字符串
* contains("")
*/
public static void method_2(){
String s1 = "hello world";
String s2 = "wo";
//s1對象調用String類的方法contains傳遞s2
//判斷字符串s1中,是不是完全包含s2
boolean b = s1.contains(s2);
System.out.println(b);
}
1.4 public boolean startsWith(String s)
判斷一個字符串,是否以另一個字符串開頭,是開頭返回true
/*
* String類判斷一個字符串是否以另一個字符串開頭
* startsWith("")
*/
public static void method_3(){
String s1 = "HelloWorld.java";
String s2 = "H";
//s1對象調用String類方法startsWith傳遞s2
//判斷s1是不是以s2開頭
boolean b = s1.startsWith(s2);
System.out.println(b);
}
1.5 public boolean endsWith(String s)
判斷一個字符串,是否以另一個字符串結尾,是結尾返回true
/*
* String類判斷一個字符串是否以另一個字符串結尾
* endsWith("")
*/
public static void method_4(){
String s1 = "HelloWorld.java";
String s2 = ".java";
//s1對象調用String類的方法endsWith傳遞s2
//判斷s1是不是以s2結尾
boolean b = s1.endsWith(s2);
System.out.println(b);
}
1.6 public boolean isEmpty()
判斷一個字符串中是不是空的,如果一個字符串中一個字符都沒有,返回true ""
/*
* String類判斷一個字符串中是否有字符
* isEmpty()
*/
public static void method_5(){
String s = "";
//s1對象調用String類的方法isEmpty()
boolean b = s.isEmpty();
System.out.println(b);
}
2. String類中的獲取方法
2.1 public char charAt(int index)
獲取字符串中,指定的索引上的單個字符 "abcd" 返回指定索引上的單個字符
/*
* String類獲取指定索引上的單個字符
* charAt(int index)傳遞索引,返回字符
* 索引沒有??出現字符串越界異常
* StringIndexOutOfBoundsException
*/
public static void method(){
String s = "how are you";
//s對象調用String類方法charAt傳遞索引
char ch = s.charAt(3);
System.out.println(ch);
}
2.2 public int indexOf(char ch)
獲取指定的字符,在字符串中第一次出現的索引 ,如果找不到字符,返回-1
/*
* String類獲取字符在字符串中第一次出現的索引
* indexOf(char ch)傳遞字符,返回第一次出現索引
* 沒有這個字符,返回-1 (負數不能是索引)
*/
public static void method_1(){
String s = "fine thank you";
//s對象調用String類方法indexOf傳遞字符
int index = s.indexOf('H');
System.out.println(index);
}
2.3 public int indexOf(char ch, int fromIndex)
獲取指定的字符,在字符串中第一次出現的索引 ,指定開始查找的索引,如果找不到字符,返回-1
/*
* String類獲取字符在字符串中第一次出現的索引
* 指定開始查找索引
* indexOf(char ch,int fromIndex)傳遞字符,開始查找的索引
* 沒有這個字符,返回-1 (負數不能是索引)
*/
public static void method_2(){
String s = "fine thank you";
//s對象調用String類方法indexOf傳遞字符,指定索引
int index = s.indexOf('n',8);
System.out.println(index);
}
2.4 public int indexOf(String s)
獲取指定的字符串,在另一個字符串中第一次出現的索引,如果找不到字符串,返回-1
/*
* String類獲取一個字符串在另一個字符串中第一次出現的索引
* indexOf(String s)傳遞字符串
* 如果找不到返回-1
*/
public static void method_3(){
String s = "fine thank you";
//s對象調用String類的方法indexOf傳遞字符串
int index = s.indexOf("tha");
System.out.println(index);
}
2.5 public int indexOf(String s, int fromIndex)
獲取指定的字符串,在另一個字符串中第一次出現的索引,指定開始查找的索引,如果找不到字符串,返回-1
/*
* String類獲取一個字符串在另一個字符串中第一次出現的索引
* 指定開始查找的索引
* indexOf(String s,index fromIndex)傳遞字符串,開始查找索引
* 如果找不到返回-1
*/
public static void method_4(){
String s = "fine thank you";
//s對象調用String類方法indexOf傳遞字符串,傳遞索引
int index = s.indexOf("han",7);
System.out.println(index);
}
2.6 public int lastIndexOf(char ch)
獲取指定的字符,在字符串中最後一次出現的索引,反向查找,如果找不到返回-1
/*
* String類獲取一個字符在一個字符串中最後一次出現的索引
* lastIndexOf(char ch)傳遞字符
* 如果找不到返回-1
*/
public static void method_5(){
String s = "fine thank you";
//s對象調用String方法lastIndexOf傳遞字符
int index = s.lastIndexOf('n');
System.out.println(index);
}
2.7 public int lastIndexOf(char ch,int formIndex)
獲取指定的字符,在字符串中最後一次出現的索引,反向查找,指定開始查找的索引,如果找不到返回-1
/*
* String類獲取一個字符在一個字符串中最後一次出現的索引
* 指定開始查找的索引
* lastIndexOf(char ch,int fromIndex)傳遞字符,傳遞開始查找索引
* 如果找不到返回-1
* 從開始索引,向前查找
*/
public static void method_6(){
String s = "abmcmdemfgmh";
//s對象調用String類方法lastIndexOf傳遞字符,傳遞開始查找索引
int index = s.lastIndexOf('m',6);
System.out.println(index);
}
2.8 public int length()
獲取字符串的長度 ,返回的是字符串中字符的個數
數組的屬性 數組名.length 字符串的方法 字符串.length()
/*
* String類獲取字符串中字符個數
* 字符串長度
* length()
*/
public static void method_7(){
String s = "khjgfdmhyfbvdcmkjngfbvdc";
int length = s.length();
System.out.println(length);
}
2.9 public String substring(int begin,int end)
獲取字符串的一部分,開始索引,結束索引,返回新的字符串
/*
* String類的獲取字符串的一部分
* 截取字符串
* substring(int begin ,int end)
* 包含頭,不包含尾
*/
public static void method_8(){
String s = "abcdefghijk";
s = s.substring(2,5);
System.out.println(s);
String s1 = "abcdefg";
//從開始索引,後面全要
s1 = s1.substring(2);
System.out.println(s1);
}
3. String類轉換方法
3.1 public byte[] getBytes()
將字符串轉成字節數組 ,查詢本機默認編碼表
/*
* String類將字符串轉成字節數組 查詢編碼表 getBytes()
*/
public static void method() {
// ""可以直接調用String類的方法
// byte[] bytes = "abcd".getBytes();
byte[] bytes = "換成中文".getBytes();
for (int x = 0; x < bytes.length; x++) {
System.out.println(bytes[x]);
}
byte[] bytes2 = { -69, -69, -77, -55, -42, -48, -50, -60 };
String s = new String(bytes2);
System.out.println(s);
}
3.2 public char[] toCharArray()
將字符串轉成字符數組,不查詢編碼表
/*
* String類將字符串轉成字符數組
* 不查詢編碼表
* toCharArray()
*/
public static void method_1(){
//""調用String類方法
char[] ch = "abcde".toCharArray();
for(int x = 0 ; x < ch.length ;x++){
System.out.println(ch[x]);
}
}
3.3 public String toUpperCase()
將字符串全部轉成大寫字母
public static void method_2(){
String s = "A5Bcd*eFGhJIk中lMn";
//s對象調用String類的方法toUpperCase
String upper = s.toUpperCase();
System.out.println(upper);
3.4 public String toLowerCase()
將字符串全部轉成小寫字母
/*
* String類將字符串轉成小寫
* toLowerCase
*/
//s對象調用String類的方法toLowerCase
String lower = s.toLowerCase();
System.out.println(lower);
}
3.5 public String concat(String s)
將兩個字符串連接起來 +
/*
* String類將兩個字符串連接
* concat(String s)
*/
public static void method_3(){
String s = "abc".concat("qq");
System.out.println(s);
//String s = "abc"+"qq";
}
3.6 public static String valueOf(傳遞任意數據類型)
將任意數據類型變成字符串
/*
* String類將任意數據類型變成字符串
* static valueOf(寫任意數據類型)
*/
public static void method_4(){
String s = String.valueOf(false);
//s = false+"";
System.out.println(s);
}
4. String類其他功能
4.1 public String[] split(String s)
切割字符串,傳遞參數就是一個切割的標準
abc de fgh jk
/*
* String類切割字符串方法
* split(切割標準)返回新的字符串數組
*/
public static void method(){
//String s = "abWcWdefgWhijWkl";
String s = "192.168.123.45";
//s對象調用String類的方法split 傳遞標準
String[] str = s.split("\\.");
for(int x = 0 ; x < str.length ; x++){
System.out.println(str[x]);
}
}
4.2 public String replace(char oldChar,char newChar)
替換字符串,被替換以前的,替換以後的新字符
/*
* String類替換字符串方法
* replace()傳遞老字符,新字符
* 返回新的字符串
*/
public static void method_1(){
String s = "www.itcast.cn";
//s對象調用方法replace傳遞2個字符
s = s.replace('t', 'M');
System.out.println(s);
}
4.3 public String replace(String oldString,String newString)
替換字符串,被替換以前的字符串,替換以後的新字符串
/*
* String類替換字符串方法
* replace傳遞老的字符串,新的字符串
* 返回新的字符串
*/
public static void method_2(){
String s = "www.itcast.cn";
//s對象調用方法replace傳遞2個字符串
s = s.replace("cast", "CAST");
System.out.println(s);
}
4.4 public String trim()
去掉字符串兩端空格,返回新的字符串,中間空格不理會
/*
* String類去掉字符串兩端空格
* trim()返回新字符串
* 註冊,登錄使用
*/
public static void method_3(){
String s = " aa bb cc ";
System.out.println(s);
//s對象調用String類方法trim
s = s.trim();
System.out.println(s);
}
4.5 public int compareTo(String s)
兩個字符串進行比較,稱爲字符串的自然順序,字典順序abcd ABCD
按照字符串的字典順序進行比較
返回值是整數,比較後出現三種結果 s1.compareTo(s2)
s1小於s2 < 0 負數
s1等於s2 = 0
s1大於s2 > 0 正數
char c = '以'
public static void method_4(){
String s1 = "abc";
String s2 = new String("bbc");
//s1對象調用String類的方法compareTo傳遞s2
int number = s1.compareTo(s2);
System.out.println(number);
}
實例練習：
/*
* woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”
* 中java出現了5次
* 實現步驟:
* 1. 定義int計數器,保存字符串出現次數
* 2. 字符串使用查找功能indexOf
* indexOf -1 程序結束,找完了
* 3. indexOf結果不是-1
* 計數器++
* 截取字符串 indexOf結果+被找的字符串長度
*/
public static void test_2(){
String big = "woaijavawozhenaijavawozhejavandeaijavawozhendehenaijavaxinbuxijavanwoaijavagun";
String small = "java";
//定義計數器
int count = 0 ;
//定義變量,記錄indexOf計算結果
int index = 0 ;
//開始循環查找,結束條件是 indexOf = -1
while ( ( index = big.indexOf(small)) !=-1 ){
//計數器++
count++;
//對字符串進行截取,索引確定 index + 字符串的長度
big = big.substring(index+small.length());
}
System.out.println(count);
}
/*
* 舉例：鍵盤錄入”abc” 輸出結果：”cba”
* 鍵盤錄入 Scanner類方法nextLine
* 字符串轉成字符數組
* 數組反轉 -- 數組的最遠端換位
* 字符數組變成字符串
*/
public static void test_1(){
//鍵盤輸入
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
//字符串轉成字符數組 toCharArray()
char[] ch = s.toCharArray();
//對數組進行反轉,數組中元素確實進行了位置交換
for(int x = 0,y = ch.length-1 ; x < y ; x++,y--){
char temp = ch[x];
ch[x] = ch[y];
ch[y] = temp;
}
//將數組變成字符串
//String構造方法
String s1 = new String(ch);
System.out.println(s1);
}
/*
* 舉例：int[] arr = {1,2,3}; 輸出結果：[1, 2, 3]
* 獲取數組每個元素,進行字符串的拼接
*/
public static void test(){
int[] arr = {1,2,3};
//定義字符串,保存一半中括號
String s = "[";
//數組遍歷
for(int x = 0 ; x < arr.length ; x++){
//判斷變量x是不是到達了數組的最大索引
if(x != arr.length-1)
//s = s + arr[x]+", ";
s = s.concat(arr[x]+", ");
else
//s = s + arr[x]+"]";
s = s.concat(arr[x]+"]");
}
System.out.println(s);
}
StringBuffer
概述
StringBuffer是字符串緩衝區，緩衝區用於存儲String數據，所以也稱之爲容器。。
常見操作
1、StringBuffer類的添加功能
數據添加到字符串緩衝區中
append 追加
insert 插入
/*
* 在緩衝區的指定索引位置上插入數據
* insert(索引,要添加數據)
*/
public static void method_1(){
StringBuffer buffer = new StringBuffer();
buffer.append("abcdefg");
System.out.println(buffer);
//調用StringBuffer類的方法insert 第3索引上添加6
buffer.insert(3, 6);
System.out.println(buffer);
}
/*
* 向緩衝區追加數據
* append(任意類型)
* 方法的返回值是 StringBuffer類型
* 方法是StringBuffer類的對象
* public StringBuffere append(XX){
* return this;
* }
* 誰調用我,我返回誰
* */
public static void method(){
//創建緩衝區對象
StringBuffer buffer = new StringBuffer();
//調用StringBuffer類的方法append追加數組
buffer.append(3.1).append(false).append(12).append('a');
System.out.println(buffer);
}
2、 StringBuffer類的刪除方法
deleteCharAt(int index)刪除指定索引上的單個字符
delete(int begin,int end)刪除指定索引內的字符
/*
* StringBuffer類的刪除方法
* delete(int begin,int end)
* JAVA凡是開始結尾下標,包含頭,不包含尾
*/
public static void method_1(){
StringBuffer buffer = new StringBuffer();
buffer.append(1234567);
//刪除範圍 1-4索引
buffer.delete(1,4);
System.out.println(buffer);
}
/*
* StringBuffer類的刪除方法
* deleteCharAt(int index)
*/
public static void method(){
StringBuffer buffer = new StringBuffer();
buffer.append(1234567);
//刪除3索引上的字符
buffer.deleteCharAt(3);
System.out.println(buffer);
}
3、 StringBuffer類其他方法
setCharAt(int index,char ch)
第一個要修改的索引,修改後的字符
/*
* 修改指定索引上的字符
* setCharAt(int index ,char ch)
*/
private static void method() {
StringBuffer buffer = new StringBuffer();
buffer.append("abcdef");
//修改第一索引上字符,修改成m
buffer.setCharAt(1, 'm');
System.out.println(buffer);
}
replace(int start,int end,String str)
將一個索引範圍內的數據,全部替換成指定的字符串
/*
* 替換緩衝區中指定的字符
* 開始和結束的索引
* replace(int start,int end,String str)
*/
private static void method_1() {
StringBuffer buffer = new StringBuffer();
buffer.append("abcdef");
//替換緩衝區 1-3索引,替換爲itcast
buffer.replace(1, 3, "itcast");
System.out.println(buffer);
}
reverse()
將緩衝區中的內容反轉
/*
* 反轉緩衝區
* reverse()
*/
private static void method_2() {
StringBuffer buffer = new StringBuffer();
buffer.append("abcdef");
//反轉緩衝區
buffer.reverse();
System.out.println(buffer);
}
4、 String對象和StringBuffer對象之間的相互轉換
不變對象,轉成可變對象 String->StringBuffer
可變對象,轉成不可變對象 StringBuffer -> String
/*
* StringBuffer -> String
* StringBuffer類的方法toString()
*/
public static void method_1(){
StringBuffer buffer = new StringBuffer();
buffer.append(123);
buffer.append(false);
System.out.println(buffer.toString());
String s = buffer.toString();
System.out.println(s);
}
/*
* String -> StringBuffer
* 兩種方式
* StringBuffer類構造方法
* StringBuffer類append
*/
public static void method(){
StringBuffer buffer = new StringBuffer("abc");
buffer.append("1234");
}
練習 用例：
利用StringBuffer將數組拼接成字符串
* 採用字符串緩衝區對象StringBuffer類實現
* 節約內存,運行速度就快了
* append取代字符串 + 操作
* 緩衝區變成字符串
*/
public static String test(){
int[] arr = {1,2,3};
//創建緩衝區對象
StringBuffer buffer = new StringBuffer();
buffer.append("[");
for(int x = 0 ; x < arr.length ;x++){
if( x!=arr.length-1)
buffer.append(arr[x]+", ");
else
buffer.append(arr[x]+"]");
}
return buffer.toString();
}
StringBuilder
StringBuilder類方法,和StringBuffer完全一樣
StringBuffer,出現JDK1.0
StringBuilder,出現JDK1.5
StringBuilder類運行速度比StringBuffer快
StringBuffer線程安全
StringBuilder線程不全的
-----------android培訓、java培訓、java學習型技術博客、期待與您交流！------------