建一個Student類：

public class Student {

    private String name;//名字

    private int score;//成績

    public Student() {
        super();
    }

    public Student(String name, int score) {
        super();
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return
 
 name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }


}

集合List：

import java.util.ArrayList;
import java.util.Iterator;

public class Application2 {

    public
 
 static void main(String[] args) {

        Student zhangsan = new Student("zhangsan",90);
        Student lisi = new Student("lisi",80);
        Student liuliu = new Student("liuliu",99);

        //建立一個能夠儲存Student 的 ArrayList，並新增資料
        //<Studdent> 用來限制集合中只能儲存 Student 物件
        ArrayList<Student> al1 = new
 
 ArrayList<Student>();

        //新增資料，集合儲存的是物件的地址
        al1.add(zhangsan);
        al1.add(lisi);
        al1.add(liuliu);

        System.out.println(al1.size());

        zhangsan.setScore(88);//因為集合中儲存的是地址，所以可以對元素進行修改

        //獲取索引為0出儲存的資料地址
        Student s0 = al1.get(0);
        System.out.println(s0.getName() + " " + s0.getScore());

        //基本型別 需要轉換為 對應的引用型別，才能把堆上的地址放入集合中
        /*
         * byte → Byte
         * short → Short
         * int → Integer
         * long → Long
         * float → Float
         * double → Double
         * char → Character
         * Boolean → Boolean
         */

        //基本型別對應的引用型別也叫做包裝型別，他們之間相互轉化有系統完成，不需要我們處理
        int a = 10;//基本型別，再棧上
        Integer b = 20;//引用型別，在堆上
        //系統自動把b轉換為int型別進行計算
        int c = a + b;
        //系統自動把b轉換為int型別進行計算，然後把結果轉化為Integer型別
        Integer d = a + b;

        ArrayList<Integer> al2 = new ArrayList<Integer>();

        al2.add(10);
        al2.add(15);

        int number1 = al2.get(0);
        int number2 = al2.get(1);
        System.out.println(number1 + " " + number2);

        ArrayList<Double> al3 = new ArrayList<Double>();

        al3.add(6.6);
        al3.add(9.9);

        double d1 = al3.get(0);
        double d2 = al3.get(1);
        System.out.println(d1 + " " + d2);

        //基本型別轉化為引用型別：裝箱，封包
        //引用型別轉化為基本型別：拆箱，解包

        //List 的遍歷（獲取集合中的每一元素）
        //方案1：普通for迴圈遍歷
        System.out.println("_-_-_-_-_-_-_-_-");
        for (int i = 0; i < al1.size(); i++) {
            Student stu = al1.get(i);
            System.out.println(stu.getName() + " " + stu.getScore());
        }
        //方案2：增強for迴圈遍歷
        System.out.println("_-_-_-_-_-_-_-_-");
        for(Student stu : al1) {
            System.out.println(stu.getName() + " " + stu.getScore());
        }
        //方案3：使用迭代器Iterator（專用於遍歷資料的介面）
        System.out.println("_-_-_-_-_-_-_-_-");
        Iterator<Student> iterator = al1.iterator();
        while(iterator.hasNext()){
            Student stu = iterator.next();
            System.out.println(stu.getName() + " " + stu.getScore());
        }

    }

}

集合Set：

import java.util.HashSet;
import java.util.Iterator;

public class Application3 {

    public static void main(String[] args) {

        HashSet<Integer> hs1 = new HashSet<Integer>();

        //重複的資料只會儲存一次
        //根據equals 方法進行重複判斷
        hs1.add(1);
        hs1.add(1);
        hs1.add(1);
        hs1.add(1);
        hs1.add(1);

        hs1.add(2);
        hs1.add(2);
        hs1.add(2);
        //只有兩個重複的元素
        System.out.println(hs1.size());

        //Set中沒有索引的概念，我們不能獲取Set 中的某一個元素
        //不支援根據索引取值 .get 無效

        //Set的遍歷
        //方案1： 增強for迴圈
        System.out.println("_-_-_-_-_-_-_-_-");
        for (Integer number : hs1) {
            System.out.println(number);
        }
        //方案2：迭代器
        System.out.println("_-_-_-_-_-_-_-_-");
        Iterator<Integer> iterator = hs1.iterator();
        while(iterator.hasNext()) {
            Integer number = iterator.next();
            System.out.println(number);
        }

        //List和Set的區別：
        /*
         * List中資料可以重複，Set中資料不能重複
         * List中有索引，資料按照索引排序，也可以根據索引獲取某個元素的值
         * Set中沒有索引，資料是無序（不一定和新增順序保持一致）的，只能通過遍歷獲取全部資料
         */
        //如果集合中的資料不能重複，必須使用Set，其他情況使用List

    }

}