day16<集合框架+>

集合框架(去除ArrayList中重複字符串元素方式)

集合框架(去除ArrayList中重複自定義對象元素)

集合框架(LinkedList的特有功能)

集合框架(棧和隊列數據結構)

集合框架(用LinkedList模擬棧數據結構的集合並測試)

集合框架(泛型(generic)概述和基本使用)

集合框架(ArrayList存儲字符串和自定義對象並遍歷泛型版)

集合框架(泛型的由來)

集合框架(泛型類的概述及使用)

集合框架(泛型方法的概述和使用)

集合框架(泛型接口的概述和使用)

集合框架(泛型高級之通配符)

集合框架(加強for的概述和使用)

集合框架(ArrayList存儲自定義對象並遍歷加強for版)

集合框架(三種迭代的可否刪除)

集合框架(靜態導入的概述和使用)

集合框架(可變參數的概述和使用)

集合框架(Arrays工具類的asList()方法的使用)

集合框架(集合嵌套之ArrayList嵌套ArrayList)

 

###16.01_集合框架(去除ArrayList中重複字符串元素方式)(掌握)
 A:案例演示
     需求：ArrayList去除集合中字符串的重複值(字符串的內容相同)
     思路：建立新集合方式

public class Demo1_ArrayList {    public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("a"); list.add("a"); list.add("b"); list.add("b"); list.add("c"); list.add("c"); ArrayList newList = getSingle(list); System.out.println(newList); //[a, b, c]     }     /*      * 建立新集合將重複元素去掉      * 1,明確返回值類型,返回ArrayList      * 2,明確參數列表ArrayList      *      * 分析:      * 1,建立新集合      * 2,根據傳入的集合(老集合)獲取迭代器      * 3,遍歷老集合      * 4,經過新集合判斷是否包含老集合中的元素,若是包含就不添加,若是不包含就添加      */     public static ArrayList getSingle(ArrayList list) { ArrayList newList = new ArrayList(); //1,建立新集合 Iterator it = list.iterator(); //2,根據傳入的集合(老集合)獲取迭代器 while(it.hasNext()) { //3,遍歷老集合     Object obj = it.next(); //記錄住每個元素    if(!newList.contains(obj)) { //若是新集合中不包含老集合中的元素 newList.add(obj); //將該元素添加     } }        return newList;     } }

###16.02_集合框架(去除ArrayList中重複自定義對象元素)(掌握)
 A:案例演示
     需求：ArrayList去除集合中自定義對象元素的重複值(對象的成員變量值相同)
 B:注意事項
     重寫equals()方法的

@Override     public boolean equals(Object obj) { Person p = (Person)obj; return this.name.equals(p.name) && this.age == p.age;    }

public class Demo2_ArrayList {     /**     contains方法判斷是否包含,底層依賴的是equals方法     remove方法判斷是否刪除,底層依賴的是equals方法，沒重寫前比較的是地址值，重寫後比較對象的屬性值     */     public static void main(String[] args) { ArrayList list = new ArrayList(); //建立集合對象 list.add(new Person("張三", 23)); list.add(new Person("張三", 23)); list.add(new Person("李四", 24)); list.add(new Person("李四", 24)); //ArrayList newList = getSingle(list); //調用方法去除重複 //System.out.println(newList); list.remove(new Person("張三", 23)); System.out.println(list); //重寫後比較對象的屬性，因此沒重寫equals方法比較的是地址值，刪不了     }     /*      * 建立新集合將重複元素去掉      * 1,明確返回值類型,返回ArrayList      * 2,明確參數列表ArrayList      *      * 分析:      * 1,建立新集合      * 2,根據傳入的集合(老集合)獲取迭代器      * 3,遍歷老集合      * 4,經過新集合判斷是否包含老集合中的元素,若是包含就不添加,若是不包含就添加      */     public static ArrayList getSingle(ArrayList list) {         ArrayList newList = new ArrayList(); //1,建立新集合 Iterator it = list.iterator(); //2,根據傳入的集合(老集合)獲取迭代器 while(it.hasNext()) { //3,遍歷老集合     Object obj = it.next(); //記錄住每個元素    if(!newList.contains(obj)) { //若是新集合中不包含老集合中的元素 newList.add(obj); //將該元素添加     } }        return newList;     } }

###16.03_集合框架(LinkedList的特有功能)(掌握)
 A:LinkedList類概述
 B:LinkedList類特有功能
     public void addFirst(E e)及addLast(E e)
     public E getFirst()及getLast()
     public E removeFirst()及public E removeLast()
     public E get(int index);

LinkedList list = new LinkedList();     list.addFirst("a");     list.addFirst("b");     list.addLast("c");     System.out.println(list.getFirst()); //b     System.out.println(list.getLast()); //c     System.out.println(list.removeFirst()); //b     System.out.println(list.removeLast()); //c     System.out.println(list.get(1)); //a     System.out.println(list); //[b, a, c]

###16.04_集合框架(棧和隊列數據結構)(掌握)
 棧
     先進後出 
 隊列
     先進先出

###16.05_集合框架(用LinkedList模擬棧數據結構的集合並測試)(掌握)
 A:案例演示
     需求：請用LinkedList模擬棧數據結構的集合，並測試
     建立一個類將Linked中的方法封裝

public class Stack {     private LinkedList list = new LinkedList(); // 模擬進棧方法 public void in(Object obj) { list.addLast(obj);     }     // 模擬出棧     public Object out() { return list.removeLast();     }     // 模擬棧結構是否爲空     public boolean isEmpty() { return list.isEmpty();     } }

//用LinkedList模擬棧結構     public static void main(String[] args) { //demo1(); Stack s = new Stack(); s.in("a"); //進棧 s.in("b"); s.in("c"); s.in("d"); while(!s.isEmpty()) { //判斷棧結構是否爲空     System.out.println(s.out()); //彈棧 }     }     public static void demo1() { LinkedList list = new LinkedList(); //建立集合對象 list.addLast("a"); list.addLast("b"); list.addLast("c"); list.addLast("d"); /*System.out.println(list.removeLast()); System.out.println(list.removeLast()); System.out.println(list.removeLast()); System.out.println(list.removeLast());*/ while(!list.isEmpty()) {      System.out.println(list.removeLast()); }     }

###16.06_集合框架(泛型概述和基本使用)(掌握)
 A:泛型概述
 B:泛型好處
     提升安全性(將運行期的錯誤轉換到編譯期) 
     省去強轉的麻煩
 C:泛型基本使用
     <>中放的必須是引用數據類型 
 D:泛型使用注意事項
     先後的泛型必須一致,或者後面的泛型能夠省略不寫(1.7的新特性菱形泛型)

public static void main(String[] args) { demo1(); //int[] arr = new byte[5]; //數組要保證先後的數據類型一致 //ArrayList<Object> list = new ArrayList<Person>(); //集合的泛型要保證先後的數據類型一致 //ArrayList<Object> list = new ArrayList<>();//1.7版本的新特性,菱形泛型 ArrayList<Object> list = new ArrayList<Object>(); //泛型最好不要定義成Object,沒有意義 list.add("aaa"); list.add(true);     }     public static void demo1() { ArrayList<Person> list = new ArrayList<Person>(); // list.add(110); // list.add(true); list.add(new Person("張三", 23)); list.add(new Person("李四", 24)); Iterator<Person> it = list.iterator(); while(it.hasNext()) {     //System.out.println(it.next());     //System.out.println(it.next().getName() + "..." + it.next().getAge());//張三...24 //next方法只能調用一次,若是調用屢次會將指針向後移動屢次     Person p = it.next();     System.out.println(p.getName() + "..." + p.getAge());         }     }

###16.07_集合框架(ArrayList存儲字符串和自定義對象並遍歷泛型版)(掌握)
 A:案例演示
     ArrayList存儲字符串並遍歷泛型版

public static void main(String[] args) { //demo1(); ArrayList<Person> list = new ArrayList<Person>(); list.add(new Person("張三", 23)); list.add(new Person("李四", 24)); list.add(new Person("王五", 25)); list.add(new Person("趙六", 26)); Iterator<Person> it = list.iterator(); while(it.hasNext()) {     Person p = it.next(); //將集合中的每個元素用Person記錄     System.out.println(p.getName() + "..." + p.getAge()); }     }     public static void demo1() { ArrayList<String> list = new ArrayList<String>(); //建立集合對象 list.add("a"); list.add("b"); list.add("c"); list.add("d"); Iterator<String> it = list.iterator(); while(it.hasNext()) {     System.out.println(it.next());         }     }

###16.08_集合框架(泛型的由來)(瞭解)
 A:案例演示
     泛型的由來:經過Object轉型問題引入
     早期的Object類型能夠接收任意的對象類型，可是在實際的使用中，會有類型轉換的問題。也就存在這隱患，因此Java提供了泛型來解決這個安全問題。

###16.09_集合框架(泛型類的概述及使用)(瞭解)
 A:泛型類概述<T>
     把泛型定義在類上
 B:定義格式
     public class 類名<泛型類型1,…>
 C:注意事項    
     泛型類型必須是引用類型
 D:案例演示
     泛型類的使用

public class Tool<Q> { //泛型一個字母大寫，當用Tool建立對象時指定泛型，指定泛型是什麼這個Q就是什麼     private Q q;     public Q getObj() { return q;     }     public void setObj(Q q) {         this.q = q;     } }

public static void main(String[] args) {     Tool<Student> t = new Tool<Student>(); //建立工具類對象     t.setObj(new Student("張三",23));     //Worker w = (Worker) t.getObj(); //向下轉型     //System.out.println(w); }

###16.10_集合框架(泛型方法的概述和使用)(瞭解)
 A:泛型方法概述
     把泛型定義在方法上
 B:定義格式    
     public <泛型類型> 返回類型 方法名(泛型類型 變量名)
 C:案例演示
     泛型方法的使用

public class Tool<Q> {     private Q q;     public Q getObj() {         return q; } public void setObj(Q q) {     this.q = q; } public<T> void show(T t) { //方法泛型最好與類的泛型一致     System.out.println(t); //若是不一致,須要在方法上聲明該泛型 }     //Static方法隨類的加載而加載，加載時可能還沒建立對象Q沒值     public static<W> void print(W w) { //靜態方法必須聲明本身的泛型 System.out.println(w);     } }

public static void main(String[] args) { //demo1(); Tool<String> t = new Tool<String>();//建立工具類對象指定爲String類型 //t.show("abc"); t.show(true);     }     public static void demo1() { Tool<Student> t = new Tool<Student>(); //建立工具類對象 t.setObj(new Student("張三",23)); //Worker w = (Worker) t.getObj(); //向下轉型 //System.out.println(w);     }

###16.11_集合框架(泛型接口的概述和使用)(瞭解)
 A:泛型接口概述
     把泛型定義在接口上
 B:定義格式    
     public interface 接口名<泛型類型>
 C:案例演示
     泛型接口的使用

interface Inter<T> {     public void show(T t); } class Demo implements Inter<String> { //推薦用這種     @Override     public void show(String t) { System.out.println(t);     } }

class Demo<T> implements Inter<T> { //沒有必要在實現接口的時候給本身類加泛型     @Override     public void show(T t) { System.out.println(t);     } }

 

###16.12_集合框架(泛型高級之通配符)(瞭解)
 A:泛型通配符<?>
     任意類型，若是沒有明確，那麼就是Object以及任意的Java類了
 B:? extends E
     向下限定，E及其子類
 C:? super E
     向上限定，E及其父類

//List<?> list = new ArrayList<Integer>(); //當右邊的泛型是不肯定時,左邊能夠指定爲?     ArrayList<Person> list1 = new ArrayList<Person>();     list1.add(new Person("張三", 23));     list1.add(new Person("李四", 24));     list1.add(new Person("王五", 25));     ArrayList<Student> list2 = new ArrayList<Student>();     list2.add(new Student("趙六", 26));     list2.add(new Student("周七", 27));     list1.addAll(list2); //Student必須繼承Person才能放進去     System.out.println(list1);

###16.13_集合框架(加強for的概述和使用)(掌握)
 A:加強for概述
     簡化數組和Collection集合的遍歷
 B:格式：
        for(元素數據類型 變量 : 數組或者Collection集合) {
            使用變量便可，該變量就是元素
        }
 C:案例演示
     數組，集合存儲元素用加強for遍歷

 ArrayList存儲字符串並遍歷加強for版
 D:好處
     簡化遍歷

int[] arr = {11,22,33,44,55};     for (int i : arr) { System.out.println(i);     }     ArrayList<String> list = new ArrayList<String>();     list.add("a");     list.add("b");     list.add("c");     list.add("d");     for (String string : list) { System.out.println(string);     }

###16.14_集合框架(ArrayList存儲字符串和自定義對象並遍歷加強for版)(掌握)
 A:案例演示
     自定義對象並遍歷加強for版
     加強for循環底層依賴的是迭代器(Iterator)

ArrayList<Person> list = new ArrayList<Person>();     list.add(new Person("張三", 23));     list.add(new Person("李四", 24));     list.add(new Person("王五", 25));     list.add(new Person("趙六", 26));     for (Person person : list) { System.out.println(person);     }

 

###16.15_集合框架(三種迭代的可否刪除)(掌握)
     普通for循環,能夠刪除,可是索引要--
     迭代器,能夠刪除,可是必須使用迭代器自身的remove方法,不然會出現併發修改異常
     jdk1.5加強for循環不能刪除

 

ArrayList<String> list = new ArrayList<String>();     list.add("a");     list.add("b");     list.add("b");     list.add("c");     list.add("d");     //1,普通for循環刪除,索引要--     for(int i = 0; i < list.size(); i++) { if("b".equals(list.get(i))) {     list.remove(i--); //經過索引刪除元素 }     }

//2,迭代器刪除     Iterator<String> it = list.iterator();     while(it.hasNext()) { if("b".equals(it.next())) {     //list.remove("b"); //不能用集合的刪除方法,由於迭代過程當中若是集合修改會出現併發修改異常     it.remove(); //能夠操做自身的方法         }     }     /*for(Iterator<String> it2 = list.iterator(); it2.hasNext();) {     if("b".equals(it2.next())) {     //list.remove("b"); //不能用集合的刪除方法,由於迭代過程當中若是集合修改會出現併發修改異常     it2.remove(); }     }*/

//3,加強for循環,加強for循環不能刪除,只能遍歷     for (String string : list) { if("b".equals(string)) {     list.remove("b"); //ConcurrentModificationException併發修改異常  }      }     System.out.println(list);

###16.16_集合框架(jdk1.5靜態導入的概述和使用)(掌握)
 A:靜態導入概述
 B:格式：
     import static 包名….類名.方法名;
     能夠直接導入到方法的級別
 C:注意事項
     方法必須是靜態的,若是有多個同名的靜態方法，容易不知道使用誰?這個時候要使用，必須加前綴。因而可知，意義不大，因此通常不用，可是要能看懂。

import static java.util.Arrays.sort; //靜態導入 import static java.util.Arrays.toString; //靜態導入   public class Demo2_StaticImport {     public static void main(String[] args) { int[] arr = {55,22,33,44,11}; sort(arr); //排序 //System.out.println(toString(arr));     } }

###16.17_集合框架(jdk1.5可變參數的概述和使用)(掌握)
 A:可變參數概述
     定義方法的時候不知道該定義多少個參數
 B:格式
     修飾符 返回值類型 方法名(數據類型…  變量名){}
 C:注意事項：
     這裏的變量實際上是一個數組
     若是一個方法有可變參數，而且有多個參數，那麼，可變參數確定是最後一個

 

public static void main(String[] args) { int[] arr = {11,22,33,44,55}; //print(arr); print(11,22,33,44,55); System.out.println("---------------"); //print();     }     /*public static void print(int[] arr) {         for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]);     }     }*/     public static void print(int ... arr) { //可變參數實際上是一個數組 for (int i = 0; i < arr.length; i++) {      System.out.println(arr[i]);          }     }

###16.18_集合框架(Arrays工具類的asList()方法的使用)(掌握)
 A:案例演示
     Arrays工具類的asList()方法的使用
     Collection中toArray(T[] a)泛型版的集合轉數組

      數組轉換成集合

      數組轉換成集合雖然不能增長或減小元素,可是能夠用集合的思想操做數組,也就是說可使用其餘集合中的方法。

public static void demo2() { //int[] arr = {11,22,33,44,55}; //List<int[]> list = Arrays.asList(arr); //基本數據類型的數組轉換成集合,會將整個數組看成一個對象轉換 //System.out.println(list); //[[I@67006d75] Integer[] arr = {11,22,33,44,55}; //將數組轉換成集合,數組必須是引用數據類型 List<Integer> list = Arrays.asList(arr); System.out.println(list); //[11, 22, 33, 44, 55]     }     public static void demo1() { String[] arr = {"a","b","c"}; List<String> list = Arrays.asList(arr); //將數組轉換成集合 //list.add("d");//ConcurrentModificationException //不能添加 System.out.println(list); //[a, b, c]     }

//集合轉數組,加泛型的     ArrayList<String> list = new ArrayList<String>();     list.add("a");     list.add("b");     list.add("c");     list.add("d");     String[] arr = list.toArray(new String[10]); //當集合轉換數組時,數組長度若是是小於等於集合的size時,轉換後的數組長度等於集合的size     //若是數組的長度大於了size,分配的數組長度就和你指定的長度同樣     for (String string : arr) { System.out.print(string + " "); //a b c d null null null null null null     }

 

###16.19_集合框架(集合嵌套之ArrayList嵌套ArrayList)(掌握)
 A:案例演示
     集合嵌套之ArrayList嵌套ArrayList

ArrayList<ArrayList<Person>> list = new ArrayList<ArrayList<Person>>();     ArrayList<Person> first = new ArrayList<Person>(); //建立第一個班級     first.add(new Person("楊冪", 30));     first.add(new Person("李冰冰", 33));     first.add(new Person("范冰冰", 20));     ArrayList<Person> second = new ArrayList<Person>();     second.add(new Person("黃曉明", 31));     second.add(new Person("趙薇", 33));     second.add(new Person("陳坤", 32));     //將班級添加到學科集合中     list.add(first);     list.add(second);     //遍歷學科集合     for(ArrayList<Person> a : list) {         for(Person p : a) {     System.out.println(p);   }     }

###16.20_day16總結
 把今天的知識點總結一遍。

 

###16.21_day16做業

1,定義一個方法swap()傳入集合和兩個角標使集合中元素交換位置

    a,定義一個臨時變量, 記住其中一個元素

    b,用第一個位置存放第二個位置上的元素

    c, 用第二個位置存放臨時變量記住的元素

2,把集合中存儲多個Person對象,Person有姓名和年齡,找出年齡最大的

    a,定義一個Person類型的變量, 先記住第一個元素

    b,循環遍歷集合

    c,用每個元素和變量比較年齡, 若是集合中的元素比變量記住的年齡大

    d,用變量記住這個年齡較大的元素

    e,返回變量記住的元素

3,把集合中的元素反轉

    a,定義循環, 循環size()/2次

    b,第一次交換第一個和最後一個, 第二次交換第二個和倒數第二個

 

4,public static void main(String[] args) {

      List<String> list1 = new ArrayList<>();

      list1.add("b");

      list1.add("f");

      list1.add("e");

      list1.add("c");

      list1.add("a");

      list1.add("d");

      sort1(list1);

      System.out.println(list1); // a, b, c, d, e, f

      List<Integer> list2 = new ArrayList<>();

      list2.add(5);

      list2.add(8);

      list2.add(3);

      list2.add(1);

      list2.add(4);

 

      sort2(list2);

      System.out.println(list2); //1,3,4,5,8

  }

對集合中添加的元素排序

5,List<String> list = new ArrayList<>();

  list.add("a");

  list.add("a");

  list.add("a");

  list.add("b");

  list.add("b");

  list.add("c");

  list.add("d");

  list.add("d");

  list.add("d");

  list.add("d");

  list.add("d");

  System.out.println(frequency(list, "a")); // 3

  System.out.println(frequency(list, "b")); // 2

  System.out.println(frequency(list, "c")); // 1

  System.out.println(frequency(list, "d")); // 5

  System.out.println(frequency(list, "xxx")); // 0

  定義方法統計集合中指定元素出現的次數

6,定義一個replaceAll方法,將傳入的新值替換集合中的老值(list,old,new)