java學(xué)習(xí)筆記6

迭代器的原理及源碼解析

A:迭代器原理
- 迭代器原理:迭代器是對(duì)集合進(jìn)行遍歷,而每一個(gè)集合內(nèi)部的存儲(chǔ)結(jié)構(gòu)都是不同的,所以每一個(gè)集合存和取都是不一樣,那么就需要在每一個(gè)類中定義hasNext()和next()方法,這樣做是可以的,但是會(huì)讓整個(gè)集合體系過于臃腫,迭代器是將這樣的方法向上抽取出接口,然后在每個(gè)類的內(nèi)部,定義自己迭代方式,這樣做的好處有二,第一規(guī)定了整個(gè)集合體系的遍歷方式都是hasNext()和next()方法,第二,代碼有底層內(nèi)部實(shí)現(xiàn),使用者不用管怎么實(shí)現(xiàn)的,會(huì)用即可
B:迭代器源碼解析
- 1,在eclipse中ctrl + shift + t找到ArrayList類
- 2,ctrl+o查找iterator()方法
- 3,查看返回值類型是new Itr(),說明Itr這個(gè)類實(shí)現(xiàn)Iterator接口
- 4,查找Itr這個(gè)內(nèi)部類,發(fā)現(xiàn)重寫了Iterator中的所有抽象方法

List集合的特有功能概述和測試

A:List集合的特有功能概述
- void add(int index,E element)
- E remove(int index)
- E get(int index)
- E set(int index,E element)

package com.heima.list;

import java.util.ArrayList;
import java.util.List;

public class Demo1_List {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.set(1,"z");
        System.out.println(list);
    }

    public static void demo4() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //通過索引遍歷List集合
        for(int i = 0;i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static void demo3() {
        List list = new ArrayList();
        list.add(111);
        list.add(222);
        list.add(333);
        
        list.remove(111);           //刪除的時(shí)候不會(huì)自動(dòng)裝箱异剥，把111當(dāng)作索引
        System.out.println(list);
    }

    public static void demo2() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        
        Object obj = list.remove(1);        //通過索引刪除元素滨达，將被刪除的元素返回
        System.out.println(obj);
        System.out.println(list);
    }

    public static void demo1() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add(4,"e");    //index<=size并且>=0都不會(huì)報(bào)異常
        //list.add(10,"z"); //java.lang.IndexOutOfBoundsException,
        System.out.println(list);//當(dāng)存儲(chǔ)時(shí)使用不存在的索引時(shí)横蜒，就會(huì)出現(xiàn)索引越界異常
    }

}

List集合存儲(chǔ)學(xué)生對(duì)象并遍歷

package com.heima.list;

import java.util.ArrayList;
import java.util.List;

import com.heima.bean.Student;

public class Demo2_List {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Student("張三",23));
        list.add(new Student("李四",24));
        list.add(new Student("王五",25));
        list.add(new Student("趙六",26));
        
        for (int i = 0; i < list.size(); i++) {
            //System.out.println(list.get(i));
            Student s = (Student)list.get(i);
            System.out.println(s.getName());
        }
    }

}

并發(fā)修改異常產(chǎn)生的原因及解決方案

A:案例演示
- 需求：我有一個(gè)集合，請(qǐng)問中狂，我想判斷里面有沒有"world"這個(gè)元素，如果有，我就添加一個(gè)"javaee"元素冒签，請(qǐng)寫代碼實(shí)現(xiàn)控汉。
B:ConcurrentModificationException出現(xiàn)
- 迭代器遍歷笔诵，集合修改集合
C:解決方案
- a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
- b:集合遍歷元素暇番，集合修改元素

ListIterator

boolean hasNext()是否有下一個(gè)
boolean hasPrevious()是否有前一個(gè)
Object next()返回下一個(gè)元素
Object previous();返回上一個(gè)元素

package com.heima.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo4_ListIterator {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");                                  //Object obj = new String();
        list.add("b");
        list.add("world");
        list.add("c");
        list.add("d");
        list.add("e");
        
        ListIterator lit = list.listIterator();         //獲取迭代器
        while(lit.hasNext()) {
            System.out.println(lit.next());             //獲取元素并將指針向后移動(dòng)
        }
        
        System.out.println("-----------------");
        
        while(lit.hasPrevious()) {
            System.out.println(lit.previous());         //獲取元素并將指針向前移動(dòng)
        }
    }

}

Vector的特有功能

A:Vector類概述
B:Vector類特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements()

package com.heima.list;

import java.util.Enumeration;
import java.util.Vector;

public class Demo5_Vector {

    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement("a");
        v.addElement("b");
        v.addElement("c");
        v.addElement("d");
        
        Enumeration en = v.elements();              //獲取枚舉
        while(en.hasMoreElements()) {               //判斷集合中是否有元素
            System.out.println(en.nextElement());   //獲取集合中的元素
        }
    }

}

數(shù)據(jù)結(jié)構(gòu)之?dāng)?shù)組和鏈表

A:數(shù)組
- 查詢快修改也快
- 增刪慢
B:鏈表
- 查詢慢,修改也慢
- 增刪快
  
  數(shù)組.jpg
  
  鏈表.jpg

List的三個(gè)子類的特點(diǎn)

A:List的三個(gè)子類的特點(diǎn)

  ArrayList:
      底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組嗤放，查詢快，增刪慢壁酬。
      線程不安全次酌，效率高。

  Vector:
      底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組舆乔，查詢快岳服，增刪慢。
      線程安全希俩，效率低吊宋。
  Vector相對(duì)ArrayList查詢慢(線程安全的)
  Vector相對(duì)LinkedList增刪慢(數(shù)組結(jié)構(gòu))

  LinkedList:
      底層數(shù)據(jù)結(jié)構(gòu)是鏈表，查詢慢颜武，增刪快璃搜。
      線程不安全，效率高鳞上。

  Vector和ArrayList的區(qū)別
      Vector是線程安全的,效率低
      ArrayList是線程不安全的,效率高
  共同點(diǎn):都是數(shù)組實(shí)現(xiàn)的

  ArrayList和LinkedList的區(qū)別
      ArrayList底層是數(shù)組結(jié)果,查詢和修改快
      LinkedList底層是鏈表結(jié)構(gòu)的,增和刪比較快,查詢和修改比較慢
  共同點(diǎn):都是線程不安全的

B:List有三個(gè)兒子这吻，我們到底使用誰呢?
查詢多用ArrayList
增刪多用LinkedList
如果都多ArrayList

去除ArrayList中重復(fù)字符串元素方式

package com.heima.list;

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

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");
        list.add("c");
        ArrayList newList = getSingle(list);
        System.out.println(newList);
    }
    
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList();                //1,創(chuàng)建新集合
        Iterator it = list.iterator();          //2,根據(jù)傳入的集合（老集合）獲取迭代器
        while(it.hasNext()) {                   //3,遍歷老集合
            Object obj = it.next();             //記錄住每一個(gè)元素
            if(!newList.contains(obj)) {    //如果新集合中不包含老集合的元素，則將該元素添加
                newList.add(obj);
            }
        }
        return newList;
    }

}

去除ArrayList中重復(fù)自定義對(duì)象元素

package com.heima.list;

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

import com.heima.bean.Person;

public class Demo2_ArrayList {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList list = new ArrayList();               //創(chuàng)建集合對(duì)象
        list.add(new Person("張三", 23));
        list.add(new Person("張三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("王麻子", 25));
        
        //ArrayList newList = getSingle(list);
        //System.out.println(newList);
        list.remove(new Person("張三", 23));  //一次只能刪除一個(gè)new Person("張三", 23)
        System.out.println(list);
    }
    
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList();                //1,創(chuàng)建新集合
        Iterator it = list.iterator();          //2,根據(jù)傳入的集合（老集合）獲取迭代器
        while(it.hasNext()) {                   //3,遍歷老集合
            Object obj = it.next();             //記錄住每一個(gè)元素
            if(!newList.contains(obj)) {    //如果新集合中不包含老集合的元素篙议，則將該元素添加
                newList.add(obj);           //contains和remove底層依賴的是equals方法
            }
        }
        return newList;
    }
}

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);

package com.heima.list;

import java.util.LinkedList;

public class Demo3_LinkedList {

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.addFirst("a");
        list.addFirst("b");
        list.addFirst("c");
        list.addLast("d");
        
        //System.out.println(list.getFirst());  //c 
        //System.out.println(list.getLast());       //d
        
        //System.out.println(list.removeFirst());   //c
        //System.out.println(list.removeLast());    //d
        
        System.out.println(list.get(1));            //b 
        System.out.println(list);
    }

}

棧和隊(duì)列數(shù)據(jù)結(jié)構(gòu)

棧
- 先進(jìn)后出
隊(duì)列
- 先進(jìn)先出

用LinkedList模擬棧數(shù)據(jù)結(jié)構(gòu)的集合并測試

package com.heima.list;

import java.util.LinkedList;

public class Demo4_LinkedList {

    public static void main(String[] args) {
        Stack s = new Stack();
        s.in("a");  //進(jìn)棧
        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();         //創(chuàng)建集合對(duì)象
        list.addLast("a");
        list.addLast("b");
        list.addLast("c");
        list.addLast("d");
        while(!list.isEmpty()) {
            System.out.println(list.removeLast());
        }
    }

}

package com.heima.list;

import java.util.LinkedList;

public class Stack {
    private LinkedList list = new LinkedList();
    //模擬進(jìn)棧方法
    public void in(Object obj) {
        list.addLast(obj);
    }
    //模擬出棧
    public Object out() {
        return list.removeLast();
    }
    //模擬棧結(jié)構(gòu)是否為空
    public boolean isEmpty() {
        return list.isEmpty();
    }
}

泛型概述和基本使用

A:泛型概述
B:泛型好處
- 提高安全性(將運(yùn)行期的錯(cuò)誤轉(zhuǎn)換到編譯期)
- 省去強(qiáng)轉(zhuǎn)的麻煩
C:泛型基本使用
- <>中放的必須是引用數(shù)據(jù)類型
D:泛型使用注意事項(xiàng)
- 前后的泛型必須一致,或者后面的泛型可以省略不寫(1.7的新特性菱形泛型)

package com.heima.generic;

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

import com.heima.bean.Person;

public class Demo1_Generic {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //int[] arr = new byte[5];  //數(shù)組要保證前后的數(shù)據(jù)類型一致
        //ArrayList<Object> list = new ArrayList<Person>(); //集合的泛型要保證前后的數(shù)據(jù)類型一致 
        //ArrayList<Object> list = new ArrayList<>();   //1.7版本的新特性唾糯，菱形泛型
        ArrayList<Object> list = new ArrayList<>();
        //泛型最好不要定位成Object怠硼，因?yàn)槿魏晤惗际荗bject類的子類，所以和不加<>是一樣的效果
        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().getName());//next方法會(huì)將指針向后移動(dòng)
            //調(diào)用next方法多次移怯，會(huì)將指針向后移動(dòng)多次
        }
    }

}

ArrayList存儲(chǔ)字符串和自定義對(duì)象并遍歷泛型版

package com.heima.generic;

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

import com.heima.bean.Person;

public class Demo2_Generic {

    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        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();       //將集合中的每一個(gè)元素用Person記錄
            System.out.println(p);
        }
    }

    public static void demo1() {
        ArrayList<String> list = new ArrayList<>(); //創(chuàng)建集合對(duì)象
        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());
        }
    }

}

泛型的由來

A:案例演示
- 泛型的由來:通過Object轉(zhuǎn)型問題引入
- 早期的Object類型可以接收任意的對(duì)象類型香璃，但是在實(shí)際的使用中，會(huì)有類型轉(zhuǎn)換的問題舟误。也就存在這隱患葡秒，所以Java提供了泛型來解決這個(gè)安全問題。

泛型類的概述及使用

A:泛型類概述<T>
* 把泛型定義在類上

B:定義格式
- public class 類名<泛型類型1,…>
C:注意事項(xiàng)
- 泛型類型必須是引用類型
D:案例演示
- 泛型類的使用

泛型方法的概述和使用

A:泛型方法概述
- 把泛型定義在方法上
B:定義格式
- public <泛型類型> 返回類型方法名(泛型類型變量名)
C:案例演示
- 泛型方法的使用

package com.heima.bean;

public class Tool<Q> {
    private Q q;
    
    /*public void show(Q q) {   //方法泛型最好與類的泛型一致
        System.out.println(q);
    }*/
    
    public<T> void show(T t) {  //如果不一致脐帝，需要在方法上聲明該泛型
        System.out.println(t);
    }
    public static<W> void print(W w) {  //靜態(tài)方法必須聲明自己的泛型
        System.out.println(w);  //因?yàn)轭惖姆盒褪穷悓?shí)例化的時(shí)候（生成對(duì)象的時(shí)候）傳入的同云，靜態(tài)方法是隨著類的加載而加載，矛盾堵腹。
    }
}

泛型接口的概述和使用

A:泛型接口概述
- 把泛型定義在接口上
B:定義格式
- public interface 接口名<泛型類型>
C:案例演示
- 泛型接口的使用

package com.heima.generic;

public class Demo4_Generic {

    public static void main(String[] args) {

    }

}

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> {         //沒有必須在實(shí)現(xiàn)接口的時(shí)候給自己類加泛型

    @Override
    public void show(T t) {
        System.out.println(t);
    }
    
}

泛型高級(jí)之通配符

A:泛型通配符<?>
- 任意類型炸站，如果沒有明確，那么就是Object以及任意的Java類了
B:? extends E
- 向下限定疚顷，E及其子類
C:? super E
- 向上限定旱易，E及其父類

package com.heima.generic;

import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo5_Generic {

    public static void main(String[] args) {
        //List<?> list = new ArrayList<Integer>();//當(dāng)右邊的泛型時(shí)不確定時(shí)，左邊也可以指定為腿堤？       
        ArrayList<Person> list1 = new ArrayList<>();
        list1.add(new Person("張三",23));
        list1.add(new Person("李四",24));
        list1.add(new Person("王五",25));
        
        ArrayList<Person> list2 = new ArrayList<>();
        list2.add(new Person("趙六",26));
        list2.add(new Person("周七",27));
        
        list1.addAll(list2);        //list2必須是list1的子類阀坏，子類提升為父類
        System.out.println(list1);
    }

}

增強(qiáng)for的概述和使用

A:增強(qiáng)for概述
- 簡化數(shù)組和Collection集合的遍歷
B:格式：
for(元素?cái)?shù)據(jù)類型變量 : 數(shù)組或者Collection集合) {
使用變量即可，該變量就是元素
}
C:案例演示
- 數(shù)組笆檀，集合存儲(chǔ)元素用增強(qiáng)for遍歷
D:好處
- 簡化遍歷

package com.heima.jdk5;

import java.util.ArrayList;

import com.heima.bean.Person;
//增強(qiáng)for循環(huán)底層依賴的是迭代器(Iterator)
public class Demo1_Foreach {

    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        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);
        }
    }

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

}

三種迭代的能否刪除

普通for循環(huán),可以刪除,但是索引要--
迭代器,可以刪除,但是必須使用迭代器自身的remove方法,否則會(huì)出現(xiàn)并發(fā)修改異常
增強(qiáng)for循環(huán)不能刪除

package com.heima.jdk5;

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

import com.heima.bean.Person;
//增強(qiáng)for循環(huán)底層依賴的是迭代器(Iterator)
public class Demo1_Foreach {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("a");
        list.add("d");
        list.add("b");
        list.add("b");
        //1,普通for循環(huán)刪除
        /*for(int i = 0;i < list.size(); i++) {
            if("b".equals(list.get(i))) {
                list.remove(i--);   //刪除的時(shí)候后面的所有元素都向前移一位忌堂，所以索引要--
                //就算b出現(xiàn)在第一位也不會(huì)報(bào)錯(cuò)，因?yàn)閳?zhí)行i--后會(huì)執(zhí)行i++酗洒。
            }
        }*/
        //2,迭代器刪除
        /*for(Iterator<String> it2 = list.iterator(); it2.hasNext();) {
            if("b".equals(it2.next())) {
                it2.remove();
            }
        }*/
        /*Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            if("b".equals(it.next())) {
                //list.remove("b"); //不能用集合的刪除方法士修，因?yàn)榈^程中如果集合修改會(huì)出現(xiàn)并發(fā)修改異常
                it.remove();
            }
        }*/
        //3,增強(qiáng)for循環(huán)不能刪除，只能遍歷樱衷。因?yàn)樵鰪?qiáng)for循環(huán)的底層是通過迭代器實(shí)現(xiàn)的棋嘲，調(diào)用集合的remove方法會(huì)引發(fā)并發(fā)修改異常
        for (String string : list) {
            if("b".equals(string)) {
                list.remove("b");
            }
        }
        System.out.println(list);
    }
    
    
    public static void demo2() {
        ArrayList<Person> list = new ArrayList<>();
        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);
        }
    }

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

}

靜態(tài)導(dǎo)入的概述和使用

A:靜態(tài)導(dǎo)入概述
B:格式：
- import static 包名….類名.方法名;
- 可以直接導(dǎo)入到方法的級(jí)別
C:注意事項(xiàng)
- 方法必須是靜態(tài)的,如果有多個(gè)同名的靜態(tài)方法，容易不知道使用誰?
  這個(gè)時(shí)候要使用矩桂，必須加前綴沸移。由此可見，意義不大侄榴，所以一般不用雹锣，但是要能看懂。

package com.heima.jdk5;

import static java.util.Arrays.sort;        //靜態(tài)導(dǎo)入
import static java.util.Arrays.toString;

public class Demo2_StaticImport {
    //靜態(tài)導(dǎo)入開發(fā)不用癞蚕，但是需要能看懂
    public static void main(String[] args) {
        int[] arr = {55,22,33,44,11};
        //Arrays.sort(arr);             //排序
        sort(arr);
        //System.out.println(Arrays.toString(arr));
        //System.out.println(toString(arr));        //toString方法靜態(tài)導(dǎo)入不能用
        System.out.println(arr);
    }

}

可變參數(shù)的概述和使用

A:可變參數(shù)概述
- 定義方法的時(shí)候不知道該定義多少個(gè)參數(shù)
B:格式
- 修飾符返回值類型方法名(數(shù)據(jù)類型… 變量名){}
C:注意事項(xiàng)：
- 這里的變量其實(shí)是一個(gè)數(shù)組
- 如果一個(gè)方法有可變參數(shù)蕊爵，并且有多個(gè)參數(shù)，那么涣达，可變參數(shù)肯定是最后一個(gè)

package com.heima.jdk5;

public class Demo3_ChangeableArgs {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        //print(arr);
        print(11,22,33,44,55);      //只支持可變參數(shù)的形式
        //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 x,int ... arr) {           //可變參數(shù)其實(shí)是一個(gè)數(shù)組
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

Arrays工具類的asList()方法的使用

A:案例演示
- Arrays工具類的asList()方法的使用
- Collection中toArray(T[] a)泛型版的集合轉(zhuǎn)數(shù)組

package com.heima.jdk5;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Demo4_AsList {

    /**
     * 數(shù)組轉(zhuǎn)換成集合雖然不能增加或減少元素在辆，但是可以用集合的思想操作數(shù)組，也就是說可以使用其他集合中的方法
     */
    public static void main(String[] args) {
        //集合轉(zhuǎn)數(shù)組度苔，加泛型的
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        
        String[] arr = list.toArray(new String[10]);    
        for (String string : arr) {     //當(dāng)集合轉(zhuǎn)換數(shù)組時(shí)匆篓，數(shù)組長度如果是小于等于集合的size時(shí)，轉(zhuǎn)換后的數(shù)組長度等于集合的size
            System.out.println(string); //如果數(shù)組的長度大于了size寇窑，分配的數(shù)組長度就和你指定的長度一樣鸦概，自動(dòng)補(bǔ)上null
        }
    }

    public static void demo2() {
        /*int[] arr = {11,22,33,44,55};
        List<int[]> list = Arrays.asList(arr);  //將整個(gè)數(shù)組放在集合里面，泛型是int型數(shù)組
        System.out.println(list);   //基本數(shù)據(jù)類型的數(shù)組轉(zhuǎn)換成集合甩骏，會(huì)將整個(gè)數(shù)組當(dāng)作一個(gè)對(duì)象轉(zhuǎn)換
*/  
        Integer[] arr = {11,22,33,44,55};   //將數(shù)組轉(zhuǎn)換成集合窗市，數(shù)組必須是引用數(shù)據(jù)類型
        List<Integer> list = Arrays.asList(arr);
        System.out.println(list);
    }

    public static void demo1() {
        String[] arr = {"a","b","c"};
        List<String> list = Arrays.asList(arr);     //數(shù)組轉(zhuǎn)換成集合
        //list.add("d");    //UnsupportedOperationException，不能添加
        System.out.println(list);
    }

}

集合嵌套之ArrayList嵌套ArrayList

package com.heima.list;

import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo5_ArrayListArrayList {

    public static void main(String[] args) {
        ArrayList<ArrayList<Person>> list = new ArrayList<>();
        
        ArrayList<Person> first = new ArrayList<>();    //創(chuàng)建第一個(gè)班級(jí)
        first.add(new Person("楊冪",30));
        first.add(new Person("李冰冰",33));
        first.add(new Person("范冰冰",20));
        
        ArrayList<Person> second = new ArrayList<>();
        second.add(new Person("黃曉明",31));
        second.add(new Person("趙薇",33));
        second.add(new Person("陳坤",32));
        
        //將班級(jí)添加到學(xué)科集合中
        list.add(first);
        list.add(second);
        
        //遍歷學(xué)科集合
        for (ArrayList<Person> a : list) {
            for (Person p : a) {
                System.out.println(p);
            }
        }
    }

}

HashSet儲(chǔ)存字符串并遍歷

package com.heima.set;

import java.util.HashSet;

public class Demo1_HashSet {

    /**
     * Set集合饮笛，無索引咨察，不可以重復(fù)，無序(存取不一致)
     */
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();   //創(chuàng)建HashSet對(duì)象
        boolean b1 = hs.add("a");
        boolean b2 = hs.add("a");   //當(dāng)向set集合中儲(chǔ)存重復(fù)元素的時(shí)候返回為false
        hs.add("b");
        hs.add("c");
        hs.add("d");
        System.out.println(hs);     //HashSet的繼承體系中有重寫toString方法
        System.out.println(b1);
        System.out.println(b2);
        
        for (String string : hs) {  //只要能用迭代器迭代的福青，就可以使用增強(qiáng)for循環(huán)遍歷
            System.out.println(string);
        }
    }

}

HashSet如何保證元素唯一性的原理

1.HashSet原理
- 我們使用set集合都是需要去掉重復(fù)元素的摄狱，如果在存儲(chǔ)的時(shí)候逐個(gè)equals比較，效率較低无午，哈希算法提高了去重復(fù)的效率媒役，降低了使用equals()方法的次數(shù)
- 當(dāng)HashSet調(diào)用add()方法存儲(chǔ)對(duì)象的時(shí)候，先調(diào)用對(duì)象的hashCode()方法得到一個(gè)哈希值宪迟，然后再集合中查找是否有哈希值相同的對(duì)象
  - 如果沒有哈希值相同的對(duì)象就直接存入集合
  - 如果有哈希值相同的對(duì)象酣衷，就和哈希值相同的對(duì)象逐個(gè)進(jìn)行equals比較，比較結(jié)果為false就存入次泽，true則不存
2.將自定義類的對(duì)象存入HashSet去重復(fù)
- 類中必須重寫hashCode()和equals()方法
- hashCode()：屬性相同的對(duì)象返回值必須相同穿仪，屬性不同的返回值盡量不同（提高效率）
- equals()：屬性相同返回true，屬性不同返回false箕憾，返回false的時(shí)候儲(chǔ)存

package com.heima.bean;

public class Person {
    private String name;
    private int age;    
    public Person() {
        super();
        
    }
    public Person(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 String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    /*@Override
    public boolean equals(Object obj) {
        System.out.println("執(zhí)行了嗎");
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
    @Override
    public int hashCode() {
        final int NUM = 38;
        return name.hashCode() * NUM + age;
    }*/
    /*
     * 為什么是31牡借？
     * 1，31是一個(gè)質(zhì)數(shù)袭异，質(zhì)數(shù)是能被1和自己本身整除的數(shù)
     * 2钠龙，31這個(gè)數(shù)既不大也不小
     * 3，31這個(gè)數(shù)好算御铃，2的五次方-1碴里，2向左移動(dòng)5位減一
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)    //調(diào)用的對(duì)象和傳入的對(duì)象是同一個(gè)對(duì)象
            return true;    //直接返回true
        if (obj == null)    //傳入的對(duì)象為null
            return false;   //返回false
        if (getClass() != obj.getClass())   //判斷兩個(gè)對(duì)象對(duì)應(yīng)的字節(jié)碼文件是否是同一個(gè)字節(jié)碼
            return false;                   //如果不是直接返回false
        Person other = (Person) obj;        //向下轉(zhuǎn)型
        if (age != other.age)               //調(diào)用對(duì)象的年齡不等于傳入對(duì)象的年齡
            return false;                   //返回false
        if (name == null) {                 //調(diào)用對(duì)象的姓名為null
            if (other.name != null)         //傳入對(duì)象的姓名不為null
                return false;               //返回false
        } else if (!name.equals(other.name))//調(diào)用對(duì)象的姓名不為null，且不等于傳入對(duì)象的姓名
            return false;                   //返回false
        return true;                        //返回true
    }
    
    
}

package com.heima.set;

import java.util.HashSet;

import com.heima.bean.Person;

public class Demo1_HashSet {

    /**
     * Set集合上真，無索引咬腋，不可以重復(fù)，無序(存取不一致)
     */
    public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<>();
        hs.add(new Person("張三", 23));
        hs.add(new Person("張三", 23));
        hs.add(new Person("李四", 24));
        hs.add(new Person("李四", 24));
        hs.add(new Person("李四", 24));
        hs.add(new Person("李四", 24));
        
        System.out.println(hs);
    }

    public static void demo1() {
        HashSet<String> hs = new HashSet<>();   //創(chuàng)建HashSet對(duì)象
        boolean b1 = hs.add("a");
        boolean b2 = hs.add("a");   //當(dāng)向set集合中儲(chǔ)存重復(fù)元素的時(shí)候返回為false
        hs.add("b");
        hs.add("c");
        hs.add("d");
        System.out.println(hs);     //HashSet的繼承體系中有重寫toString方法
        System.out.println(b1);
        System.out.println(b2);
        
        for (String string : hs) {  //只要能用迭代器迭代的睡互，就可以使用增強(qiáng)for循環(huán)遍歷
            System.out.println(string);
        }
    }

}

LinkedHashSet的使用

package com.heima.set;

import java.util.LinkedHashSet;

public class Demo2_LinkedHashSet {

    /**
     * LinkedHashSet
     * 底層是鏈表實(shí)現(xiàn)的根竿，是set集合中唯一一個(gè)能保證怎么存就怎么取的集合對(duì)象
     * 因?yàn)槭荋ashSet的子類陵像，所以也是保證元素唯一的，與HashSet的原理一樣
     */
    public static void main(String[] args) {
        LinkedHashSet<String> lhs = new LinkedHashSet<>();
        lhs.add("a");
        lhs.add("a");
        lhs.add("b");
        lhs.add("c");
        lhs.add("a");
        lhs.add("b");
        lhs.add("c");
        System.out.println(lhs);
    }

}

練習(xí)

package com.heima.test;

import java.util.HashSet;
import java.util.Random;

public class Test1 {

    /**
     * 需求：編寫一個(gè)程序寇壳，獲取10個(gè)1至20的隨機(jī)數(shù)醒颖，要求隨機(jī)數(shù)不能重復(fù)。并把最終的隨機(jī)數(shù)輸出到控制臺(tái)
     * 1壳炎，有Random類創(chuàng)建隨機(jī)數(shù)對(duì)象
     * 2泞歉，需要存儲(chǔ)10個(gè)隨機(jī)數(shù)，而且不能重復(fù)匿辩，所以我們用HashSet集合
     * 3腰耙，如果HashSet的size是小于10就可以不斷的存儲(chǔ)，如果大于等于10就停止存儲(chǔ)
     * 4铲球，通過Random類中的nextInt(n)方法獲取1到20之間的隨機(jī)數(shù)挺庞，并將這些隨機(jī)數(shù)存儲(chǔ)在HashSet集合中
     * 5，遍歷HashSet
     */
    public static void main(String[] args) {
        //1稼病，有Random類創(chuàng)建隨機(jī)數(shù)對(duì)象
        Random r = new Random();
        //2挠阁，需要存儲(chǔ)10個(gè)隨機(jī)數(shù)，而且不能重復(fù)溯饵，所以我們用HashSet集合
        HashSet<Integer> hs = new HashSet<>();
        //3侵俗，如果HashSet的size是小于10就可以不斷的存儲(chǔ)，如果大于等于10就停止存儲(chǔ)
        while(hs.size() < 10) {
            //4丰刊，通過Random類中的nextInt(n)方法獲取1到20之間的隨機(jī)數(shù)隘谣，并將這些隨機(jī)數(shù)存儲(chǔ)在HashSet集合中
            hs.add(r.nextInt(20) + 1);
        }
        //5，遍歷HashSet
        for (Integer integer : hs) {
            System.out.println(integer);
        }
    }

}

package com.heima.test;

import java.util.HashSet;
import java.util.Scanner;

public class Test2 {

    /**
     * 使用Scanner從鍵盤讀取一行輸入啄巧，去掉其中重復(fù)字符寻歧，打印出不同的那些字符
     * aaaabbbcccddd
     * 分析：
     * 1，創(chuàng)建Scanner對(duì)象
     * 2秩仆，創(chuàng)建HashSet對(duì)象码泛，將字符存儲(chǔ)，去掉重復(fù)
     * 3澄耍，將字符串轉(zhuǎn)換為字符數(shù)組噪珊，獲取每一個(gè)字符存儲(chǔ)在HashSet集合中，自動(dòng)去除重復(fù)
     * 4齐莲，遍歷HashSet痢站，打印每一個(gè)字符
     */
    public static void main(String[] args) {
        //1，創(chuàng)建Scanner對(duì)象
        Scanner sc = new Scanner(System.in);
        System.out.println("請(qǐng)輸入一行字符串：");
        //2,創(chuàng)建HashSet對(duì)象选酗，將字符存儲(chǔ)阵难，去掉重復(fù)
        HashSet<Character> hs = new HashSet<>();
        //3，將字符串轉(zhuǎn)換為字符數(shù)組芒填，獲取每一個(gè)字符存儲(chǔ)在HashSet集合中呜叫，自動(dòng)去除重復(fù)
        String line = sc.nextLine();
        char[] arr = line.toCharArray();
        
        for (char c : arr) {        //char可以換成Character空繁，自動(dòng)裝箱
            hs.add(c);
        }
        //4，遍歷HashSet朱庆，打印每一個(gè)字符
        for(Character ch : hs) {    //Character可以換成char家厌，自動(dòng)拆箱
            System.out.print(ch);
        }
    }

}

package com.heima.test;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;

public class Test3 {

    /**
     * 需求：將集合中的重復(fù)元素去掉
     * 分析：
     * 1，創(chuàng)建List集合存儲(chǔ)若干個(gè)重復(fù)元素
     * 2椎工，單獨(dú)定義方法去除重復(fù)
     * 3，打印一下List集合
     */
    public static void main(String[] args) {
        //1蜀踏，創(chuàng)建List集合存儲(chǔ)若干個(gè)重復(fù)元素
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("d");
        list.add("d");
        //2维蒙，單獨(dú)定義方法去除重復(fù)
        getSingle(list);
        
        //3，打印一下List集合
        System.out.println(list);
    }
    /*
     * 去除List集合中的重復(fù)元素
     * 1果覆，創(chuàng)建一個(gè)LinkedHashSet集合
     * 2颅痊，將List集合中所有的元素添加到LinkedHashSet集合
     * 3，將List集合中的元素清除
     * 4局待，將LinkedHashSet集合中的元素添加回List集合中
     */
    private static void getSingle(List<String> list) {
        //1斑响，創(chuàng)建一個(gè)LinkedHashSet集合
        LinkedHashSet<String> lhs = new LinkedHashSet<>();
        //2，將List集合中所有的元素添加到LinkedHashSet集合
        lhs.addAll(list);
        //3钳榨，將List集合中的元素清除
        list.clear();
        //4舰罚，將LinkedHashSet集合中的元素添加回List集合中
        list.addAll(lhs);
    }

}

最后編輯于：2018.11.07 22:27:03

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者

人面猴
序言：七十年代末，一起剝皮案震驚了整個(gè)濱河市薛耻，隨后出現(xiàn)的幾起案子营罢，更是在濱河造成了極大的恐慌，老刑警劉巖饼齿，帶你破解...
沈念sama閱讀 217,509評(píng)論 6贊 504
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件饲漾，死亡現(xiàn)場離奇詭異，居然都是意外死亡缕溉，警方通過查閱死者的電腦和手機(jī)考传，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 92,806評(píng)論 3贊 394
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進(jìn)店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來证鸥，“玉大人僚楞，你說我怎么就攤上這事⊥鞑悖” “怎么了镜硕？”我有些...
開封第一講書人閱讀 163,875評(píng)論 0贊 354
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長返干。經(jīng)常有香客問我兴枯，道長，這世上最難降的妖魔是什么矩欠？我笑而不...
開封第一講書人閱讀 58,441評(píng)論 1贊 293
?港島之戀（遺憾婚禮）
正文為了忘掉前任财剖，我火速辦了婚禮悠夯，結(jié)果婚禮上，老公的妹妹穿的比我還像新娘躺坟。我一直安慰自己沦补，他們只是感情好，可當(dāng)我...
茶點(diǎn)故事閱讀 67,488評(píng)論 6贊 392
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布咪橙。她就那樣靜靜地躺著夕膀，像睡著了一般。火紅的嫁衣襯著肌膚如雪美侦。梳的紋絲不亂的頭發(fā)上产舞，一...
開封第一講書人閱讀 51,365評(píng)論 1贊 302
城市分裂傳說
那天，我揣著相機(jī)與錄音菠剩，去河邊找鬼易猫。笑死，一個(gè)胖子當(dāng)著我的面吹牛具壮，可吹牛的內(nèi)容都是我干的准颓。我是一名探鬼主播，決...
沈念sama閱讀 40,190評(píng)論 3贊 418
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼棺妓，長吁一口氣：“原來是場噩夢啊……” “哼攘已！你這毒婦竟也來了？” 一聲冷哼從身側(cè)響起怜跑，我...
開封第一講書人閱讀 39,062評(píng)論 0贊 276
萬榮殺人案實(shí)錄
序言：老撾萬榮一對(duì)情侶失蹤贯被，失蹤者是張志新（化名）和其女友劉穎，沒想到半個(gè)月后妆艘，有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體彤灶，經(jīng)...
沈念sama閱讀 45,500評(píng)論 1贊 314
?護(hù)林員之死
正文獨(dú)居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點(diǎn)故事閱讀 37,706評(píng)論 3贊 335
?白月光啟示錄
正文我和宋清朗相戀三年批旺，在試婚紗的時(shí)候發(fā)現(xiàn)自己被綠了幌陕。大學(xué)時(shí)的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片。...
茶點(diǎn)故事閱讀 39,834評(píng)論 1贊 347
活死人
序言：一個(gè)原本活蹦亂跳的男人離奇死亡汽煮，死狀恐怖搏熄，靈堂內(nèi)的尸體忽然破棺而出，到底是詐尸還是另有隱情暇赤，我是刑警寧澤心例，帶...
沈念sama閱讀 35,559評(píng)論 5贊 345
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布，位于F島的核電站鞋囊，受9級(jí)特大地震影響汽久，放射性物質(zhì)發(fā)生泄漏尿招。R本人自食惡果不足惜驮审，卻給世界環(huán)境...
茶點(diǎn)故事閱讀 41,167評(píng)論 3贊 328
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望瓜喇。院中可真熱鬧，春花似錦歉糜、人聲如沸乘寒。這莊子的主人今日做“春日...
開封第一講書人閱讀 31,779評(píng)論 0贊 22
一樁弒父案匪补，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽伞辛。三九已至，卻和暖如春夯缺，著一層夾襖步出監(jiān)牢的瞬間蚤氏，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 32,912評(píng)論 1贊 269
情欲美人皮
我被黑心中介騙來泰國打工喳逛，沒想到剛下飛機(jī)就差點(diǎn)兒被人妖公主榨干…… 1. 我叫王不留，地道東北人棵里。一個(gè)月前我還...
沈念sama閱讀 47,958評(píng)論 2贊 370
代替公主和親
正文我出身青樓润文，卻偏偏與公主長得像，于是被迫代替她去往敵國和親殿怜。傳聞我的和親對(duì)象是個(gè)殘疾皇子典蝌，可洞房花燭夜當(dāng)晚...
茶點(diǎn)故事閱讀 44,779評(píng)論 2贊 354

java學(xué)習(xí)筆記6

迭代器的原理及源碼解析

List集合的特有功能概述和測試

List集合存儲(chǔ)學(xué)生對(duì)象并遍歷

并發(fā)修改異常產(chǎn)生的原因及解決方案

ListIterator

Vector的特有功能

數(shù)據(jù)結(jié)構(gòu)之?dāng)?shù)組和鏈表

List的三個(gè)子類的特點(diǎn)

去除ArrayList中重復(fù)字符串元素方式

去除ArrayList中重復(fù)自定義對(duì)象元素

LinkedList的特有功能

棧和隊(duì)列數(shù)據(jù)結(jié)構(gòu)

用LinkedList模擬棧數(shù)據(jù)結(jié)構(gòu)的集合并測試

泛型概述和基本使用

ArrayList存儲(chǔ)字符串和自定義對(duì)象并遍歷泛型版

泛型的由來

泛型類的概述及使用

泛型方法的概述和使用

泛型接口的概述和使用

泛型高級(jí)之通配符

增強(qiáng)for的概述和使用

三種迭代的能否刪除

靜態(tài)導(dǎo)入的概述和使用

可變參數(shù)的概述和使用

Arrays工具類的asList()方法的使用

集合嵌套之ArrayList嵌套ArrayList

HashSet儲(chǔ)存字符串并遍歷

HashSet如何保證元素唯一性的原理

LinkedHashSet的使用

練習(xí)

推薦閱讀更多精彩內(nèi)容