Java之 StringBuilder類、集合
阿新 • • 發佈：2020-12-02
0x01.StringBuilder類
1.符串拼接問題
由於String類的物件內容不可改變，所以每當進行字串拼接時，總是會在記憶體中建立一個新的物件。例如：
public class StringDemo {
public static void main(String[] args) {
String s = "Hello";
s += "World";// s = s + "World";
System.out.println(s);// HelloWorld
}
}
在API中對String類有這樣的描述：字串是常量，它們的值在建立後不能被更改。
根據這句話分析我們的程式碼，其實總共產生了三個字串，即"Hello"、"World"和"HelloWorld"。引用變數s首先指向Hello物件，最終指向拼接出來的新字串物件，即HelloWord 。
由此可知，如果對字串進行拼接操作，每次拼接，都會構建一個新的String物件，既耗時，又浪費空間。為了解決這一問題，可以使用java.lang.StringBuilder類。
小結
- 結論:
- String類的字串拼接,每一次拼接完都會得到一個新的字串物件,所以比較耗時,也浪費空間
2. StringBuilder類概述以及與String類的區別
知識點：
- StringBuilder類的概述
- StringBuilder類和String類的區別
StringBuilder類概述
StringBuilder 是一個可變的字串類，我們可以把它看成是一個容器，這裡的可變指的是 StringBuilder 物件中的內容是可變的
StringBuilder類和String類的區別
-
String類：內容是不可變的
-
StringBuilder類：內容是可變的
小結
- StringBuilder 是一個可變的字串類,表示字串
- StringBuilder 拼接是直接在本身的字串末尾進行拼接的
3. StringBuilder類的構造方法
-
常用的構造方法
public StringBuilder()建立一個空白可變字串物件，不含有任何內容 public StringBuilder(String str)根據字串的內容，來建立可變字串物件 -
示例程式碼
public class StringBuilderDemo01 {
public static void main(String[] args) {
//public StringBuilder()：建立一個空白可變字串物件，不含有任何內容
StringBuilder sb = new StringBuilder();
System.out.println("sb:" + sb);
System.out.println("sb.length():" + sb.length());
//public StringBuilder(String str)：根據字串的內容，來建立可變字串物件
StringBuilder sb2 = new StringBuilder("hello");
System.out.println("sb2:" + sb2);
System.out.println("sb2.length():" + sb2.length());
}
}
4.StringBuilder類拼接和反轉方法
-
新增和反轉方法
public StringBuilder append(任意型別) 拼接資料，並返回物件本身 public StringBuilder insert(int offset, 任意型別) 在指定位置插入資料,並返回物件本身 public StringBuilder reverse() 反轉字串,並返回物件本身 -
示例程式碼
public class StringBuilderDemo01 {
public static void main(String[] args) {
//建立物件
StringBuilder sb = new StringBuilder();
//public StringBuilder append(任意型別)：新增資料，並返回物件本身
// StringBuilder sb2 = sb.append("hello");
//
// System.out.println("sb:" + sb);
// System.out.println("sb2:" + sb2);
// System.out.println(sb == sb2);
// sb.append("hello");
// sb.append("world");
// sb.append("java");
// sb.append(100);
//鏈式程式設計
sb.append("hello").append("world").append("java").append(100);
System.out.println("sb:" + sb);
//public StringBuilder reverse()：返回相反的字元序列
sb.reverse();
System.out.println("sb:" + sb);
}
}
小結
StringBuilder類常用方法:
public StringBuilder append(任意型別) 新增資料，並返回物件本身
public StringBuilder reverse() 返回相反的字元序列
5.StringBuilder和String相互轉換
知識點：
- StringBuilder轉換為String
- String轉換為StringBuilder
StringBuilder轉換為String
public String toString()：通過StringBuilder類中的 toString() 就可以實現把 StringBuilder 轉換為 String
String轉換為StringBuilder
public StringBuilder(String s)：通過StringBuilder的構造方法就可以實現把 String 轉換為 StringBuilder
- 示例程式碼
public class StringBuilderDemo02 {
public static void main(String[] args) {
/*
//StringBuilder 轉換為 String
StringBuilder sb = new StringBuilder();
sb.append("hello");
//String s = sb; //這個是錯誤的做法
//public String toString()：通過 toString() 就可以實現把 StringBuilder 轉換為 String
String s = sb.toString();
System.out.println(s);
*/
//String 轉換為 StringBuilder
String s = "hello";
//StringBuilder sb = s; //這個是錯誤的做法
//public StringBuilder(String s)：通過構造方法就可以實現把 String 轉換為 StringBuilder
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);
}
}
6.字串拼接升級版案例
需求
定義一個方法，把 int 陣列中的資料按照指定的格式拼接成一個字串返回，呼叫該方法，
並在控制檯輸出結果。例如，陣列為int[] arr = {1,2,3}; ，執行方法後的輸出結果為：[1, 2, 3]
分析
- 定義一個 int 型別的陣列，用靜態初始化完成陣列元素的初始化
- 定義一個方法，用於把 int 陣列中的資料按照指定格式拼接成一個字串返回。返回值型別 String，引數列表 int[] arr
- 在方法中用 StringBuilder 按照要求進行拼接，並把結果轉成 String 返回
- 呼叫方法，用一個變數接收結果
- 輸出結果
實現
/*
思路：
1:定義一個 int 型別的陣列，用靜態初始化完成陣列元素的初始化
2:定義一個方法，用於把 int 陣列中的資料按照指定格式拼接成一個字串返回。
返回值型別 String，引數列表 int[] arr
3:在方法中用 StringBuilder 按照要求進行拼接，並把結果轉成 String 返回
4:呼叫方法，用一個變數接收結果
5:輸出結果
*/
public class StringBuilderTest01 {
public static void main(String[] args) {
//定義一個 int 型別的陣列，用靜態初始化完成陣列元素的初始化
int[] arr = {1, 2, 3};
//呼叫方法，用一個變數接收結果
String s = arrayToString(arr);
//輸出結果
System.out.println("s:" + s);
}
//定義一個方法，用於把 int 陣列中的資料按照指定格式拼接成一個字串返回
/*
兩個明確：
返回值型別：String
引數：int[] arr
*/
public static String arrayToString(int[] arr) {
//在方法中用 StringBuilder 按照要求進行拼接，並把結果轉成 String 返回
StringBuilder sb = new StringBuilder();
sb.append("[");
for(int i=0; i<arr.length; i++) {
if(i == arr.length-1) {
sb.append(arr[i]);
} else {
sb.append(arr[i]).append(", ");
}
}
sb.append("]");
String s = sb.toString();
return s;
}
}
7. 字串反轉升級版案例
需求
定義一個方法，實現字串反轉。鍵盤錄入一個字串，呼叫該方法後，在控制檯輸出結果
例如，鍵盤錄入abc，輸出結果 cba
分析
- 鍵盤錄入一個字串，用 Scanner 實現
- 定義一個方法，實現字串反轉。返回值型別 String，引數 String s
- 在方法中用StringBuilder實現字串的反轉，並把結果轉成String返回
- 呼叫方法，用一個變數接收結果
- 輸出結果
實現
/*
思路：
1:鍵盤錄入一個字串，用 Scanner 實現
2:定義一個方法，實現字串反轉。返回值型別 String，引數 String s
3:在方法中用StringBuilder實現字串的反轉，並把結果轉成String返回
4:呼叫方法，用一個變數接收結果
5:輸出結果
*/
public class StringBuilderTest02 {
public static void main(String[] args) {
//鍵盤錄入一個字串，用 Scanner 實現
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個字串：");
String line = sc.nextLine();
//呼叫方法，用一個變數接收結果
String s = myReverse(line);
//輸出結果
System.out.println("s:" + s);
}
//定義一個方法，實現字串反轉。返回值型別 String，引數 String s
/*
兩個明確：
返回值型別：String
引數：String s
*/
public static String myReverse(String s) {
//在方法中用StringBuilder實現字串的反轉，並把結果轉成String返回
//String --- StringBuilder --- reverse() --- String
// StringBuilder sb = new StringBuilder(s);
// sb.reverse();
// String ss = sb.toString();
// return ss;
return new StringBuilder(s).reverse().toString();
}
}
0x02.ArrayList集合
1.什麼是集合？
集合的概述
- 思考: 程式設計的時候如果要儲存多個數據,首先我們想到的就是陣列,但是陣列的特點是長度固定,所以陣列不一定能滿足我們的需求,更適應不了變化的需求,那麼應該如何選擇呢?
- 什麼是集合
- 集合其實就是一個大小可變的容器,可以用來儲存多個數據
- 集合的特點: 集合的大小可以動態改變,可以儲存各種型別的資料
集合與陣列的區別
- 陣列：陣列大小固定，只能儲存相同資料型別的資料
- 集合：集合大小可動態擴充套件，可以儲存各種引用型別的資料
總結
- 集合: 是一個大小可變的容器,可以用來儲存多個數據
- 集合和陣列的區別:
- 陣列大小是固定,只能儲存相同資料型別的資料
- 集合大小是可變,可以儲存各種引用型別的資料
2. ArrayList類概述
集合類有很多,目前我們先學習一個: ArrayList
ArrayList類概述
- 通過檢視ArrayList類的API:
java.util.ArrayList <E>：該類需要 import匯入使後使用。表示一種指定的資料型別,叫做泛型,用於約束集合中儲存元素的資料型別 - 怎麼用呢?
- 在出現E的地方我們使用引用資料型別替換即可，表示我們將儲存哪種引用型別的元素。
- 例如:
- ArrayList
表示ArrayList集合中只能儲存String型別的物件 - ArrayList
表示ArrayList集合中只能儲存Student型別的物件 - .....
- ArrayList
- 概述:
- ArrayList類底層是大小可變的陣列的實現，儲存在內的資料稱為元素。也就是說ArrayList 中可以不斷新增元素，其大小會自動增長。
小結
- 概述: ArrayList類底層是一個大小可變的陣列實現
- 使用ArrayList
類的時候,在E出現的位置使用引用資料型別替換,表示該集合可以儲存哪種引用型別的元素
3.ArrayList類構造方法
知識點：
-
介紹ArrayList的構造方法
-
案例演示
-
介紹ArrayList的構造方法
ArrayList()構造一個初始容量為 10 的空列表。
-
案例演示
public class Test { public static void main(String[] args) { /* ArrayList類構造方法: ArrayList() 構造一個初始容量為 10 的空列表。 如果一個集合需要儲存基本資料型別的資料,那麼需要把基本資料型別轉換為對應的引用資料型別 基本資料型別 引用資料型別 byte Byte short Short int Integer long Long double Double float Float char Character boolean Boolean */ // 建立了一個ArrayList集合物件,限制集合中的元素型別為String型別 ArrayList<String> list1 = new ArrayList<String>(); // 建立一個ArrayList集合物件,限制集合中的元素型別為student型別 ArrayList<Student> list2 = new ArrayList<Student>(); // 簡寫: ArrayList<String> list11 = new ArrayList<>(); ArrayList<Student> list22 = new ArrayList<>(); // 建立一個ArrayList集合物件,可以儲存任意引用型別的資料 ArrayList list3 = new ArrayList(); // 把基本資料型別轉換為對應的引用資料型別 Integer i = 10;// 基本資料型別轉換為引用資料型別 int num = i;// 引用資料型別轉換為基本資料型別 // 建立一個ArrayList集合物件,限制集合中的元素型別為Integer型別 ArrayList<Integer> list4 = new ArrayList<>(); } }
4. ArrayList類新增元素方法
-
ArrayList新增元素的方法
- public boolean add(E e)：將指定的元素追加到此集合的末尾
- public void add(int index,E element)：在此集合中的指定位置插入指定的元素
-
案例演示:
public class Test { public static void main(String[] args) { /* ArrayList類新增元素方法: boolean add(E e) 將指定的元素新增在集合的末尾 void add(int index, E element) 將指定的元素插入在指定的索引位置。 */ // 建立了一個ArrayList集合物件,限制集合中的元素型別為String型別 ArrayList<String> list1 = new ArrayList<>(); // 往list1集合的末尾新增元素 list1.add("張三丰"); list1.add("章子怡"); list1.add("張翠山"); // 列印集合 System.out.println(list1);// [張三丰, 章子怡, 張翠山] // 往list1集合所有為1的位置新增一個張無忌元素 list1.add(1, "張無忌"); System.out.println(list1);// [張三丰, 張無忌, 章子怡, 張翠山] System.out.println("======================================"); // 建立一個ArrayList集合物件,可以儲存任意引用型別的資料 ArrayList list3 = new ArrayList(); // 往list3集合中新增任意引用資料型別的元素 list3.add("殷素素"); list3.add(18);// int---->自動轉換為Integer型別 list3.add(3.14);// double--->自動轉換為Double型別 System.out.println(list3);// [殷素素, 18, 3.14] System.out.println("=========================="); // 建立一個ArrayList集合物件,限制集合中的元素型別為Integer型別 ArrayList<Integer> list4 = new ArrayList<>(); // 往list4集合中新增任意引用資料型別的元素 list4.add(10); list4.add(20); list4.add(30); System.out.println(list4);// [10, 20, 30] } }
5. ArrayList類常用方法
知識點：
- ArrayList常用方法
ArrayList常用方法
public boolean remove(Object o) 刪除指定的元素，返回刪除是否成功
public E remove(int index) 刪除指定索引處的元素，返回被刪除的元素
public E set(int index, E element) 修改指定索引處的元素，返回被修改的元素
public E get(int index) 返回指定索引處的元素
public int size() 返回集合中的元素的個數
示例程式碼
public class Test {
public static void main(String[] args) {
/*
public boolean remove(Object o) 刪除指定的元素，返回刪除是否成功
public E remove(int index) 刪除指定索引處的元素，返回被刪除的元素
public E set(int index, E element) 修改指定索引處的元素，返回被修改的元素
public E get(int index) 返回指定索引處的元素
public int size() 返回集合中的元素的個數
*/
// 建立一個ArrayList集合,限制集合中元素的型別為String型別
ArrayList<String> list1 = new ArrayList<>();
// 先往集合中新增一些元素
list1.add("張柏芝");
list1.add("白百合");
list1.add("李小璐");
list1.add("馬蓉");
System.out.println(list1);// [張柏芝, 白百合, 李小璐, 馬蓉]
// 需求:刪除馬蓉這個元素 boolean remove(Object o)
list1.remove("馬蓉");
System.out.println("刪除馬蓉後的集合:" + list1);// [張柏芝, 白百合, 李小璐]
// 需求:刪除索引為1的元素 E remove(int index)
String removeE = list1.remove(1);
System.out.println("被刪除的元素是:" + removeE);// 白百合
System.out.println("刪除索引為1的元素後的集合:" + list1);// [張柏芝, 李小璐]
// 需求:修改索引為1的元素為羅志祥 E set(int index, E element)
String setE = list1.set(1, "羅志祥");
System.out.println("被替換的元素是:" + setE);// 李小璐
System.out.println("替換索引為1的元素後的集合:" + list1);// [張柏芝, 羅志祥]
// 需求:獲取索引為0的元素 E get(int index)
String e = list1.get(0);
System.out.println("0索引上的元素是:" + e);// 張柏芝
// 需求:獲取集合中元素的個數 int size()
int size = list1.size();
System.out.println("集合中元素的個數是:" + size);// 2
// 迴圈遍歷集合中所有元素
for (int i = 0; i < size; i++) {
System.out.println(list1.get(i));
}
}
}
小結
ArrayList常用方法:
public boolean remove(Object o) 刪除指定的元素，返回刪除是否成功
public E remove(int index) 刪除指定索引處的元素，返回被刪除的元素
public E set(int index, E element) 修改指定索引處的元素，返回被修改的元素
public E get(int index) 返回指定索引處的元素
public int size() 返回集合中的元素的個數
擴充套件---問題
public class Test {
public static void main(String[] args) {
/*
1.指定位置新增元素問題
2.刪除元素的問題
如果集合中的元素型別為Integer型別,呼叫remove方法預設是根據索引刪除元素
*/
// 2.刪除元素的問題
// 1.1 建立ArrayList集合,限制集合中元素的型別為Integer型別
ArrayList<Integer> list = new ArrayList<>();
// 1.2 往集合中新增一些元素
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println("刪除元素前的集合:"+list);
// 需求:刪除2這個元素
list.remove(2);// 刪除索引為2的元素
//Integer i = new Integer(2);
// list.remove(i);// 刪除2這個元素
System.out.println("刪除元素後的集合:"+list);
}
// 1.指定位置新增元素問題 void add(int index, E element)
private static void method01() {
// 1.1 建立ArrayList集合,限制集合中元素的型別為String型別
ArrayList<String> list1 = new ArrayList<>();
// 1.2 往集合中新增一些元素
list1.add("謝霆鋒");
list1.add("陳羽凡");
list1.add("王寶強");
list1.add("賈乃亮");
System.out.println(list1);// [謝霆鋒, 陳羽凡, 王寶強, 賈乃亮]
// 需求:把陳冠希新增在索引為5的位置上,行不行?
//list1.add(5, "陳冠希");// 報異常IndexOutOfBoundsException
// 需求:把陳冠希新增在索引為4的位置上,行不行?
// list1.add("陳冠希");// 4索引
list1.add(4, "陳冠希");// 4索引
System.out.println(list1);// [謝霆鋒, 陳羽凡, 王寶強, 賈乃亮, 陳冠希]
}
}
6. ArrayList儲存字串並遍歷
- 建立一個儲存字串的集合，儲存3個字串元素，使用程式實現在控制檯遍歷該集合
分析
- 建立集合物件
- 往集合中新增字串物件
- 遍歷集合，首先要能夠獲取到集合中的每一個元素，這個通過get(int index)方法實現
- 遍歷集合，其次要能夠獲取到集合的長度，這個通過size()方法實現
- 遍歷集合的通用格式
實現
import java.util.ArrayList;
/*
ArrayList儲存字串並遍歷
需求
- 建立一個儲存字串的集合，儲存3個字串元素，使用程式實現在控制檯遍歷該集合
分析:
1.建立ArrayList集合物件,限制集合中元素的型別為String型別
2.往集合物件中儲存3個字串元素 使用add()方法往集合中新增元素
3.獲取集合中元素的個數
4.迴圈遍歷集合中每一個元素
*/
public class Test1ArrayList {
public static void main(String[] args) {
// 1.建立ArrayList集合物件,限制集合中元素的型別為String型別
ArrayList<String> list = new ArrayList<>();
// 2.往集合物件中儲存3個字串元素 使用add()方法往集合中新增元素
list.add("唐三");
list.add("小舞");
list.add("榮榮");
// 3.獲取集合中元素的個數
//int size = list.size();
// 4.迴圈遍歷集合中每一個元素
for (int i = 0;i<list.size();i++){
// 獲取元素,並列印
System.out.println(list.get(i));
}
}
}
7.ArrayList儲存學生物件並遍歷
需求
- 建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合
分析
- 定義學生類
- 建立集合物件
- 建立學生物件
- 新增學生物件到集合中
- 遍歷集合，採用通用遍歷格式實現
實現
import java.util.ArrayList;
/*
ArrayList儲存學生物件並遍歷
需求:
- 建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合
分析:
1.建立學生類
2.建立3個學生物件
3.建立ArrayList集合物件,限制集合中元素的型別為學生類型別
4.往集合中儲存那3個學生物件
5.迴圈遍歷集合中的元素,列印輸出
*/
public class Test2ArrayList {
public static void main(String[] args) {
// 建立3個學生物件
Student stu1 = new Student("蕭炎",18);
Student stu2 = new Student("薰兒",19);
Student stu3 = new Student("美杜莎",20);
// 建立ArrayList集合物件,限制集合中元素的型別為學生類型別
ArrayList<Student> list = new ArrayList<>();
// 往集合中儲存那3個學生物件
list.add(stu1);
list.add(stu2);
list.add(stu3);
// 迴圈遍歷集合中的元素,列印輸出
for (int i = 0;i<list.size();i++){
// 獲取集合元素
Student stu = list.get(i);
// System.out.println("stu:"+stu);// 列印地址值
System.out.println( stu.getName()+","+ stu.getAge());
}
}
}
8.ArrayList儲存學生物件並遍歷升級版
需求
- 建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合 ( 學生的姓名和年齡來自於鍵盤錄入)
分析
- 定義學生類，為了鍵盤錄入資料方便，把學生類中的成員變數都定義為String型別
- 建立集合物件
- 鍵盤錄入學生物件所需要的資料
- 建立學生物件，把鍵盤錄入的資料賦值給學生物件的成員變數
- 往集合中新增學生物件
- 遍歷集合，採用通用遍歷格式實現
實現
/*
思路：
1:定義學生類，為了鍵盤錄入資料方便，把學生類中的成員變數都定義為String型別
2:建立集合物件
3:鍵盤錄入學生物件所需要的資料
4:建立學生物件，把鍵盤錄入的資料賦值給學生物件的成員變數
5:往集合中新增學生物件
6:遍歷集合，採用通用遍歷格式實現
*/
public class ArrayListTest {
public static void main(String[] args) {
//建立集合物件
ArrayList<Student> array = new ArrayList<Student>();
//為了提高程式碼的複用性，我們用方法來改程序序
addStudent(array);
addStudent(array);
addStudent(array);
//遍歷集合，採用通用遍歷格式實現
for (int i = 0; i < array.size(); i++) {
Student s = array.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
}
/*
兩個明確：
返回值型別：void
引數：ArrayList<Student> array
*/
public static void addStudent(ArrayList<Student> array) {
//鍵盤錄入學生物件所需要的資料
Scanner sc = new Scanner(System.in);
System.out.println("請輸入學生姓名:");
String name = sc.nextLine();
System.out.println("請輸入學生年齡:");
String age = sc.nextLine();
//建立學生物件，把鍵盤錄入的資料賦值給學生物件的成員變數
Student s = new Student();
s.setName(name);
s.setAge(age);
//往集合中新增學生物件
array.add(s);
}
}
總結
String類:
概述: 表示不可變的字串
建立字串物件:
1.通過String類的構造方法 堆區
public String();
public String(char[] chs)
public String(byte[] bys);
public String(String str); 例如:String str = new String("abc");// str:"abc"
2.通過雙引號直接賦值的方式 常量池
String str = "abc";
常用方法: 功能
concat(); //把兩個字串拼接起來，獲取一個新的字串
★length(); //獲取字串的長度(其實就是獲取字串中 字元的個數)
★equals(); //比較兩個字串的內容是否相同。 //區分大小寫
equalsIgnoreCase(); //比較兩個字串的內容是否相同。 //忽略大小寫
★charAt(); //根據給定的索引，獲取對應位置的字元
★indexOf(); //獲取指定的字元 在字串中 第一次出現的位置(索引)，找不到返回-1
//int index = a1.indexOf('h'); 從頭找，'h'第一次出現的位置
//int index = a1.indexOf('h',3); 從索引為3的元素開始往後找，'h'第一次出現的位置
lastIndexOf(); //獲取指定的字元 在字串中 最後一次出現的位置(索引)，找不到返回-1
//int index = a1.lastIndexOf('h'); 從尾部找，'h'最後一次出現的位置
//int index = a1.lastIndexOf('h',3); 從索引為3的元素開始往前找，'h'最後一次出現的位置
★substring(); //擷取字串，返回新的字串
//String newStr = a1.substring(2); //從給定索引，直接擷取到字串末尾
//String newStr = a1.substring(2,5); //包左不包右(前閉後開), 能取索引2的元素，不能取索引5的元素
★isEmpty(); //判斷字串是否為空(長度為0返回true，不為0返回false)
★contains(); //判斷字串中是否包含 給定的字串。
endsWith(); //判斷字串是否以 給定的字串 結尾。
startsWith(); //判斷字串是否以 給定的字串 開頭。
★replace(); //用新內容替代舊內容，返回新的字串
toLowerCase(); //把字母都轉成其對應的小寫形式。
toUpperCase(); //把字母都轉成其對應的大寫形式。
toCharArray() // 把字串轉換為陣列
getBytes() // 把字串轉換為位元組陣列
★trim(); //移除首尾空格。
★split(); //根據給定的內容，切割字串，返回字串陣列
StringBuilder:
概述: 表示可變的字串
建立StringBuilder物件:
StringBuilder();
StringBuilder(String str)
常用方法:
StringBuilder append(任意資料) 拼接
StringBuilder insert(int index,任意資料) 插入
StringBuilder reverse() 反轉
String toString() 轉換為String物件
ArrayList<E>:
使用: 在出現E的位置寫指定的引用資料型別替換,用來限制集合中元素的資料型別
概述: 表示集合物件
作用: 可以儲存多個不固定數量的引用資料型別的資料
構造方法:
ArrayList();
成員方法:
add(E e) 在末尾增加元素
add(int index, E e) 在指定位置新增元素
remove(Object e) 刪除指定的元素
remove(int index) 刪除指定索引位置上的元素
set(int index,E e) 替換指定索引位置上的元素
get(int index) 根據指定索引獲取元素
size() 獲取集合元素個數(大小,長度)
- 能夠知道字串物件通過構造方法建立和直接賦值的區別
字串物件通過構造方法建立:每次new都會在堆區建立物件,哪怕字串內容一樣,都會新建立物件
直接賦值: 存在常量池,如果字串內容一樣,就不會建立新的字串物件,直接共享
- 能夠完成使用者登入案例
1.定義一個使用者名稱和密碼的字串
2.獲取使用者輸入的使用者名稱和密碼
3.拿使用者輸入的使用者名稱和密碼與定義的使用者名稱和密碼進行比較,如果都相同,就登入成功,否則就登入失敗
- 能夠完成統計字串中大寫,小寫,數字字元的個數
1.定義3個統計變數,分別統計大寫,小寫,數字字元的個數
2.迴圈遍歷字串,根據索引獲取字串的每一個字元
3.判斷,計數
- 能夠知道String和StringBuilder的區別
String: 不可變
StringBuilder:可變
- 能夠完成String和StringBuilder的相互轉換
String---StringBuilder: public StingBuilder(String str)
StringBuilder---String: String toString();
- 能夠使用StringBuilder完成字串的拼接
StringBuilder append(任意資料);
- 能夠使用StringBuilder完成字串的反轉
StringBuilder reverse();
- 能夠知道集合和陣列的區別
1.集合的長度是不固定的,陣列的長度是固定的
2.集合中元素的型別是引用資料型別,陣列中的元素型別可以是集合資料型別,也可以是引用資料型別
3.集合中元素的型別可以不一致,陣列中元素的型別必須一致
- 能夠完成ArrayList集合新增字串並遍歷
1.建立ArrayList集合
2.往集合中新增字串元素
3.迴圈遍歷,根據索引獲取元素
- 能夠完成ArrayList集合新增學生物件並遍歷
1.建立ArrayList集合
2.往集合中新增學生物件元素
3.迴圈遍歷,根據索引獲取元素