15_常用API_第15天（Object、String、StringBuffer、使用者登陸註冊）_講義

阿新 • • 發佈：2018-12-20

今日內容介紹 1、Object 2、String 3、StringBuilder 第1章 Java的API及Object類在以前的學習過程中，我們都在學習物件基本特徵、物件的使用以及物件的關係。接下來我們開始使用物件做事情，那麼在使用物件做事情之前，我們要學習一些API中提供的常用物件。首先在學習API中的Object類之前,先來學習如何使用API。 1.1 Java 的API Java 的API（API: Application(應用) Programming(程式) Interface(介面)） Java API就是JDK中提供給我們使用的類，這些類將底層的程式碼實現封裝了起來，我們不需要關心這些類是如何實現的，只需要學習這些類如何使用即可。在JDK安裝目錄下有個src.zip檔案，這個檔案解壓縮后里面的內容是所有Java類的原始檔。可以在其中檢視相對應的類的原始碼。我們在每次檢視類中的方法時，都開啟原始碼進行檢視，這種方式過於麻煩。其實，我們可以通過查幫助文件的方式，來了解Java提供的API如何使用。如下圖操作：查詢Object類在這裡插入圖片描述

通過幫助文件中類與方法的介紹，我們就能夠使用這個類了。 1.2 Object類概述 Object類是Java語言中的根類，即所有類的父類。它中描述的所有方法子類都可以使用。所有類在建立物件的時候，最終找的父類就是Object。在Object類眾多方法中，我們先學習equals方法與toString方法，其他方法後面課程中會陸續學到。 1.3 equals方法在這裡插入圖片描述

equals方法，用於比較兩個物件是否相同，它其實就是使用兩個物件的記憶體地址在比較。Object類中的equals方法內部使用的就是比較運算子。在開發中要比較兩個物件是否相同，經常會根據物件中的屬性值進行比較，也就是在開發經常需要子類重寫equals方法根據物件的屬性值進行比較。 03 equals方法比較記憶體地址 A:equals方法比較記憶體地址 a: Object類中的equals方法用於比較兩個物件是否相同，Object類中就是使用兩個物件的記憶體地址在比較。 Object類中的equals方法內部使用的就是

比較運算子。 b: 案例程式碼在這裡插入圖片描述

package cn.itcast.demo;

public class Person {
	private String name;
	private int age;
	//無參函式
	public Person(){}
	
	//滿參函式
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	/*
	 * 將父類的equals方法寫過來,重寫父類的方法
	 * 但是,也不改變父類方法的原始碼,方法equals比較兩個物件的記憶體地址
	 */
	public boolean equals(Object obj){
		return this == obj;
	}
	
}

package cn.itcast.demo;

public class TestEquals {

	public static void main(String[] args) {
		//Person類繼承Object類,繼承下來了父類的方法equals
		Person p1 = new Person("張三",12);
		Person p2 = new Person("張三",22);
		
		//Person物件p1,呼叫父類的方法equals,進行物件的比較
		//正常兩個物件new出來,記憶體地址是不同的,沒有可比性
		System.out.println(p1.equals(p2));
	}

}

在這裡插入圖片描述 04 重寫equals方法 A: 重寫equals方法 a: 開發中要比較兩個物件是否相同，經常會根據物件中的屬性值進行比較 b: 在開發經常需要子類重寫equals方法根據物件的屬性值進行比較。 c: ==號和equals方法的區別 ==是一個比較運算子號,既可以比較基本資料型別,也可以比較引用資料型別,基本資料型別比較的是值,引用資料型別比較的是地址值 equals方法是一個方法,只能比較引用資料型別,所有的物件都會繼承Object類中的方法,如果沒有重寫Object類中的equals方法, equals方法和==號比較引用資料型別無區別,重寫後的equals方法比較的是物件中的屬性 d: 案例程式碼注意：在複寫Object中的equals方法時，一定要注意public boolean equals(Object obj)的引數是Object型別，在呼叫物件的屬性時，一定要進行型別轉換，在轉換之前必須進行型別判斷。

package cn.itcast.demo01;

public class Person extends Object{
	private String name;
	private int age;
	
	public Person() {
		super();	
	}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	/*
	 * 	重寫Object類equals方法
	 * 比較兩個物件的記憶體地址
	 * 比較兩個物件的成員變數age
	 * 兩個物件成員變數age,相同返回true,不同返回true
	 * 重寫父類equals方法,自己定義自己物件的比較方式
	 */
	public boolean equals(Object obj){
		//以下加的健壯性判斷
		//1.跟自己比,沒有意義
		//boolean b2 = p1.equals(p1)
		if(this == obj){
			return true;
		}
		
		//2.對引數obj,非null判斷
		//boolean b1 = p1.equals(null);
		if(null == obj){
			return false;
		}
		
		//3.
		if(obj instanceof Person){
			//多型的弊端：無法執行子類的特有內容
			//需要向下轉型,obj轉成Person型別
			Person p = (Person)obj;
			System.out.println("子類重寫了");
			return this.age == p.age;
		}
		return false;
	}
	/*
	 * 重寫父類的toString()
	 * 沒有必要讓呼叫者看到記憶體地址
	 * 要求：方法中,返回類中所有成員變數(不能寫靜態方法,因為這個是需要物件呼叫)
	 * 重寫toString方法的好處
	 */
	public String toString(){
		return name+age;
	}
}

package cn.itcast.demo01;

import java.util.ArrayList;

/*
 * equals方法，用於比較兩個物件是否相同
 * 它其實就是使用兩個物件的記憶體地址在比較
 * Object類中的equals方法內部使用的就是==比較運算子。
 */
public class TestEquals {

	public static void main(String[] args) {
		//Person類繼承Object類,繼承下來父類的方法equals
		Person p1 = new Person("張三",12);
		Person p2 = new Person("張三",12);
		//正常兩個物件new出來,記憶體地址是不同的,沒有可比性
		System.out.println(p1.equals(p2));//1
		
		//讓兩個記憶體地址相同,輸出才會true
		p1 = p2;
		//Person物件P1,呼叫父類的方法equals
		//比較兩個物件的記憶體地址
		System.out.println(p1.equals(p2));//2
		//這裡可說明：public boolean equals(Object obj)
		//這個十分有風險性,什麼型別都能給Object型別給吸收掉,但是隻能是Person才接受
		ArrayList<String> array = new ArrayList<>();
		boolean b = p1.equals(array);
		System.out.println(b);//3
		//null
		boolean b1 = p1.equals(null);
		System.out.println(b1);//4
		//呼叫者是自己
		boolean b2 = p1.equals(p1);
		System.out.println(b2);//5
	}

}

在這裡插入圖片描述 1.4 toString方法

package cn.itcast.demo01;

import java.util.Random;
import java.util.Scanner;

public class TestToString {

	public static void main(String[] args) {
		//呼叫Person類的方法toString()
		//輸出語句,寫的是一個物件,預設呼叫物件的toString方法
		Person p = new Person("張三",20);
		String s = p.toString();
		System.out.println(p);
		System.out.println(s);
		/*
		 * System.out.println(p)
		 * System.out.println(p.toString())
		 */
		Random r = new Random();
		System.out.println(r.toString());
		
		Scanner sc = new Scanner(System.in);
		System.out.println(sc.toString());
	}

}

在這裡插入圖片描述 toString方法返回該物件的字串表示，其實該字串內容就是物件的型別[email protected]+記憶體地址值。 由於toString方法返回的結果是記憶體地址，而在開發中，經常需要按照物件的屬性得到相應的字串表現形式，因此也需要重寫它。

class Person extends Object{
	int age ;
	//根據Person類的屬性重寫toString方法
	public String toString() {
		return "Person [age=" + age + "]";
	}
}

第2章 String類 2.1 String類的概念和不變性 A: String類的概念和不變性 a:String類 API中的String類的描述，發現String 類代表字串 Java 程式中的所有字串字面值（如 “abc” ）都作為此類的例項實現。字串是常量,在建立之後不能更改其實就是說一旦這個字串確定了，那麼就會在記憶體區域中就生成了這個字串。字串本身不能改變，但str變數中記錄的地址值是可以改變的。原始碼分析,String類底層採用的是字元陣列: private final char value[] private 修飾說明value只能在String類內部使用,而且又沒有提供get方法,所以外部無法獲取value陣列,就無法改變陣列中元素的值 final修飾說明value是常量,一旦建立,就不能被改變,value一旦被初始化成某個陣列,將永遠指向這個陣列,不可能再指向其它的陣列了 b: 案例程式碼

package cn.itcast.demo02;
/*
 * String類特點：
 * 		一切都是物件,字串事物""也是物件
 * 		類是描述事物,String類, 描述字串物件的類
 * 		所有的""都是String類的物件
 * 
 * 字串是一個常量,一旦建立,不能改變
 *  private final char value[];
 *  定義一維陣列,[]寫char[] 或者解除安裝value[]都可以
 */
public class StringDemo {
	public static void main(String[] args) {
		//引用變數str指向記憶體變化
		//定義好的字串物件不變,一旦生成,不允許改變
		String str = "itcast";
		//因為String類重寫了Object父類的toString方法
		System.out.println(str);
		str = "itheima";
		System.out.println(str);
	}
}

在這裡插入圖片描述 2.1 String類建立方式和比較 A: String類建立方式和比較 a: 建立物件的數量比較 String s3 = “abc”; 在記憶體中只有一個物件。這個物件在字串常量池中 String s4 = new String(“abc”); 在記憶體中有兩個物件。一個new的物件在堆中，一個字串本身物件，在字串常量池中 b: 案例程式碼

package cn.itcast.demo02;
/*
 * equals方法，用於比較兩個物件是否相同，
 * 它其實就是使用兩個物件的記憶體地址在比較。
 * Object類中的equals方法內部使用的就是==比較運算子
 */
public class StringDemo2 {
	public static void main(String[] args) {
		//字串定義方式2個,直接= 使用String類的構造方法
		String str1 = new String("abc");
		String str2 = "abc";
		System.out.println(str1);
		System.out.println(str2);
		//引用資料型別,比較物件的地址false
		System.out.println(str1 == str2);
		//String類繼承Object,重寫了父類的方法equals,建立了字串自己的比較方式
		//字串中每個字元是否相同
//		 public boolean equals(Object anObject) {
//		        if (this == anObject) {
//		            return true;
//		        }
//		        if (anObject instanceof String) {
//		            String anotherString = (String) anObject;
//		            int n = value.length;
//		            if (n == anotherString.value.length) {
//		                char v1[] = value;
//		                char v2[] = anotherString.value;
//		                int i = 0;
//		                while (n-- != 0) {
//		                    if (v1[i] != v2[i])
//		                            return false;
//		                    i++;
//		                }
//		                return true;
//		            }
//		        }
//		        return false;
//		    }
		System.out.println(str1.equals(str2));//true
	}
}

在這裡插入圖片描述 2.2 String類構造方法 A: String類構造方法 a: 常見構造方法

package cn.itcast.demo02;
/*
 * String類構造方法
 * String類的構造方法,過載方式
 */
public class StringDemo3 {
	public static void main(String[] args) {
		function();
		System.out.println();
		funtion_1();
	}
	/*
	 * String(char[] value) 傳遞字元陣列
	 * 將字元陣列,轉成字串,字元陣列的引數,不查詢編碼表
	 * 
	 * String(char[] value, int offset, int count) 傳遞字元陣列
	 * value - 作為字元源的陣列。
	 * offset - 初始偏移量
	 * count - 個數,轉幾個(不是結束的索引) 
	 */
	public static void funtion_1(){
//		char ch[] = {'a','b','c'};
		char[] ch = {'a','b','c'};
		//呼叫String構造方法,傳遞字元陣列
		String s = new String(ch);
		System.out.println(s);
		
		String s1 = new String(ch,0,3);
		System.out.println(s1);
	}
	/*
	 * 定義方法,String類的構造方法
	 * String(byte[] bytes)  傳遞位元組陣列
	 * 位元組陣列轉成字串
	 * 通過使用平臺的預設字符集節碼指定的byte陣列,構造一個新的String
	 * 平臺：指作業系統
	 * 預設字符集：作業系統中的預設編碼表,傳遞位元組陣列
	 * 將位元組陣列中的每個位元組,查詢了編碼表,得到的結果
	 * 位元組是負數,漢字的位元組編碼就是負數,預設編碼表,一個漢字採用2個位元組表示
	 * 
	 * String(byte[] bytes, int offset, int length) 傳遞位元組陣列
	 * 位元組陣列的一部分轉成字串
	 * offset	陣列的起始索引
	 * length	個數,轉幾個(不是結束的索引)
	 */
	public static void function(){
		byte[] bytes = {-97,-98,-60,-61};
		//呼叫String類的構造方法,傳遞位元組陣列
		String s = new String(bytes);
		System.out.println(s);
		
		byte[] bytes1 = {65,66,67,69};
		//呼叫String構造方法,傳遞陣列,傳遞2個int值
		String s1 = new String(bytes1,0,2);
		System.out.println(s1);
	}
}

在這裡插入圖片描述 2.3 String類的方法查詢 tring類中有很多的常用的方法，我們在學習一個類的時候，不要盲目的把所有的方法嘗試去使用一遍，這時我們應該根據這個物件的特點分析這個物件應該具備那些功能，這樣大家應用起來更方便。字串是一個物件，那麼它的方法必然是圍繞操作這個物件的資料而定義的。我們想想字串中有哪些功能呢？  字串中有多少個字元? 在這裡插入圖片描述

String str = "abcde";
int len = str.length();
System.out.println("len="+len);

 獲取部分字串。在這裡插入圖片描述

String str = "abcde";
String s1 = str.substring(1); //返回一個新字串，內容為指定位置開始到字串末尾的所有字元
String s2 = str.substring(2, 4);//返回一個新字串，內容為指定位置開始到指定位置結束所有字元
System.out.println("str="+str);
System.out.println("s1="+s1);
System.out.println("s2="+s2);

2.4 String類中方法查詢練習前面給大家簡單介紹了幾個字串中常用的方法，這個過程中主要讓大家學會如何去查閱API，如何找到自己想用的方法。接下來我們來練習下字串方法的查詢。  字串是否以指定字串開頭。結尾同理。在這裡插入圖片描述

String str = "StringDemo.java";
boolean b1 = str.startsWith("Demo");//判斷是否以給定字串開頭
boolean b2 = str.startsWith("String");
boolean b3 = str.endsWith("java");//判斷是否以給定字串結尾

 字串中是否包含另一個字串。在這裡插入圖片描述

String str = "abcde";
int index = str.indexOf(“bcd”); //判斷是否包含指定字串，包含則返回第一次出現該字串的索引，不包含則返回-1
boolean b2 = str.contains("bcd");//判斷是否包含指定字串，包含返回true，不包含返回false

 將字串轉成一個字元陣列。或者位元組陣列。在這裡插入圖片描述

String str = "abcde";
char[] chs = str.toCharArray();
byte[] bytes = str.getBytes();

 判斷兩個字串中的內容是否相同在這裡插入圖片描述

String str = "abcde";
String str2 = "abcde";
String str3 = "hello";
boolean b1 = str.equals(str2);
boolean b2 = str.equals(str3);

 獲取該字串物件中的內容在這裡插入圖片描述

String str = new String("hello");
System.out.println( str.toString() );
System.out.pintln( str );

package cn.itcast.demo02;
/*
 * String類的查詢功能
 */
public class StringDemo4 {
	public static void main(String[] args) {
		System.out.println("function():");
		function();
		System.out.println("funtion_1():");
		funtion_1();
		System.out.println("funtion_3():");
		funtion_3();
		System.out.println("funtion_4():");
		funtion_4();
		System.out.println("funtion_5():");
		funtion_5();
		System.out.println("funtion_6():");
		funtion_6();
		System.out.println("funtion_7():");
		funtion_7();
		System.out.println("funtion_8():");
		funtion_8();
		System.out.println("funtion_9():");
		funtion_9();
	}
	/*
	 * boolean equals(Object anObject) 將此字串與指定的物件比較 
	 * boolean equalsIgnoreCase(String anotherString) 
	 * 將此 String 與另一個 String 比較，不考慮大小寫 
	 */
	public static void funtion_9(){
		String str = "abc";
		String str1 = "Abc";
		//呼叫String類的方法
		boolean b1 = str.equals(str1);
		boolean b2 = str.equalsIgnoreCase(str1);
		System.out.println(b1);
		System.out.println(b2);		
	}
	/*
	 *  char[] toCharArray() 將此字串轉換為一個新的字元陣列 
	 */
	public static void funtion_8(){
		String str = "abc";
		//呼叫String類的方法
		char[] b = str.toCharArray();
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
	}
	/*
	 *  byte[] getBytes() 
	 * 使用平臺的預設字符集將此 String 編碼為 byte 序列，並將結果儲存到一個新的 byte 陣列中
	 */
	public static void funtion_7(){
		String str = "abc";
		//呼叫String類的方法
		 byte[] b = str.getBytes();
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
	}
	/*
	 * indexOf(String str) 
	 * 返回指定子字串在此字串中第一次出現處的索引。
	 */
	public static void funtion_6(){
		String str = "howareyou";
		//呼叫String類的方法
		int b = str.indexOf("are");
		System.out.println(b);
	}
	/*
	 * boolean contains(String s)
	 * 判斷一個字串中,是不是包含另一個字串
	 */
	public static void funtion_5(){
		String str = "howareyou";
		//呼叫String類的方法
		boolean b = str.contains("are");
		System.out.println(b);
	}
	/*
	 * public boolean endsWith(String prefix)
	 * 判斷一個字串是不是另一個字串的字尾或者結尾
	 */
	public static void funtion_4(){
		String str = "howareyou";
		//呼叫String類的方法
		boolean b = str.endsWith("you");
		System.out.println(b);
	}
	/*
	 * public boolean startsWith(String prefix)
	 * 判斷一個字串是不是另一個字串的字首或者開頭
	 * howareyou
	 * hOw
	 */
	public static void funtion_3(){
		String str = "howareyou";
		//呼叫String類的方法
		boolean b = str.startsWith("How");
		System.out.println(b);
	}
	/*
	 * substring(int beginIndex, int endIndex) 
	 * 返回一個新字串，它是此字串的一個子字串。
	 * beginIndex - 起始索引（包括）
	 * endIndex - 結束索引（不包括）。 
	 * 不包含尾巴
	 * 
	 * String substring(int beginIndex)獲取字串的一部分
	 * 包含頭,後面字元全要
	 */
	public static void funtion_1(){
		String str = "howareyou";
		//substring(int beginIndex, int endIndex)
		str = str.substring(1,5);
		System.out.println(str);
		
		String str2 = "Hello world";
		//String substring(int beginIndex)獲取字串的一部分
		str2 = str2.substring(1);
		System.out.println(str2);
	}
	/*
	 * int length() 返回字串的長度
	 * 包含多少個字元
	 */
	public static void function(){
		String str = "adfadfgasdf";
		//呼叫String類方法length,獲取字串長度
		System.out.println(str.length());
	}
}

在這裡插入圖片描述直接列印引用型別變數時，預設呼叫該型別進行重寫後的toString方法下面的需求所對應的方法，要求大家自己動手在API中查詢，並進行方法使用。  判斷該字串的內容是否為空的字串  獲取給定的字元，在該字串中第一次出現的位置  獲取該字串中指定位置上的字元  把該字串轉換成小寫字串  把該字串轉換成大寫字串  在該字串中，將給定的舊字元，用新字元替換  在該字串中，將給定的舊字串，用新字串替換  去除字串兩端空格，中間的不會去除，返回一個新字串 2.5 String類方法使用練習  題目一：獲取指定字串中，大寫字母、小寫字母、數字的個數。  思路：1.為了統計大寫字母、小寫字母、數字的個數。建立3個計數的變數。 2.為了獲取到字串中的每個字元，進行字串的遍歷，得到每個字元。 3.對得到的字元進行判斷，如果該字元為大寫字母，則大寫字母個數+1；如果該字元為小寫字母，則小寫字母個數+1；如果該字元為數字，則數字個數+1。 4.顯示大寫字母、小寫字母、數字的個數在這裡插入圖片描述

package cn.itcast.demo04;

public class StringTest {

	public static void main(String[] args) {
		getCount("adfsdAAA123");
		System.out.println(toConvert("abcdefBB"));
		System.out.println(getStringCount("javahellojava,nihaojava,javazhenbang","java"));
	}
	/*
	 * 獲取一個字串中,另一個字串出現的次數
	 * 思想：
	 * 		1.indexOf到字串中到第一次出現的索引
	 * 		2.找到索引+被找的字串長度,擷取字串
	 * 		3.計數器++
	 */
	public  static int getStringCount(String str,String key){
		//定義計數器
		int count = 0;
		//定義變數,儲存indexOf查詢後的索引結果
		int index = 0;
		//開始迴圈,條件,indexOf == -1 字串查詢完畢
		while((index = str.indexOf(key)) != -1){
			count++;
			//獲取到的索引,和字串長度求和,用於接下來擷取字串,繼續索引查詢key
			str = str.substring(index + key.length());
		}
		return count;
	}
	/*
	 * 將字串的首字母轉成大寫,其他內容轉成小寫
	 * 思想：
	 * 		獲取首字母,charAt(0)-（這個用起來需要char型別）	substring(0,1)
	 * 		轉成大寫toUpperCase()
	 * 		
	 * 		獲取剩餘字串,substring(1) toLowerCase()
	 */
	public static String toConvert(String str){
		//定義變數,儲存首字母,和剩餘字元
		// String substring(int beginIndex, int endIndex)  
		//返回一個新字串，它是此字串的一個子字串。該子字串從指定的 beginIndex 處開始，直到索引 endIndex - 1 處的字元。
		//因此，該子字串的長度為 endIndex-beginIndex。 
		String first = str.substring(0, 1);
		String after = str.substring(1);
		//呼叫String方法,大寫 小寫轉換
		first = first.toUpperCase();
		after = after.toLowerCase();
		return first + after;
	}
	/*
	 * 題目一：獲取指定字串中，大寫字母、小寫字母、數字的個數
	 * 思想：
	 * 		1.計數器,就是int變數,滿足條件++
	 * 		2.遍歷字串,長度方法length() + charAt()遍歷
	 * 		3.字元判斷是大寫,小寫還是數字
	 */
	public static void getCount(String str){
		//定義三個變數,計數
		int upper = 0;
		int lower = 0;
		int digit = 0;
		//對字串遍歷
		for (int i = 0; i < str.length(); i++) {
			//String方法charAt,索引,獲取字元
			char c = str.charAt(i);
			//利用編碼表65-90 97-122 48-57
			if(c >= 'A' && c <= 90){
				upper++;
			}else if(c >= 97 && c <= 122){
				lower++;
			}else if(c >= 48 && c <= 57){
				digit++;
			}
		}
		System.out.println("大寫字母個數：" + upper + "小寫字母個數：" + lower + "數字個數：" + digit);
	}
}

在這裡插入圖片描述第3章字串緩衝區 3.1 StringBuffer類在學習String類時，API中說字串緩衝區支援可變的字串，什麼是字串緩衝區呢？接下來我們來研究下字串緩衝區。查閱StringBuffer的API，StringBuffer又稱為可變字元序列，它是一個類似於 String 的字串緩衝區，通過某些方法呼叫可以改變該序列的長度和內容。原來StringBuffer是個字串的緩衝區，即就是它是一個容器，容器中可以裝很多字串。並且能夠對其中的字串進行各種操作。 A:StringBuffer類概述通過JDK提供的API，檢視StringBuffer類的說明執行緒安全的可變字元序列底層採用字元陣列實現,初始容量為16 B:StringBuffer和String的區別 String是一個不可變的字元序列 StringBuffer是一個可變的字元序列在這裡插入圖片描述 3.2 StringBuffer類的方法 A: StringBuffer類的方法 a: 方法介紹 StringBuffer append(), 將任意型別的資料,新增緩衝區 append 返回值,寫return this 呼叫者是誰,返回值就是誰 delete(int start,int end): 刪除緩衝區中字元開始索引包含,結尾索引不包含 insert(int index, 任意型別): 將任意型別資料,插入到緩衝區的指定索引上 replace(int start,int end, String str): 將指定的索引範圍內的所有字元,替換成新的字串 reverse(): 將緩衝區中的字元反轉 String toString(): 繼承Object,重寫toString() 將緩衝區中的所有字元,變成字串 b: 案例程式碼

package cn.itcast.demo03;

public class StringBufferDemo {

	public static void main(String[] args) {
		System.out.println("function()");
		function();
		System.out.println("function_1()");
		function_1();
		System.out.println("function_2()");
		function_2();
		System.out.println("function_3()");
		function_3();
		System.out.println("function_4()");
		function_4();
		System.out.println("function_5()");
		function_5();
	}
	/*
	 * StringBuffer類方法
	 * String toString() 繼承Object,重寫toString()
	 * 將緩衝區的所有字元,變成字串
	 */
	public static void function_5(){
		StringBuffer buffer = new StringBuffer();
		buffer.append("abcdef");
		buffer.append(12345);
		
		//將可變的字串緩衝區物件,變成了不可變的String物件
		String s = buffer.toString();
		System.out.println(s);
	}
	/*
	 * StringBuffer類方法
	 * StringBuffer reverse()  將緩衝區中的字元反轉
	 */
	public static void function_4(){
		StringBuffer buffer = new StringBuffer();
		buffer.append("abcdef");
		buffer.reverse();
		System.out.println(buffer);
	}
	/*
	 * StringBuffer類方法
	 * StringBuffer replace(int start, int end, String str) 
	 * 將指定的索引範圍內的所有字元,替換成新的字串
	 */
	public static void function_3(){
		StringBuffer buffer = new StringBuffer();
		buffer.append("abcdef");
		buffer.replace(1, 3, "QQ");
		System.out.println(buffer);
	}
	/*
	 * StringBuffer類方法
	 * StringBuffer insert(int offset, 任意型別 c)   
	 * 將任意型別資料,插入到緩衝區的指定索引上
	 */
	public static void function_2(){
		StringBuffer buffer = new StringBuffer();
		buffer.append("abcdef");
		buffer.insert(3, 5.20);
		System.out.println(buffer);
	}
	
	/*
	 * StringBuffer類方法
	 * StringBuffer delete(int start, int end)  
	 * 移除此序列的子字串中的字元
	 * 開始索引是包含的,結尾索引不包含
	 */
	public static void function_1(){
		StringBuffer buffer = new StringBuffer();
		buffer.append("abcdef");
		buffer.delete(1, 5);
		System.out.println(buffer);
	}
	/*
	 * StringBuffer類方法
	 * StringBuffer	append 將任意型別的資料,新增緩衝區
	 * append 返回值,寫return this
	 * 呼叫者是誰,返回值就是誰
	 */
	public static void function(){
		StringBuffer buffer = new StringBuffer();
		//呼叫StringBuffer方法append向緩衝區新增內容
		buffer.append(6).append(false);//方法呼叫鏈條,因為append返回值是return this的原因
		System.out.println(buffer);
	}

}

在這裡插入圖片描述 3.3 StringBuffer類方法查詢練習下面的需求所對應的方法，要求大家自己動手在API中查詢，並進行方法使用。  從指定位置開始，到末尾結束，擷取該字串緩衝區，返回新字串  在原有字串緩衝區內容基礎上，刪除指定位置上的字元 3.4 物件的方法鏈式呼叫在我們開發中，會遇到呼叫一個方法後，返回一個物件的情況。然後使用返回的物件繼續呼叫方法。這種時候，我們就可以把程式碼現在一起，如append方法一樣，程式碼如下：

建立一個字串緩衝區物件。用於儲存資料。
StringBuffer sb = new StringBuffer();
新增資料。不斷的新增資料後，要對緩衝區的最後的資料進行操作，必須轉成字串才可以。
String str = sb.append(true).append("hehe").toString();

3.5 StringBuffer練習

package cn.itcast.demo04;
/*
 * int[] arr = {34,12,89,68};將一個int[]中元素轉成字串  格式 [34,12,89,68]
 * 格式[34,12,89,68]
 * String s = "["
 * 陣列遍歷
 * 		s+=arr[i]
 * s+"]"
 * StringBuffer實現,節約記憶體空間,String+在緩衝區中,append方法
 */
public class StringBufferTest {
	public static void main(String[] args) {
		int[] arr = {34,12,89,68};
		System.out.println(toString(arr));
	}
	public static String toString(int[] arr){
		//建立字元緩衝區
		StringBuffer buffer = new StringBuffer();
		buffer.append("[");
		//陣列遍歷
		for (int i = 0; i < arr.length; i++) {
			//判斷是否是陣列的最後一個元素
			if(i == arr.length - 1){
				buffer.append(arr[i]).append("]");
			}else{
				buffer.append(arr[i]).append(",");
			}
		}
		//將緩衝區的所有字元,變成字串
		return buffer.toString();
	}
}

在這裡插入圖片描述 3.6 StringBuilder類查閱API發現還有一個StringBuilder類，它也是字串緩衝區，StringBuilder與它和StringBuffer的有什麼不同呢？我們閱讀StringBuilder的API說明發現，它也是一個可變的字元序列。此類提供一個與 StringBuffer 相容的 API，但不保證同步。該類被設計用作 StringBuffer 的一個簡易替換，用在字串緩衝區被單個執行緒使用的時候（這種情況很普遍）。如果可能，建議優先採用該類，因為在大多數實現中，它比 StringBuffer 要快。(安全的永遠要慢點) 目前，我們還沒有涉及到執行緒與同步，知道結論StringBuilder比StringBuffer快即可。為什麼快，我們會在學習執行緒時講解。 A:StringBuilder的概述通過檢視API瞭解一下StringBuilder類 B:面試題 String,StringBuffer,StringBuilder的區別 StringBuffer和StringBuilder的區別 StringBuffer是jdk1.0版本的,是執行緒安全的,效率低 StringBuilder是jdk1.5版本的,是執行緒不安全的,效率高 String和StringBuffer,StringBuilder的區別 String是一個不可變的字元序列 StringBuffer,StringBuilder是可變的字元序列第4章總結 4.1 知識點總結  Object: 它是所有類的超類，祖宗類。java中所有的類都直接或間接的繼承這個類  方法 public String toString() 返回當前物件中的內容, 對於Object類預設操作來說，返回的物件的型別[email protected]+記憶體地址值 public boolean equals(Object obj) 比較兩個物件內容是否相同，對於Object類預設操作來說,比較的是地址值

 String: 字串類，字串是常量；它們的值在建立之後不能更改  方法 boolean equals(Object obj) 判斷兩個字串中的內容是否相同 boolean equalsIgnoreCase(String str) 判斷兩個字串中的內容是否相同, 忽略大小寫 boolean contains(String str) 判斷該字串中是否包含給定的字串 boolean startsWith(String str) 判斷該字串是否以給定的字串開頭 boolean endsWith(String str) 判斷該字串是否以給定的字串結尾 boolean isEmpty() 判斷該字串的內容是否為空的字串 “” int length() 獲取該字串的長度 char charAt(int index) 獲取該字串中指定位置上的字元 String substring(int start) 從指定位置開始，到末尾結束，擷取該字串，返回新字串 String substring(int start,int end) 從指定位置開始，到指定位置結束，擷取該字串，返回新字串 int indexOf(int ch ) 獲取給定的字元，在該字串中第一次出現的位置 int indexOf(String str) 獲取給定的字串，在該字串中第一次出現的位置 int indexOf(int ch,int fromIndex) 從指定位置開始，獲取給定的字元，在該字元 byte[] getBytes() 把該字串轉換成位元組陣列 char[] toCharArray() 把該字串轉換成字元陣列 String replace(char old,char new) 在該字串中，將給定的舊字元，用新字元替換 String replace(String old,String new) 在該字串中，將給定的舊字串，用新字串替換 String trim() 去除字串兩端空格，中間的不會去除，返回一個新字串 String toLowerCase() 把該字串轉換成小寫字串 String toUpperCase() 把該字串轉換成大寫字串 int indexOf(String str,int fromIndex) 從指定位置開始，獲取給定的字串，在該字串中第一次出現的位置

 StringBuffer/StringBuilder:  方法 public StringBuffer append(String str) 在原有字串緩衝區內容基礎上，在末尾追加新資料 public StringBuffer insert(int offset,String str) 在原有字串緩衝區內容基礎上，在指定位置插入新資料 public StringBuffer deleteCharAt(int index) 在原有字串緩衝區內容基礎上，刪除指定位置上的字元 public StringBuffer delete(int start,int end) 在原有字串緩衝區內容基礎上，刪除指定範圍內的多個字元 public StringBuffer replace(int start,int end,String str)在原有字串緩衝區內容基礎上，將指定範圍內的多個字元用給定的字串替換 public StringBuffer reverse() 將字串緩衝區的內容反轉 “abc”----“cba” public String substring(int start) 從指定位置開始，到末尾結束，擷取該字串緩衝區，返回新字串 public String substring(int start,int end) 從指定位置開始，到指定位置結束，擷取該字串緩衝區，返回新字串

15_常用API_第15天（Object、String、StringBuffer、使用者登陸註冊）_講義

15_常用API_第15天（Object、String、StringBuffer、使用者登陸註冊）_講義

16_常用API_第16天（正則表達式、Date、DateFormat、Calendar）

Java進階學習第十三天（檔案上傳與下載、JavaMail郵件開發）

14_Java面向物件_第14天（Eclipse高階、類與介面作為引數返回值）_講義

每天學習點--------第四天（2017-09-26）摘要: 常用的字符串方法閱讀全文

【第11天】Java的單例模式、介面以及Object類常用的方法

30天自制作業系統之第15天多工（1）

沖刺第八天（補發5.9日）

走入計算機的第四天（linux的熱鍵和一些簡單的命令）

走入計算機的第六天（linux的基礎知識）

走入計算機的第七天（關於操作系統的內容）

BOS項目第2天（BaseDao、BaseAction、用戶登錄、自定義strust登錄攔截器）

走入計算機的第十天（linux基礎的結尾）

linux基礎第七天（nfs服務，計劃任務crond服務）

OC第三天（內存管理）

python函數第5天（day 24）

python函數第6天（day 25）

Python第四天（未完）

每天學習點--------第六天（2017-10-10）摘要: mysql和Oracle的區別

python3第七天（輸入和輸出）

15_常用API_第15天（Object、String、StringBuffer、使用者登陸註冊）_講義

相關推薦