1:List的子類(掌握)
(1)List的子類特點
ArrayList:
底層數據結構是數組，查詢快，增刪慢
線程不安全，效率高
Vector:
底層數據結構是數組，查詢快，增刪慢
線程安全，效率低
LinkedList:
底層數據結構是鏈表，查詢慢，增刪快
線程不安全，效率高
(2)ArrayList
A:沒有特有功能需要學習
B:案例
a:ArrayList存儲字符串並遍歷
b:ArrayList存儲自定義對象並遍歷
(3)Vector
A:有特有功能
a:添加
public void addElement(E obj)--add()
b:獲取
public E elementAt(int index)--get()
public Enumeration<E> elements()-- iterator()
B:案例
a:Vector存儲字符串並遍歷
import java.util.Enumeration;
import java.util.Vector;
/*
* Vector的特有功能：
* 1：添加功能
* public void addElement(Object obj) -- add()
* 2：獲取功能
* public Object elementAt(int index) -- get()
* public Enumeration elements() -- Iterator iterator()
* boolean hasMoreElements() hasNext()
* Object nextElement() next()
*
* JDK升級的原因：
* A:安全
* B:效率
* C:簡化書寫
*/
public class VectorDemo {
public static void main(String[] args) {
// 創建集合對象
Vector v = new Vector();
// 添加功能
v.addElement("hello");
v.addElement("world");
v.addElement("java");
// 遍歷
for (int x = 0; x < v.size(); x++) {
String s = (String) v.elementAt(x);
System.out.println(s);
}
System.out.println("------------------");
Enumeration en = v.elements(); // 返回的是實現類的對象
while (en.hasMoreElements()) {
String s = (String) en.nextElement();
System.out.println(s);
}
}
}
b:Vector存儲自定義對象並遍歷
(4)LinkedList
A:有特有功能
a:添加
addFirst()
addLast()
b:刪除
removeFirst()
removeLast()
c:獲取
getFirst()
getLast()
import java.util.LinkedList;
/*
* LinkedList的特有功能：
* A:添加功能
* public void addFirst(Object e)
* public void addLast(Object e)
* B:獲取功能
* public Object getFirst()
* public Obejct getLast()
* C:刪除功能
* public Object removeFirst()
* public Object removeLast()
*/
public class LinkedListDemo {
public static void main(String[] args) {
// 創建集合對象
LinkedList link = new LinkedList();
// 添加元素
link.add("hello");
link.add("world");
link.add("java");
// public void addFirst(Object e)
// link.addFirst("javaee");
// public void addLast(Object e)
// link.addLast("android");
// public Object getFirst()
// System.out.println("getFirst:" + link.getFirst());
// public Obejct getLast()
// System.out.println("getLast:" + link.getLast());
// public Object removeFirst()
System.out.println("removeFirst:" + link.removeFirst());
// public Object removeLast()
System.out.println("removeLast:" + link.removeLast());
// 輸出對象名
System.out.println("link:" + link);
}
}
B:案例
a:LinkedList存儲字符串並遍歷
b:LinkedList存儲自定義對象並遍歷
(5)案例：
A:去除集合中的多個字符串的重複元素
如果字符串的內容相同，即爲重複元素
test：
用新的集合來裝各個不重複的元素
import java.util.ArrayList;
public class class4 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("111");
list.add("222");
list.add("333");
list.add("111");
list.add("444");
list.add("222");
System.out.println("list:" + list);
ArrayList list2 = new ArrayList();
// Iterator it = list.iterator();
// while (it.hasNext()) {
// String s = (String) it.next();
// if (!list2.contains(s)) {
// list2.add(s);
// }
//
// }
// 循環提取list的元素
for (int i = 0; i < list.size(); i++) {
// 如果list2不包含提取到的元素，就添加進list2
if (!list2.contains(list.get(i))) {
list2.add(list.get(i));
}
}
System.out.println("list2:" + list2);
}
}
輸出：
list:[111, 222, 333, 111, 444, 222]
list2:[111, 222, 333, 444]
Test2：
不能新建集合，使用原集合
/**
* 去除集合中的重複元素，不能新建集合
*/
import java.util.ArrayList;
public class class4 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("111");
list.add("222");
list.add("333");
list.add("111");
list.add("111");
list.add("111");
list.add("444");
list.add("222");
list.add("111");
list.add("444");
System.out.println("list:" + list);
// 雙層循環實現
for (int i = 0; i < list.size(); i++) {
// 外層逐個提取元素，內層爲外層元素逐一取比對的元素
// 由於不能自身對比會誤判，所以j=I+1
for (int j = i + 1; j < list.size(); j++) {
// 如果對比相同，則把靠後面的元素刪除
if (list.get(i) == list.get(j)) {
list.remove(j);
//由於有連續重複的元素，刪除元素後繼續搜索會漏掉一個
//所以需要回退一部繼續判斷
j--;
}
}
}
System.out.println("new list:" + list);
}
}
輸出：
list:[111, 222, 333, 111, 111, 111, 444, 222, 111, 444]
new list:[111, 222, 333, 444]
B:去除集合中的多個自定義對象的重複元素
如果自定義對象的成員變量值都相同，即爲重複元素
Test:
import java.util.ArrayList;
public class Test5 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Student("張三", 12));
list.add(new Student("李四", 13));
list.add(new Student("王五", 14));
list.add(new Student("張三", 13));
list.add(new Student("李四", 13));
list.add(new Student("王五", 14));
list.add(new Student("張三", 12));
list.add(new Student("李四", 13));
list.add(new Student("張三", 12));
// 雙層循環實現
// 外循環逐個提取元素
for (int i = 0; i < list.size(); i++) {
// 內循環提取待比較的各個元素
for (int j = i + 1; j < list.size(); j++) {
// 轉換成 原始數據類型
Student s = (Student) list.get(i);
Student s2 = (Student) list.get(j);
// 如果兩個引用類型的兩個值（name，age）都相同則判定相同，刪除靠後的元素
if (s.getName() == s2.getName() && s.getAge() == s2.getAge()) {
list.remove(j);
j--;
}
}
}
// 遍歷集合
for (int i = 0; i < list.size(); i++) {
Student s = (Student) list.get(i);
System.out.println(s.getName() + "\t" + s.getAge());
}
}
}
輸出：
張三12
李四13
王五14
張三13
C:用LinkedList模擬一個棧數據結構的集合類，並測試。
你要定義一個集合類，只不過內部可以使用LinkedList來實現。
2:泛型(掌握)
(1)泛型概述
是一種把明確類型的工作推遲到創建對象或者調用方法的時候纔去明確的特殊的類型。
(2)格式：
<數據類型>
注意：該數據類型只能是引用類型。
(3)好處：
A:把運行時期的問題提前到了編譯期間
B:避免了強制類型轉換
C:優化了程序設計，解決了黃色警告線問題，讓程序更安全
(4)泛型的前世今生
A:泛型的由來
Object類型作爲任意類型的時候，在向下轉型的時候，會隱含一個轉型問題
B:泛型類
C:泛型方法
D:泛型接口
E:泛型高級通配符
? 任意類型，如果沒有明確，那麼就是Object以及任意的Java類了
? extends E 向下限定，只能使用E及其子類
? super E 向上限定，只能使用E及其父類
import java.util.ArrayList;
import java.util.Collection;
/*
* 泛型高級(通配符)
* ?:任意類型，如果沒有明確，那麼就是Object以及任意的Java類了
* ? extends E:向下限定，E及其子類
* ? super E:向上限定，E極其父類
*/
public class GenericDemo {
public static void main(String[] args) {
// 泛型如果明確的寫的時候，前後必須一致
Collection<Object> c1 = new ArrayList<Object>();
// Collection<Object> c2 = new ArrayList<Animal>();
// Collection<Object> c3 = new ArrayList<Dog>();
// Collection<Object> c4 = new ArrayList<Cat>();
// ?表示任意的類型都是可以的
Collection<?> c5 = new ArrayList<Object>();
Collection<?> c6 = new ArrayList<Animal>();
Collection<?> c7 = new ArrayList<Dog>();
Collection<?> c8 = new ArrayList<Cat>();
// ? extends E:向下限定，E及其子類
// Collection<? extends Animal> c9 = new ArrayList<Object>();
Collection<? extends Animal> c10 = new ArrayList<Animal>();
Collection<? extends Animal> c11 = new ArrayList<Dog>();
Collection<? extends Animal> c12 = new ArrayList<Cat>();
// ? super E:向上限定，E極其父類
Collection<? super Animal> c13 = new ArrayList<Object>();
Collection<? super Animal> c14 = new ArrayList<Animal>();
// Collection<? super Animal> c15 = new ArrayList<Dog>();
// Collection<? super Animal> c16 = new ArrayList<Cat>();
}
}
class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
(5)我們在哪裏使用呢?
一般是在集合中使用。
3:增強for循環(掌握)
(1)是for循環的一種
(2)格式：
for(元素的數據類型 變量名 : 數組或者Collection集合的對象) {
使用該變量即可，該變量其實就是數組或者集合中的元素。
}
(3)好處：
簡化了數組和集合的遍歷
(4)弊端
增強for循環的目標不能爲null。建議在使用前，先判斷是否爲null。
Test：
import java.util.ArrayList;
import java.util.List;
/*
* JDK5的新特性：自動拆裝箱,泛型,增強for,靜態導入,可變參數,枚舉
*
* 增強for:是for循環的一種。
*
* 格式：
* for(元素數據類型 變量 : 數組或者Collection集合) {
* 使用變量即可，該變量就是元素
* }
*
* 好處：簡化了數組和集合的遍歷。
*
* 弊端： 增強for的目標不能爲null。
* 如何解決呢?對增強for的目標先進行不爲null的判斷，然後在使用。
*/
public class ForDemo {
public static void main(String[] args) {
// 定義一個int數組
int[] arr = { 1, 2, 3, 4, 5 };
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
System.out.println("---------------");
// 增強for
for (int x : arr) {
System.out.println(x);
}
System.out.println("---------------");
// 定義一個字符串數組
String[] strArray = { "林青霞", "風清揚", "東方不敗", "劉意" };
// 增強for
for (String s : strArray) {
System.out.println(s);
}
System.out.println("---------------");
// 定義一個集合
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
// 增強for
for (String s : array) {
System.out.println(s);
}
System.out.println("---------------");
List<String> list = null;
// NullPointerException
// 這個s是我們從list裏面獲取出來的，在獲取前，它肯定還好做一個判斷
// 說白了，這就是迭代器的功能
if (list != null) {
for (String s : list) {
System.out.println(s);
}
}
// 增強for其實是用來替代迭代器的
//ConcurrentModificationException
// for (String s : array) {
// if ("world".equals(s)) {
// array.add("javaee");
// }
// }
// System.out.println("array:" + array);
}
}
Test2:
三種方法遍歷字符串集合
import java.util.ArrayList;
import java.util.Iterator;
/*
* ArrayList存儲字符串並遍歷。要求加入泛型，並用增強for遍歷。
* A:迭代器
* B:普通for
* C:增強for
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 創建集合對象
ArrayList<String> array = new ArrayList<String>();
// 創建並添加元素
array.add("hello");
array.add("world");
array.add("java");
// 遍歷集合
// 迭代器
Iterator<String> it = array.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
System.out.println("------------------");
// 普通for
for (int x = 0; x < array.size(); x++) {
String s = array.get(x);
System.out.println(s);
}
System.out.println("------------------");
// 增強for
for (String s : array) {
System.out.println(s);
}
}
}
Test3：
三種方法遍歷自定義類型集合
import java.util.ArrayList;
import java.util.Iterator;
/*
* 需求：ArrayList存儲自定義對象並遍歷。要求加入泛型，並用增強for遍歷。
* A:迭代器
* B:普通for
* C:增強for
*
* LinkedList,Vector,Colleciton,List等存儲我還講嗎?不講解了，但是要求你們練習。
*
* 增強for是用來替迭代器。
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
// 創建集合對象
ArrayList<Student> array = new ArrayList<Student>();
// 創建學生對象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("貂蟬", 22);
Student s3 = new Student("楊玉環", 24);
Student s4 = new Student("西施", 21);
Student s5 = new Student("王昭君", 23);
// 把學生對象添加到集合中
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
array.add(s5);
// 迭代器
Iterator<Student> it = array.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("---------------");
// 普通for
for (int x = 0; x < array.size(); x++) {
Student s = array.get(x);
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("---------------");
// 增強for
for (Student s : array) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
4:靜態導入(瞭解)
(1)可以導入到方法級別的導入
(2)格式：
import static 包名....類名.方法名;
(3)注意事項：
A:方法必須是靜態的
B:如果多個類下有同名的方法，就不好區分了，還得加上前綴。
所以一般我們並不使用靜態導入，但是一定要能夠看懂。
Test：
/*
* 靜態導入：
* 格式：import static 包名….類名.方法名;
* 可以直接導入到方法的級別
*
* 靜態導入的注意事項：
* A:方法必須是靜態的
* B:如果有多個同名的靜態方法，容易不知道使用誰?這個時候要使用，必須加前綴。由此可見，意義不大，所以一般不用，但是要能看懂。
*/
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.max;
//錯誤
//import static java.util.ArrayList.add;
public class StaticImportDemo {
public static void main(String[] args) {
// System.out.println(java.lang.Math.abs(-100));
// System.out.println(java.lang.Math.pow(2, 3));
// System.out.println(java.lang.Math.max(20, 30));
// 太複雜，我們就引入到import
// System.out.println(Math.abs(-100));
// System.out.println(Math.pow(2, 3));
// System.out.println(Math.max(20, 30));
// 太複雜，有更簡單
// System.out.println(abs(-100));
System.out.println(java.lang.Math.abs(-100));
System.out.println(pow(2, 3));
System.out.println(max(20, 30));
}
public static void abs(String s){
System.out.println(s);
}
}
5:可變參數(掌握)
(1)如果我們在寫方法的時候，參數個數不明確，就應該定義可變參數。
(2)格式：
修飾符 返回值類型 方法名(數據類型... 變量) {}
注意：
A:該變量其實是一個數組名
B:如果一個方法有多個參數，並且有可變參數，可變參數必須在最後
Test：
public class test6 {
public static void main(String[] args) {
System.out.println(sum(1, 2, 3, 4, 5, 6, 7, 8, 9));
}
public static int sum(int... n) {
int sum = 0;
for (int i : n) {
sum += i;
}
return sum;
}
}
(3)Arrays工具類的一個方法
asList()把數組轉成集合。
注意：這個集合的長度不能改變。
Test：
import java.util.Arrays;
import java.util.List;
/*
* public static <T> List<T> asList(T... a):把數組轉成集合
*
* 注意事項：
* 雖然可以把數組轉成集合，但是集合的長度不能改變。
* 不能增刪，但是可以修改
*/
public class ArraysDemo {
public static void main(String[] args) {
// 定義一個數組
// String[] strArray = { "hello", "world", "java" };
// List<String> list = Arrays.asList(strArray);
// 可變參數列表，可以自行添加元素
List<String> list = Arrays.asList("hello", "world", "java");
// UnsupportedOperationException
// list.add("javaee");
// UnsupportedOperationException
// list.remove(1);
list.set(1, "javaee");
for (String s : list) {
System.out.println(s);
}
}
}
6:練習(掌握)
A:集合的嵌套遍歷
Demo：
package cn.itcast_01;
import java.util.ArrayList;
/*
* 集合的嵌套遍歷
* 需求：
* 我們班有學生，每一個學生是不是一個對象。所以我們可以使用一個集合表示我們班級的學生。ArrayList<Student>
* 但是呢，我們旁邊是不是還有班級，每個班級是不是也是一個ArrayList<Student>。
* 而我現在有多個ArrayList<Student>。也要用集合存儲，怎麼辦呢?
* 就是這個樣子的：ArrayList<ArrayList<Student>>
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 創建大集合
ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();
// 創建第一個班級的學生集合
ArrayList<Student> firstArrayList = new ArrayList<Student>();
// 創建學生
Student s1 = new Student("唐僧", 30);
Student s2 = new Student("孫悟空", 29);
Student s3 = new Student("豬八戒", 28);
Student s4 = new Student("沙僧", 27);
Student s5 = new Student("白龍馬", 26);
// 學生進班
firstArrayList.add(s1);
firstArrayList.add(s2);
firstArrayList.add(s3);
firstArrayList.add(s4);
firstArrayList.add(s5);
// 把第一個班級存儲到學生系統中
bigArrayList.add(firstArrayList);
// 創建第二個班級的學生集合
ArrayList<Student> secondArrayList = new ArrayList<Student>();
// 創建學生
Student s11 = new Student("諸葛亮", 30);
Student s22 = new Student("司馬懿", 28);
Student s33 = new Student("周瑜", 26);
// 學生進班
secondArrayList.add(s11);
secondArrayList.add(s22);
secondArrayList.add(s33);
// 把第二個班級存儲到學生系統中
bigArrayList.add(secondArrayList);
// 創建第三個班級的學生集合
ArrayList<Student> thirdArrayList = new ArrayList<Student>();
// 創建學生
Student s111 = new Student("宋江", 40);
Student s222 = new Student("吳用", 35);
Student s333 = new Student("高俅", 30);
Student s444 = new Student("李師師", 22);
// 學生進班
thirdArrayList.add(s111);
thirdArrayList.add(s222);
thirdArrayList.add(s333);
thirdArrayList.add(s444);
// 把第三個班級存儲到學生系統中
bigArrayList.add(thirdArrayList);
// 遍歷集合
for (ArrayList<Student> array : bigArrayList) {
for (Student s : array) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
}
Test：
package bao_01;
import java.util.ArrayList;
public class Test9 {
public static void main(String[] args) {
// 新建三個<Student>自定義對象集合
ArrayList<Student> list1 = new ArrayList<>();
ArrayList<Student> list2 = new ArrayList<>();
ArrayList<Student> list3 = new ArrayList<>();
// 新建一個儲存集合的集合
// 類型也應對應普通集合，<ArrayList<Student>>
ArrayList<ArrayList<Student>> listS = new ArrayList<>();
// Student集合添加元素
list1.add(new Student("小一", 1));
list1.add(new Student("小二", 2));
list1.add(new Student("小三", 3));
list2.add(new Student("小四", 4));
list2.add(new Student("小五", 5));
list2.add(new Student("小六", 6));
list3.add(new Student("小七", 7));
list3.add(new Student("小八", 8));
list3.add(new Student("小九", 9));
// ArrayList<Student>類型集合添加元素
listS.add(list1);
listS.add(list2);
listS.add(list3);
// for增強型循環方式實現遍歷
// 外循環從總集合中提取ArrayList<Student>類型的元素
for (ArrayList<Student> arr : listS) {
// 內循環提取Student類型元素
for (Student s : arr) {
System.out.println(s.getName() + "\t" + s.getAge());
}
System.out.println("++++++++++++++++++++");
}
// //普通for循環方法實現遍歷
// //外循環從總集合中提取元素
// for (int i = 0; i < listS.size(); i++) {
// //內循環從子集合中提取元素
// for (int j = 0; j < listS.get(i).size(); j++) {
// 將子集合中的元素轉換爲原始的Student類
// Student s = (Student) listS.get(i).get(j);
// System.out.println(s.getName() + "\t" + s.getAge());
// }
// System.out.println("+++++++++++++++++++++++");
// }
}
}
輸出：
小一1
小二2
小三3
+++++++++++++++++++++++
小四4
小五5
小六6
+++++++++++++++++++++++
小七7
小八8
小九9
+++++++++++++++++++++++
B:產生10個1-20之間的隨機數，要求隨機數不能重複
Demo：
import java.util.ArrayList;
import java.util.Random;
/*
* 獲取10個1-20之間的隨機數，要求不能重複
*
* 用數組實現，但是數組的長度是固定的，長度不好確定。
* 所以我們使用集合實現。
*
* 分析：
* A:創建產生隨機數的對象
* B:創建一個存儲隨機數的集合。
* C:定義一個統計變量。從0開始。
* D:判斷統計遍歷是否小於10
* 是:先產生一個隨機數，判斷該隨機數在集合中是否存在。
* 如果不存在:就添加，統計變量++。
* 如果存在:就不搭理它。
* 否：不搭理它
* E:遍歷集合
*/
public class RandomDemo {
public static void main(String[] args) {
// 創建產生隨機數的對象
Random r = new Random();
// 創建一個存儲隨機數的集合。
ArrayList<Integer> array = new ArrayList<Integer>();
// 定義一個統計變量。從0開始。
int count = 0;
// 判斷統計遍歷是否小於10
while (count < 10) {
//先產生一個隨機數
int number = r.nextInt(20) + 1;
//判斷該隨機數在集合中是否存在。
if(!array.contains(number)){
//如果不存在:就添加，統計變量++。
array.add(number);
count++;
}
}
//遍歷集合
for(Integer i : array){
System.out.println(i);
}
}
}
Test：
import java.util.ArrayList;
import java.util.Random;
public class Test7 {
public static void main(String[] args) {
// 新建整數集合
ArrayList<Integer> list = new ArrayList<>();
// 新建獲取隨機數對象
Random m = new Random();
int n = 0;
// for (int i = 0; i < 100; i++) {
// n=m.nextInt(20)+1;
// System.out.println(n);
// }
// 當集合元素不到10個時循環
while (list.size() < 10) {
// 獲取1-20的隨機數
n = m.nextInt(20) + 1;
// 如果集合中不包含該元素就添加進去
if (!list.contains(n)) {
list.add(n);
}
}
// 遍歷集合
for (int x : list) {
System.out.println(x);
}
}
}
輸出：
6
11
7
9
16
14
5
12
15
19
C:鍵盤錄入多個數據，以0結束，並在控制檯輸出最大值
Demo：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
/*
* 鍵盤錄入多個數據，以0結束，要求在控制檯輸出這多個數據中的最大值
*
* 分析：
* A:創建鍵盤錄入數據對象
* B:鍵盤錄入多個數據,我們不知道多少個，所以用集合存儲
* C:以0結束,這個簡單，只要鍵盤錄入的數據是0，我就不繼續錄入數據了
* D:把集合轉成數組
* E:對數組排序
* F:獲取該數組中的最大索引的值
*/
public class ArrayListDemo {
public static void main(String[] args) {
// 創建鍵盤錄入數據對象
Scanner sc = new Scanner(System.in);
// 鍵盤錄入多個數據,我們不知道多少個，所以用集合存儲
ArrayList<Integer> array = new ArrayList<Integer>();
// 以0結束,這個簡單，只要鍵盤錄入的數據是0，我就不繼續錄入數據了
while (true) {
System.out.println("請輸入數據：");
int number = sc.nextInt();
if (number != 0) {
array.add(number);
} else {
break;
}
}
// 把集合轉成數組
// public <T> T[] toArray(T[] a)
Integer[] i = new Integer[array.size()];
// Integer[] ii = array.toArray(i);
array.toArray(i);
// System.out.println(i);
// System.out.println(ii);
// 對數組排序
// public static void sort(Object[] a)
Arrays.sort(i);
// 獲取該數組中的最大索引的值
System.out.println("數組是：" + arrayToString(i) + "最大值是:"
+ i[i.length - 1]);
}
public static String arrayToString(Integer[] i) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int x = 0; x < i.length; x++) {
if (x == i.length - 1) {
sb.append(i[x]);
} else {
sb.append(i[x]).append(", ");
}
}
sb.append("]");
return sb.toString();
}
}
Test：
import java.util.ArrayList;
import java.util.Scanner;
public class Test8 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<>();
System.out.println("請開始輸入數據，以數字0結束：");
int n = sc.nextInt();
// 當輸入的數字不是0時則提示繼續輸入
while (n != 0) {
list.add(n);
System.out.println("請輸入下一個數據：");
n = sc.nextInt();
}
System.out.println("輸入結束。");
System.out.println("輸入的最大的數字爲：" + Max(list));
}
/***
* 求Integer類型集合中的最大值
*
* @param list
* @return
*/
public static int Max(ArrayList<Integer> list) {
int m = list.get(0);
for (int x : list) {
// 如果既定值小於遍歷值則進行賦值
if (m < x) {
m = x;
}
}
return m;
}
}
輸出：
請開始輸入數據，以數字0結束：
54
請輸入下一個數據：
48
請輸入下一個數據：
13
請輸入下一個數據：
81
請輸入下一個數據：
0
輸入結束。
輸入的最大的數字爲：81
#如果直接輸入0會報錯，集合爲空無法遍歷#
7:要掌握的代碼
集合存儲元素，加入泛型，並可以使用增強for遍歷。