2. 程式人生 > 其它 >Java基礎（01）-15總結物件陣列，集合Collection，集合List

Java基礎（01）-15總結物件陣列，集合Collection，集合List

阿新 • • 發佈：2022-05-04
1:物件陣列(掌握)

(1)陣列既可以儲存基本資料型別，也可以儲存引用型別。它儲存引用型別的時候的陣列就叫物件陣列。

(2)案例：

用陣列儲存5個學生物件，並遍歷陣列。

package cn.itcast_01;
public class Student {
 // 成員變數
 private String name;
 private int age;
 // 構造方法
 public Student() {
 super();
 }
 public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
 }
 // 成員方法
 // getXxx()/setXxx()
 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;
 }
 @Override
 public String toString() {
 return "Student [name=" + name + ", age=" + age + "]";
 }
}
package cn.itcast_01;
/*
 * 我有5個學生，請把這個5個學生的資訊儲存到陣列中，並遍歷陣列，獲取得到每一個學生資訊。
 *  學生：Student
 *  成員變數：name,age
 *  構造方法：無參,帶參
 *  成員方法：getXxx()/setXxx()
 *  儲存學生的陣列?自己想想應該是什麼樣子的?
 * 分析：
 *  A:建立學生類。
 *  B:建立學生陣列(物件陣列)。
 *  C:建立5個學生物件，並賦值。
 *  D:把C步驟的元素，放到陣列中。
 *  E:遍歷學生陣列。
 */
public class ObjectArrayDemo {
 public static void main(String[] args) {
 // 建立學生陣列(物件陣列)。
 Student[] students = new Student[5];
 // for (int x = 0; x < students.length; x++) {
 // System.out.println(students[x]);
 // }
 // System.out.println("---------------------");
 // 建立5個學生物件，並賦值。
 Student s1 = new Student("林青霞", 27);
 Student s2 = new Student("風清揚", 30);
 Student s3 = new Student("劉意", 30);
 Student s4 = new Student("趙雅芝", 60);
 Student s5 = new Student("王力巨集", 35);
 // 把C步驟的元素，放到陣列中。
 students[0] = s1;
 students[1] = s2;
 students[2] = s3;
 students[3] = s4;
 students[4] = s5;
 // 看到很相似，就想迴圈改
 // for (int x = 0; x < students.length; x++) {
 // students[x] = s + "" + (x + 1);
 // }
 // 這個是有問題的
 // 遍歷
 for (int x = 0; x < students.length; x++) {
 //System.out.println(students[x]);
 Student s = students[x];
 System.out.println(s.getName()+"---"+s.getAge());
 }
 }
}

2:集合(Collection)(掌握)

(1)集合的由來?

我們學習的是Java -- 面向物件 -- 操作很多物件 -- 儲存 -- 容器(陣列和StringBuffer) -- 陣列

而陣列的長度固定，所以不適合做變化的需求，Java就提供了集合供我們使用。

(集合的由來：

我們學習的語言是面向物件的語言，name既然是面向物件的語言，那麼對事物的描述都是用過物件進行體現的，那麼為了方便的操作多個物件

那麼我們就需要將多個物件儲存起來，那麼既然要儲存多個物件，我們就需要找一個容器型別的變數進行儲存。那麼我們都學過哪些容器型別的變數呢？

陣列（物件陣列），字串緩衝區，而我們的陣列滿足不了我們的)

(2)集合和陣列的區別?

A:長度區別

陣列固定

集合可變

B:內容區別（儲存資料型別區別）

陣列可以是基本型別，也可以是引用型別

集合只能是引用型別

C:元素內容區別

陣列只能儲存同一種類型

集合可以儲存不同型別(其實集合一般儲存的也是同一種類型)

(3)集合的繼承體系結構?

由於需求不同，Java就提供了不同的集合類。這多個集合類的資料結構不同，但是它們都是要提供儲存和遍歷功能的，

我們把它們的共性不斷的向上提取，最終就形成了集合的繼承體系結構圖。

Collection

|--List

|--ArrayList

|--Vector

|--LinkedList

|--Set

|--HashSet

|--TreeSet

(4)Collection的功能概述(自己補齊)

A:新增功能

B:刪除功能

C:判斷功能

D:獲取功能

E:長度功能

F:交集(瞭解)

G:把集合轉陣列(瞭解)

package cn.itcast_01;
import java.util.ArrayList;
import java.util.Collection;
/*
 * 集合的由來：
 *  我們學習的是面嚮物件語言，而面嚮物件語言對事物的描述是通過物件體現的，為了方便對多個物件進行操作，我們就必須把這多個物件進行儲存。
 *  而要想儲存多個物件，就不能是一個基本的變數，而應該是一個容器型別的變數，在我們目前所學過的知識裡面，有哪些是容器型別的呢?
 *  陣列和StringBuffer。但是呢?StringBuffer的結果是一個字串，不一定滿足我們的要求，所以我們只能選擇陣列，這就是物件陣列。
 *  而物件陣列又不能適應變化的需求，因為陣列的長度是固定的，這個時候，為了適應變化的需求，Java就提供了集合類供我們使用。
 * 
 * 陣列和集合的區別?
 *  A:長度區別
 *  陣列的長度固定
 *  集合長度可變
 *  B:內容不同
 *  陣列儲存的是同一種類型的元素
 *  而集合可以儲存不同型別的元素
 *  C:元素的資料型別問題 
 *  陣列可以儲存基本資料型別，也可以儲存引用資料型別
 *  集合只能儲存引用型別
 * 
 * 剛說過集合是儲存多個元的，但是呢，儲存多個元素我們也是有不同需求的：比如說，我要這多個元素中不能有相同的元素，
 * 再比如說，我要這多個元素按照某種規則排序一下。針對不同的需求，Java就提供了不同的集合類，這樣呢，Java就提供了很多個集合類。
 * 這多個集合類的資料結構不同,結構不同不重要的，重要的是你要能夠儲存東西，並且還要能夠使用這些東西，比如說判斷，獲取等。
 * 既然這樣，那麼，這多個集合類是有共性的內容的，我們把這些集合類的共性內容不斷的向上提取，最終就能形成集合的繼承體系結構。
 * 
 * 資料結構：資料的儲存方式。
 * 
 * Collection:是集合的頂層介面，它的子體系有重複的，有唯一的，有有序的，有無序的。(後面會慢慢的講解)
 * 
 * Collection的功能概述：
 * 1：新增功能
 *  boolean add(Object obj):新增一個元素
 *  boolean addAll(Collection c):新增一個集合的元素
 * 2:刪除功能
 *  void clear():移除所有元素
 *  boolean remove(Object o):移除一個元素
 *  boolean removeAll(Collection c):移除一個集合的元素(是一個還是所有)
 * 3:判斷功能
 *  boolean contains(Object o)：判斷集合中是否包含指定的元素
 *  boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(是一個還是所有)
 *  boolean isEmpty()：判斷集合是否為空
 * 4:獲取功能
 *  Iterator<E> iterator()(重點)
 * 5:長度功能
 *  int size():元素的個數
 *  面試題：陣列有沒有length()方法呢?字串有沒有length()方法呢?集合有沒有length()方法呢?
 * 6:交集功能
 *  boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
 * 7：把集合轉換為陣列
 *  Object[] toArray()
 * 基礎功能
 */
public class CollectionDemo {
 public static void main(String[] args) {
 // 測試不帶All的方法
 // 建立集合物件
 // Collection c = new Collection(); //錯誤，因為介面不能例項化
 Collection c = new ArrayList();
 // boolean add(Object obj):新增一個元素
 // System.out.println("add:"+c.add("hello"));
 c.add("hello");
 c.add("world");
 c.add("java");
 // void clear():移除所有元素
 // c.clear();
 // boolean remove(Object o):移除一個元素
 // System.out.println("remove:" + c.remove("hello"));
 // System.out.println("remove:" + c.remove("javaee"));
 // boolean contains(Object o)：判斷集合中是否包含指定的元素
 // System.out.println("contains:"+c.contains("hello"));
 // System.out.println("contains:"+c.contains("android"));
 // boolean isEmpty()：判斷集合是否為空
 // System.out.println("isEmpty:"+c.isEmpty());
 //int size():元素的個數
 System.out.println("size:"+c.size());
 System.out.println("c:" + c);
 }
}
package cn.itcast_01;
import java.util.ArrayList;
import java.util.Collection;
/* 高階功能
 * boolean addAll(Collection c):新增一個集合的元素
 * boolean removeAll(Collection c):移除一個集合的元素(是一個以上）
 * boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(包含所有的算是包含)
 * boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
   A對B取交集，獲取到的交集元素儲存到A中去了；返回的boolean值表示的意思是集合A是否發生變化發生變化是true否則是false。
 */
public class CollectionDemo2 {
 public static void main(String[] args) {
 // 建立集合1
 Collection c1 = new ArrayList();
 c1.add("abc1");
 c1.add("abc2");
 c1.add("abc3");
 c1.add("abc4");
 // 建立集合2
 Collection c2 = new ArrayList();
// c2.add("abc1");
// c2.add("abc2");
// c2.add("abc3");
// c2.add("abc4");
 c2.add("abc5");
 c2.add("abc6");
 c2.add("abc7");
 // boolean addAll(Collection c):新增一個集合的元素
 // System.out.println("addAll:" + c1.addAll(c2));
 //boolean removeAll(Collection c):移除一個集合的元素(是一個還是所有)
 //只要有一個元素被移除了，就返回true。
 //System.out.println("removeAll:"+c1.removeAll(c2));
 //boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(是一個還是所有)
 //只有包含所有的元素，才叫包含
 // System.out.println("containsAll:"+c1.containsAll(c2));
 //boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
 //假設有兩個集合A，B。
 //A對B做交集，最終的結果儲存在A中，B不變。
 //返回值表示的是A是否發生過改變。
 System.out.println("retainAll:"+c1.retainAll(c2));
 System.out.println("c1:" + c1);
 System.out.println("c2:" + c2);
 }
}

(5)Collection集合的遍歷

A:把集合轉陣列(瞭解)

B:迭代器(集合專用方式)

package cn.itcast_01;
import java.util.ArrayList;
import java.util.Collection;
/*
 * 集合的遍歷。其實就是依次獲取集合中的每一個元素。
 * 
 * Object[] toArray():把集合轉成陣列，可以實現集合的遍歷
 */
public class CollectionDemo3 {
 public static void main(String[] args) {
 // 建立集合物件
 Collection c = new ArrayList();
 // 新增元素
 c.add("hello"); // Object obj = "hello"; 向上轉型
 c.add("world");
 c.add("java");
 // 遍歷
 // Object[] toArray():把集合轉成陣列，可以實現集合的遍歷
 Object[] objs = c.toArray();
 for (int x = 0; x < objs.length; x++) {
 // System.out.println(objs[x]);
 // 我知道元素是字串，我在獲取到元素的的同時，還想知道元素的長度。
 // System.out.println(objs[x] + "---" + objs[x].length());
 // 上面的實現不了，原因是Object中沒有length()方法
 // 我們要想使用字串的方法，就必須把元素還原成字串
 // 向下轉型
 String s = (String) objs[x];
 System.out.println(s + "---" + s.length());
 }
 }
}

C: 案例：Collection集合儲存自定義物件，把集合轉換成陣列在遍歷

package cn.itcast_02;(1)
public class Student {
 // 成員變數
 private String name;
 private int age;
 // 構造方法
 public Student() {
 super();
 }
 public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
 }
 // 成員方法
 // getXxx()/setXxx()
 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;
 }
}
package cn.itcast_02;(2)
import java.util.ArrayList;
import java.util.Collection;
/*
 * 練習：用集合儲存5個學生物件，並把學生物件進行遍歷。
 * 
 * 分析：
 * A:建立學生類
 * B:建立集合物件
 * C:建立學生物件
 * D:把學生新增到集合
 * E:把集合轉成陣列
 * F:遍歷陣列
 */
public class StudentDemo {
 public static void main(String[] args) {
 // 建立集合物件
 Collection c = new ArrayList();
 // 建立學生物件
 Student s1 = new Student("林青霞", 27);
 Student s2 = new Student("風清揚", 30);
 Student s3 = new Student("令狐沖", 33);
 Student s4 = new Student("武鑫", 25);
 Student s5 = new Student("劉曉曲", 22);
 // 把學生新增到集合
 c.add(s1);
 c.add(s2);
 c.add(s3);
 c.add(s4);
 c.add(s5);
 // 把集合轉成陣列
 Object[] objs = c.toArray();
 // 遍歷陣列
 for (int x = 0; x < objs.length; x++) {
 // System.out.println(objs[x]);
 Student s = (Student) objs[x];
 System.out.println(s.getName() + "---" + s.getAge());
 }
 }
}

(6)迭代器

A:是集合的獲取元素的方式。

B:是依賴於集合而存在的。

C:迭代器的原理和原始碼。

a:為什麼定義為了一個介面而不是實現類?

假如我們把迭代器定義成一個類，我們就需要給出具體的方法的實現。而我們都知道不同的集合的資料結構不同，就是說資料儲存方式不同；那麼既然儲存方式不同，獲取方式能相同嗎？

不能相同，所以我們的獲取元素的方法能給出具體的實現嗎？

不能給出具體的實現。所以這個方法就應該定義為抽象方法。那麼我們就可以把這個迭代器的類定義為抽象類，可以實現，為什麼

b:看了看迭代器的內部類實現。

package cn.itcast_03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
 * Iterator iterator():迭代器，集合的專用遍歷方式
 *  Object next():獲取元素,並移動到下一個位置。
 *  NoSuchElementException：沒有這樣的元素，因為你已經找到最後了。
 *  boolean hasNext():如果仍有元素可以迭代，則返回 true。（
 */
public class IteratorDemo {
 public static void main(String[] args) {
 // 建立集合物件
 Collection c = new ArrayList();
 // 建立並新增元素
 // String s = "hello";
 // c.add(s);
 c.add("hello");
 c.add("world");
 c.add("java");
 // Iterator iterator():迭代器，集合的專用遍歷方式
 Iterator it = c.iterator(); // 實際返回的肯定是子類物件，這裡是多型
 // Object obj = it.next();
 // System.out.println(obj);
 // System.out.println(it.next());
 // System.out.println(it.next());
 // System.out.println(it.next());
 // System.out.println(it.next());
 // 最後一個不應該寫，所以，我們應該在每次獲取前，如果有一個判斷就好了
 // 判斷是否有下一個元素，有就獲取，沒有就不搭理它
 // if (it.hasNext()) {
 // System.out.println(it.next());
 // }
 // if (it.hasNext()) {
 // System.out.println(it.next());
 // }
 // if (it.hasNext()) {
 // System.out.println(it.next());
 // }
 // if (it.hasNext()) {
 // System.out.println(it.next());
 // }
 // if (it.hasNext()) {
 // System.out.println(it.next());
 // }
 // 最終版程式碼  獲取元素
 while (it.hasNext()) {
 // System.out.println(it.next());
 String s = (String) it.next();
 System.out.println(s);
 }
 }
}
迭代器原始碼：
public interface Inteator {
 boolean hasNext();
 Object next(); 
}
public interface Iterable {
    Iterator iterator();
}
public interface Collection extends Iterable {
 Iterator iterator();
}
public interface List extends Collection {
 Iterator iterator();
}
public class ArrayList implements List {
 public Iterator iterator() {
        return new Itr();
    }
    private class Itr implements Iterator {
  public boolean hasNext() {}
 public Object next(){} 
    }
}
Collection c = new ArrayList();
c.add("hello");
c.add("world");
c.add("java");
Iterator it = c.iterator();  //new Itr();
while(it.hasNext()) {
 String s = (String)it.next();
 System.out.println(s);
}
 (7)Collection集合的案例(遍歷方式 迭代器)   【重點**********】
 集合的操作步驟：
 A:建立集合物件
 B:建立元素物件
 C:把元素新增到集合
 D:遍歷集合
 A:儲存字串並遍歷
 import java.util.Collection;
 import java.util.ArrayList;
 import java.util.Iterator;
 public class CollectionDemo {
 public static void main(String[] args) {
 //建立集合物件
 Collection c = new ArrayList();
 //建立並新增元素
 c.add("hello");
 c.add("world");
 c.add("java");
 //遍歷集合
 Iterator it = c.iterator();
 while(it.hasNext()) {
 String s =(String) it.next();
 System.out.println(s);
 }
 }
 }

B:儲存自定義物件並遍歷

 public class Student {
 private String name;
 private int age;
 public Student(){}
 public Student(String name,int age) {
 this.name = name;
 this.age = age;
 }
 //getXxx()/setXxx()
 }
 import java.util.Collection;
 import java.util.ArrayList;
 import java.util.Iterator;
 public class StudentDemo {
 public static void main(String[] args) {
 //建立集合物件
 Collection c = new ArrayList();
 //建立學生物件
 Student s1 = new Student("林青霞",27);
 Student s2 = new Student("風清揚",30);
 Student s3 = new Student("劉意",30);
 Student s4 = new Student("武鑫",25);
 Student s5 = new Student("劉曉曲",16);
 //新增元素
 c.add(s1);
 c.add(s2);
 c.add(s3);
 c.add(s4);
 c.add(s5);
 //遍歷集合
 Iterator it = c.iterator();
 while(it.hasNext()) {
 Student s = (Student)it.next();
 System.out.println(s.getName()+"---"+s.getAge());
 }
 }
 }
package cn.itcast_03;(一)
public class Student {
 // 成員變數
 private String name;
 private int age;
 // 構造方法
 public Student() {
 super();
 }
 public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
 }
 // 成員方法
 // getXxx()/setXxx()
 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;
 }
 @Override
 public String toString() {
 return "Student [name=" + name + ", age=" + age + "]";
 }
}
package cn.itcast_03;(二)
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
 * 練習：用集合儲存5個學生物件，並把學生物件進行遍歷。用迭代器遍歷。
 * 
 * 注意：
 *  A:自己的類名不要和我們學習的要使用的API中的類名相同。
 *  B:複製程式碼的時候，很容易把那個類所在的包也匯入過來，容易出現不能理解的問題。
 */
public class IteratorTest {
 public static void main(String[] args) {
 // 建立集合物件
 Collection c = new ArrayList();
 // 建立學生物件
 Student s1 = new Student("林青霞", 27);
 Student s2 = new Student("風清揚", 30);
 Student s3 = new Student("令狐沖", 33);
 Student s4 = new Student("武鑫", 25);
 Student s5 = new Student("劉曉曲", 22);
 // 把學生新增到集合中
 c.add(s1);
 c.add(s2);
 c.add(s3);
 c.add(s4);
 c.add(s5);
 // 遍歷
 Iterator it = c.iterator();
 while (it.hasNext()) {
 // System.out.println(it.next());
 Student s = (Student) it.next();
 System.out.println(s.getName() + "---" + s.getAge());
 }
 }
}
package cn.itcast_03;(三)
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
 * 問題1:能用while迴圈寫這個程式，我能不能用for迴圈呢?
 * 問題2:不要多次使用it.next()方法，因為每次使用都是訪問一個物件。
 */
public class IteratorTest2 {
 public static void main(String[] args) {
 // 建立集合物件
 Collection c = new ArrayList();
 // 建立學生物件
 Student s1 = new Student("林青霞", 27);
 Student s2 = new Student("風清揚", 30);
 Student s3 = new Student("令狐沖", 33);
 Student s4 = new Student("武鑫", 25);
 Student s5 = new Student("劉曉曲", 22);
 // 把學生新增到集合中
 c.add(s1);
 c.add(s2);
 c.add(s3);
 c.add(s4);
 c.add(s5);
 // 遍歷
 Iterator it = c.iterator();
 while (it.hasNext()) {
 Student s = (Student) it.next();
 System.out.println(s.getName() + "---" + s.getAge());
 // NoSuchElementException 不要多次使用it.next()方法
 // System.out.println(((Student) it.next()).getName() + "---"
 // + ((Student) it.next()).getAge());
 }
 // System.out.println("----------------------------------");
 // for迴圈改寫
 // for(Iterator it = c.iterator();it.hasNext();){
 // Student s = (Student) it.next();
 // System.out.println(s.getName() + "---" + s.getAge());
 // }
 }
}

相關推薦

Java基礎（01）-15總結物件陣列，集合Collection，集合List

1:物件陣列(掌握) (1)陣列既可以儲存基本資料型別，也可以儲存引用型別。它儲存引用型別的時候的陣列就叫物件陣列。

Java基礎（02）-15總結物件陣列，集合Collection，集合List

3:集合(List)(掌握) (1)List是Collection的子介面 特點：有序(儲存順序和取出順序一致)，可重複。

Java 基礎（一） -- 面向物件

面向過程和麵向物件的區別 什麼是面向過程（pop） 面向過程（Process-oriented programming）是一種以事件為中心的程式設計思想。就是分析出解決問題所需要的步驟，然後用函式把這些步驟全部實現，然後按照順序依次呼

Java基礎（7）— 面向物件

面向物件 初識面向物件 面向過程&面向物件 面向過程 線性思維，步驟清晰簡單，第一步做什麼，第二步做什麼

java基礎（4）

1.集合 概述：面嚮物件語言對事物的體現都是以物件的形式，所有為了方便對多個物件的操作，我們就必須把這多個物件進行儲存，而想儲存多個物件，就不能是一個基本的變數，而應該是一個容器型別的變數，陣列可以滿足這

Java基礎（2）— 入門

Java入門 帝國的誕生 1972年，C誕生。 C語言的優點 "貼近硬體，執行極快，效率極高"，能夠應用在"作業系統，編譯器，資料庫，網路系統"等，但是"指標和記憶體管理"比較繁瑣

Java基礎（8）— 異常

異常機制 什麼是異常 實際工作中，遇到的情況不可能是非常完美的。比如:你寫的某個模組，使用者輸入不一定符合你的要求。你的程式要開啟某個檔案，這個檔案可能不存在或者檔案格式不對，你要讀取資料庫的資料，資料

java基礎（9）

1.類載入器 類的載入： 概述：當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過載入，連線，初始化三步來實現對這個類的初始化

java基礎（8）

1.網路程式設計 概述：就是用來實現網路互連的不同計算機上執行的程式間可以進行資料交換

Java基礎（9）— 常用類

常用類 Object類 java.lang.Object 是Java語言的根類，即所有類的父類 Object類中包含11個方法如下

Java基礎（10）— 集合框架

集合框架 常見的資料結構 資料儲存的常用結構有：棧、佇列、陣列、連結串列和紅黑樹。我們分別來了解一下：

JavaSE學習之回顧Java基礎（二）

一、流程控制 1.Scanner（System.in） 使用者互動 2.順序結構 程式預設的結構，自上而下地執行

Java基礎（12）— 多執行緒

多執行緒 程序Process與執行緒Thread 說起程序，就不得不說下程式。程式是指令和資料的有序集合，其本身沒有任何執行的含義，是一個靜態的概念

Java基礎（1）---陣列

1. 概念 陣列是有序的元素序列，相同型別的有限的元素的集合。陣列的元素儲存在一個連續性的記憶體空間中，並通過索引訪問。

Java基礎（七）——網路程式設計

技術標籤：Java基礎系列文章java網路 版本說明釋出日期1.0釋出文章第一版2020-12-29

java基礎（五）——多重迴圈經典示例

技術標籤：java java基礎（五）——多重迴圈經典示例 一、列印三角形和平行四邊形二、九九乘法表1.break及return的用法2.continue的用法

#Java基礎（複習）

Java基礎（複習） 環境 JDK、JRE和JVM JRE=JVM+JavaSE標準類庫 JDK=JRE+開發工具集（例如Javac編譯工具）

Java基礎（7）

技術標籤：Java基礎Java基礎java程式語言 文章目錄 Java集合、泛型和列舉Java 8中Map新增的方法Java Collections類操作集合詳解排序（正向和逆向）查詢、替換操作複製

（轉）某Java大佬在地表最強Java企業（阿里）面試總結

技術標籤：javajava 原文連結：https://blog.csdn.net/weixin_46285416/article/details/108186216

Java基礎（6）

技術標籤：Java基礎java字串Java基礎 文章目錄 Java集合、泛型和列舉Java集合詳解Java Collection介面詳解Java List集合：ArrayList和LinkedList類的用法及區別ArrayList 類LinkedList類ArrayList 類和 Linked