ArrayList存儲java
package cn.itcast_01; import java.util.ArrayList; import java.util.Iterator; /* * List的子類特色: * ArrayList: * 底層數據結構是數組,查詢快,增刪慢 * 線程不安全,效率高 * Vector: * 底層數據結構是數組,查詢快,增刪慢 * 線程安全,效率低 * LinkedList: * 底層數據結構是鏈表,查詢慢,增刪快 * 線程不安全,效率高 * * 案例: * 使用List的任何子類存儲字符串或者存儲自定義對象並遍歷。 * * ArrayList的使用。 * 存儲字符串並遍歷 */ public class ArrayListDemo { public static void main(String[] args) { // 建立集合對象 ArrayList array = new ArrayList(); // 建立元素對象,並添加元素 array.add("hello"); array.add("world"); array.add("java"); // 遍歷 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } System.out.println("-----------"); for (int x = 0; x < array.size(); x++) { String s = (String) array.get(x); System.out.println(s); } } }
Vector的特有功能:
android
package cn.itcast_02; 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); } } }
Linkedlist的特有功能
數組
package cn.itcast_03; 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); } }
去除ArrayList集合中的重複字符串元素
安全
package cn.itcast_04; import java.util.ArrayList; import java.util.Iterator; /* * ArrayList去除集合中字符串的重複值(字符串的內容相同) * * 分析: * A:建立集合對象 * B:添加多個字符串元素(包含內容相同的) * C:建立新集合 * D:遍歷舊集合,獲取獲得每個元素 * E:拿這個元素到新集合去找,看有沒有 * 有:不搭理它 * 沒有:就添加到新集合 * F:遍歷新集合 */ public class ArrayListDemo { public static void main(String[] args) { // 建立集合對象 ArrayList array = new ArrayList(); // 添加多個字符串元素(包含內容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world"); // 建立新集合 ArrayList newArray = new ArrayList(); // 遍歷舊集合,獲取獲得每個元素 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); // 拿這個元素到新集合去找,看有沒有 if (!newArray.contains(s)) { newArray.add(s); } } // 遍歷新集合 for (int x = 0; x < newArray.size(); x++) { String s = (String) newArray.get(x); System.out.println(s); } } }
去除ArrayList集合中的重複字符串元素案例2
數據結構
package cn.itcast_04; import java.util.ArrayList; import java.util.Iterator; /* * 需求:ArrayList去除集合中字符串的重複值(字符串的內容相同) * 要求:不能建立新的集合,就在之前的集合上作。 */ public class ArrayListDemo2 { public static void main(String[] args) { // 建立集合對象 ArrayList array = new ArrayList(); // 添加多個字符串元素(包含內容相同的) array.add("hello"); array.add("world"); array.add("java"); array.add("world"); array.add("java"); array.add("world"); array.add("world"); array.add("world"); array.add("world"); array.add("java"); array.add("world"); // 由選擇排序思想引入,咱們就能夠經過這種思想作這個題目 // 拿0索引的依次和後面的比較,有就把後的幹掉 // 同理,拿1索引... for (int x = 0; x < array.size() - 1; x++) { for (int y = x + 1; y < array.size(); y++) { if (array.get(x).equals(array.get(y))) { array.remove(y); y--; } } } // 遍歷集合 Iterator it = array.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } } }
去除ArrayList集合中的重複自定義對象元素案例
app
package cn.itcast_04; 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; } 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 boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
package cn.itcast_04; import java.util.ArrayList; import java.util.Iterator; /* * 需求:去除集合中自定義對象的重複值(對象的成員變量值都相同) * * 咱們按照和字符串同樣的操做,發現出問題了。 * 爲何呢? * 咱們必須思考哪裏會出問題? * 經過簡單的分析,咱們知道問題出如今了判斷上。 * 而這個判斷功能是集合本身提供的,因此咱們若是想很清楚的知道它是如何判斷的,就應該去看源碼。 * contains()方法的底層依賴的是equals()方法。 * 而咱們的學生類中沒有equals()方法,這個時候,默認使用的是它父親Object的equals()方法 * Object()的equals()默認比較的是地址值,因此,它們進去了。由於new的東西,地址值都不一樣。 * 按照咱們本身的需求,比較成員變量的值,重寫equals()便可。 * 自動生成便可。 */ public class ArrayListDemo3 { public static void main(String[] args) { // 建立集合對象 ArrayList array = new ArrayList(); // 建立學生對象 Student s1 = new Student("林青霞", 27); Student s2 = new Student("林志玲", 40); Student s3 = new Student("鳳姐", 35); Student s4 = new Student("芙蓉姐姐", 18); Student s5 = new Student("翠花", 16); Student s6 = new Student("林青霞", 27); Student s7 = new Student("林青霞", 18); // 添加元素 array.add(s1); array.add(s2); array.add(s3); array.add(s4); array.add(s5); array.add(s6); array.add(s7); // 建立新集合 ArrayList newArray = new ArrayList(); // 遍歷舊集合,獲取獲得每個元素 Iterator it = array.iterator(); while (it.hasNext()) { Student s = (Student) it.next(); // 拿這個元素到新集合去找,看有沒有 if (!newArray.contains(s)) { newArray.add(s); } } // 遍歷新集合 for (int x = 0; x < newArray.size(); x++) { Student s = (Student) newArray.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } }
用LinkedList模擬棧數據結構的集合並測試案例
dom
package cn.itcast_05; import java.util.LinkedList; /** * 自定義的棧集合 * * @author 風清揚 * @version V1.0 */ public class MyStack { private LinkedList link; public MyStack() { link = new LinkedList(); } public void add(Object obj) { link.addFirst(obj); } public Object get() { // return link.getFirst(); return link.removeFirst(); } public boolean isEmpty() { return link.isEmpty(); } }
package cn.itcast_05; /* * MyStack的測試 */ public class MyStackDemo { public static void main(String[] args) { // 建立集合對象 MyStack ms = new MyStack(); // 添加元素 ms.add("hello"); ms.add("world"); ms.add("java"); // System.out.println(ms.get()); // System.out.println(ms.get()); // System.out.println(ms.get()); // NoSuchElementException // System.out.println(ms.get()); while(!ms.isEmpty()){ System.out.println(ms.get()); } } }
ArrayList存儲自定義對象並遍歷泛型
ide
package cn.itcast_02; import java.util.ArrayList; import java.util.Iterator; /* * 需求:存儲自定義對象並遍歷。 * * A:建立學生類 * B:建立集合對象 * C:建立元素對象 * D:把元素添加到集合 * E:遍歷集合 */ public class ArrayListDemo2 { public static void main(String[] args) { // 建立集合對象 // JDK7的新特性:泛型推斷。 // ArrayList<Student> array = new ArrayList<>(); // 可是我不建議這樣使用。 ArrayList<Student> array = new ArrayList<Student>(); // 建立元素對象 Student s1 = new Student("曹操", 40); // 後知後覺 Student s2 = new Student("蔣幹", 30); // 不知不覺 Student s3 = new Student("諸葛亮", 26);// 先知先覺 // 添加元素 array.add(s1); array.add(s2); array.add(s3); // 遍歷 Iterator<Student> it = array.iterator(); while (it.hasNext()) { Student s = it.next(); System.out.println(s.getName() + "---" + s.getAge()); } System.out.println("------------------"); for (int x = 0; x < array.size(); x++) { Student s = array.get(x); System.out.println(s.getName() + "---" + s.getAge()); } } }
經過Object轉型問題引入泛型
工具
package cn.itcast_03; public class ObjectTool { private Object obj; public Object getObj() { return obj; } public void setObj(Object obj) { // Object obj = new Integer(30); this.obj = obj; } }
package cn.itcast_03; /* * 早期的時候,咱們使用Object來表明任意的類型。 * 向上轉型是沒有任何問題的,可是在向下轉型的時候其實隱含了類型轉換的問題。 * 也就是說這樣的程序其實並非安全的。因此Java在JDK5後引入了泛型,提升程序的安全性。 */ public class ObjectToolDemo { public static void main(String[] args) { ObjectTool ot = new ObjectTool(); // 正常使用 ot.setObj(new Integer(27)); Integer i = (Integer) ot.getObj(); System.out.println("年齡是:" + i); ot.setObj(new String("林青霞")); String s = (String) ot.getObj(); System.out.println("姓名是:" + s); System.out.println("---------"); ot.setObj(new Integer(30)); // ClassCastException String ss = (String) ot.getObj(); System.out.println("姓名是:" + ss); } }
泛型方法(一)
測試
package arraylist; public class GenericDemo<T> { private T obj; public T getObj() { return obj; } public void setObj(T obj) { this.obj = obj; } }
package arraylist; public class GenericTest { public static void main(String[] args) { GenericDemo<String> gd = new GenericDemo<String>(); gd.setObj("zhangsan"); System.out.println("name:"+gd.getObj()); } }
泛型方法(二)
package arraylist; public class GenericDemo<T> { public void show(T t){ System.out.println(t); } }
package arraylist; public class GenericTest { public static void main(String[] args) { GenericDemo<String> gd = new GenericDemo<String>(); System.out.print("name:"); gd.show("lisi"); } }
泛型方法(把泛型定義在方法上)
package arraylist; public class GenericDemo<T> { public <T> void show(T t){ System.out.println(t); } }
package arraylist; public class GenericTest { public static void main(String[] args) { GenericDemo gd = new GenericDemo(); gd.show("lisi"); gd.show(20); gd.show(true); } }
泛型接口的概述和使用
package cn.itcast_06; /* * 泛型接口:把泛型定義在接口上 */ public interface Inter<T> { public abstract void show(T t); }
package cn.itcast_06; //實現類在實現接口的時候 //第一種狀況:已經知道該是什麼類型的了 //public class InterImpl implements Inter<String> { // // @Override // public void show(String t) { // System.out.println(t); // } // } //第二種狀況:還不知道是什麼類型的 public class InterImpl<T> implements Inter<T> { @Override public void show(T t) { System.out.println(t); } }
package cn.itcast_06; public class InterDemo { public static void main(String[] args) { // 第一種狀況的測試 // Inter<String> i = new InterImpl(); // i.show("hello"); // // 第二種狀況的測試 Inter<String> i = new InterImpl<String>(); i.show("hello"); Inter<Integer> ii = new InterImpl<Integer>(); ii.show(100); } }
泛型高級之通配符
package cn.itcast_07; 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 { }
加強for的概述和使用
package cn.itcast_01; 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); } }
靜態導入的概述和使用
package cn.itcast_02; /* * 靜態導入: * 格式: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); } }
可變參數的概述和使用
package cn.itcast_03; /* * 可變參數:定義方法的時候不知道該定義多少個參數 * 格式: * 修飾符 返回值類型 方法名(數據類型… 變量名){ * * } * * 注意: * 這裏的變量實際上是一個數組 * 若是一個方法有可變參數,而且有多個參數,那麼,可變參數確定是最後一個 */ public class ArgsDemo { public static void main(String[] args) { // 2個數據求和 int a = 10; int b = 20; int result = sum(a, b); System.out.println("result:" + result); // 3個數據的求和 int c = 30; result = sum(a, b, c); System.out.println("result:" + result); // 4個數據的求和 int d = 30; result = sum(a, b, c, d); System.out.println("result:" + result); // 需求:我要寫一個求和的功能,究竟是幾個數據求和呢,我不太清楚,可是我知道在調用的時候我確定就知道了 // 爲了解決這個問題,Java就提供了一個東西:可變參數 result = sum(a, b, c, d, 40); System.out.println("result:" + result); result = sum(a, b, c, d, 40, 50); System.out.println("result:" + result); } public static int sum(int... a) { // System.out.println(a); //return 0; int s = 0; for(int x : a){ s +=x; } return s; } // public static int sum(int a, int b, int c, int d) { // return a + b + c + d; // } // // public static int sum(int a, int b, int c) { // return a + b + c; // } // // public static int sum(int a, int b) { // return a + b; // } }
Arrays工具類的asList()方法的使用
package cn.itcast_03; 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); } } }
集合嵌套存儲和遍歷元素的案例圖解
集合嵌套存儲和遍歷元素的案例代碼實現
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()); } } } }
產生10個1-20之間的隨機數要求隨機數不能重複案例
package cn.itcast_02; 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); } } }
鍵盤錄入多個數據在控制檯輸出最大值案例
package cn.itcast_03; 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(); } }