Java學習筆記（15）

阿新 • • 發佈：2019-04-04

構造函數上一個 scan 否則筆記 poll() pre 最後一個元素 reg

iterator方法

叠代器的作用：就是用於抓取集合中的元素

註：叠代器返回的一個接口類型的實現類，是一種多態的用法，而不是接口在調用方法

public class Demo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Money m=test();
        m.makeMoney();
    }
    public static Money test(){
        return new Worker();
    }
}
 
interface Money{
    public void makeMoney();
}
class Worker implements Money{
    @Override
    public void makeMoney() {
        // TODO Auto-generated method stub
        System.out.println("工人在賺錢...");
    }
}

結果：
工人在賺錢...

這裏就用了多態，返回了一個Money的實現類

hasNext() 　　　問是否有元素可以遍歷，若可以，則返回true

　　如果仍有元素可以叠代，則返回 true。
next() 　　　　獲取元素
　　返回叠代的下一個元素。
remove()
　　從叠代器指向的 collection 中移除叠代器返回的最後一個元素（可選操作）

import java.util.ArrayList;
public class Demo1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Collection c=new 
 ArrayList();
        c.add("狗娃");
        c.add("狗剩");
        c.add("鐵蛋");
        c.add("美美");
        //遍歷集合的元素：--------->方式一：可以使用toArray方法
        /*Object[] arr=c.toArray();//把集合的元素存儲到一個Object的數組中返回
        System.out.println("集合的元素為:"+Arrays.toString(arr));
        */
        //要求使用iterator叠代器遍歷
        Iterator it=c.iterator();//返回一個叠代器
        System.out.println("有元素可以遍歷嗎？"+it.hasNext());
        while (it.hasNext()) {
            System.out.println("元素:"+it.next());//獲取元素
        }
        it.remove();
        System.out.println("集合的元素:"+c);
    }
    

}

結果：
有元素可以遍歷嗎？true
元素:狗娃
元素:狗剩
元素:鐵蛋
元素:美美
集合的元素:[狗娃, 狗剩, 鐵蛋]

作業2：使用集合實現註冊登陸功能，

第一步：提示用戶選擇功能， A（註冊） B(登陸) 。要求：功能選擇的時候要忽略大小寫。

註冊：
1. 提示用戶輸入註冊的賬號(數字)與密碼，如果輸入的id號已經存在集合中，提示用戶重新輸入。註冊完畢之後，把集合中的所有用戶信息打印出來。(使用：toArrry()方法)

登陸：
提示用戶輸入登陸的賬號與密碼,如果賬號與密碼這個用戶已經存在集合中，那麽登陸成功，否則登陸失敗。

import java.util.ArrayList;
public class Demo3 {

    static Scanner sc=new Scanner(System.in);
    static Collection users=new ArrayList();//使用該集合保存所有的用戶信息
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        while (true) {
            System.out.println("請選擇功能： A（註冊）   B（登陸） ");
            String option=sc.next();
            if ("a".equalsIgnoreCase(option)) {
                reg();
            }
            else if ("b".equalsIgnoreCase(option)) {
                login();
            }
            else {
                System.out.println("你的選擇有誤，請重新輸入！");
            }
        }
    }

    public static void login() {
        System.out.println("你選擇了登錄功能...");
        System.out.println("請輸入賬號:");
        int id=sc.nextInt();
        System.out.println("請輸入密碼:");
        String password=sc.next();
        //判斷集合的用戶是否存在該用戶名與密碼
        //遍歷集合的元素,查看是否存在該用戶信息
        
        boolean isLogin=false;//定義一個變量用於記錄是否登錄成功的信息,默認是沒有登錄成功的
        Iterator it=users.iterator();
        while (it.hasNext()) {
            User user=(User)it.next();
            if (user.getId()==id&&user.getPassword().equals(password)) {
                //存在該用戶信息,登錄成功
                isLogin=true;
            }
        }
        if (isLogin) {
            System.out.println("歡迎登錄...");
        }
        else {
            System.out.println("用戶名或者密碼錯誤，登錄失敗...");
        }
    }

    public static void reg() {
        User user =null;
        while (true) {
            System.out.println("請輸入賬號");
            int id=sc.nextInt();
            user =new User(id,null);
            //System.out.println(id);
            if (users.contains(user)) {
                //如果存在
                System.out.println("該賬號已經存在，請重新輸入賬號");
            }
            else {
                //如果不存在
                break;
            }
        }
        //System.out.println(user.getId());
        System.out.println("請輸入密碼:");
        String password=sc.next();
        user.setPassword(password);
        //把user對象保存到集合中
        users.add(user);
        System.out.println("註冊成功！");
        System.out.println("當前註冊的人員:"+users);
    }

}
class User{
    private int id;
    private String password;
    
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public User() {}
    public User(int id,String password) {
        this.id=id;
        this.password=password;
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        User user=(User)obj;
        return this.id==user.id;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "{賬號:"+this.id+" 密碼:"+this.password;
    }
}

結果：
請選擇功能： A（註冊）   B（登陸） 
a
請輸入賬號
110
請輸入密碼:
gouwa
註冊成功！
當前註冊的人員:[{賬號:110 密碼:gouwa]
請選擇功能： A（註冊）   B（登陸） 
b
你選擇了登錄功能...
請輸入賬號:
110
請輸入密碼:
gouwa
歡迎登錄...
請選擇功能： A（註冊）   B（登陸） 
c
你的選擇有誤，請重新輸入！
請選擇功能： A（註冊）   B（登陸） 
b
你選擇了登錄功能...
請輸入賬號:
110
請輸入密碼:
gou
用戶名或者密碼錯誤，登錄失敗...
請選擇功能： A（註冊）   B（登陸）

List接口：有序，可重復

有序：集合的有序不是指自然順序，而是指添加進去的順序與元素出來的順序是一致的。

ctrl+shift+/ 添加多行註釋

ctrl+shift+\ 取消多行註釋

添加：

add(int index, E element) 　　　　把元素添加到集合的指定索引值位置上
addAll(Collection<? extends E> c) 　　　　把參數集合的元素添加到調用者集合指定索引值的位置上

public class Demo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        list.add("狗娃");
        list.add("狗剩");
        list.add("鐵蛋");
        
        /*list.add(1, "本山");*/
        List list2=new ArrayList();
        list2.add("本山");
        list2.add("沈陽");
        list.addAll(2, list2);
        System.out.println("集合的元素:"+list);
    }

}

結果：
集合的元素:[狗娃, 狗剩, 本山, 沈陽, 鐵蛋]

獲取：

get(int index) 　　　　根據索引值獲取集合中的元素
indexOf(Object o) 　　　　找出指定元素第一次出現在集合中的索引值
lastIndexOf(Object o) 　　　　找指定的元素最後一次出現在集合中的索引值
subList(int fromIndex, int toIndex) 　　　　指定開始與結束的索引值截取集合中的元素

public class Demo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        list.add("狗娃");
        list.add("狗剩");
        list.add("鐵蛋");
        list.add("狗娃");
        /*list.add(1, "本山");
        List list2=new ArrayList();
        list2.add("本山");
        list2.add("沈陽");
        list.addAll(2, list2);*/
        System.out.println("找出指定元素在集合中的索引值:"+list.indexOf("狗剩"));
        System.out.println("找到本山:"+list.indexOf("本山"));
        System.out.println("最後一次:"+list.lastIndexOf("狗娃"));
        System.out.println("get方法獲取元素:"+list.get(1));
        List subList=list.subList(1, 4);
        System.out.println("子集合的元素是:"+subList);
        System.out.println("集合的元素:"+list);
    }

}

結果：
找出指定元素在集合中的索引值:1
找到本山:-1
最後一次:3
get方法獲取元素:狗剩
子集合的元素是:[狗剩, 鐵蛋, 狗娃]
集合的元素:[狗娃, 狗剩, 鐵蛋, 狗娃]

修改：

set(int index, E element) 　　　　使用指定的元素替換指定索引值位置的元素

public class Demo2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        list.add("狗娃");
        list.add("狗剩");
        list.add("鐵蛋");
        list.add("狗娃");
        
        list.set(3, "本山");
        System.out.println("集合的元素:"+list);
    }

}

結果：
集合的元素:[狗娃, 狗剩, 鐵蛋, 本山]

List接口中特有的方法具備的特點：操作的方法都存在索引值

只有List接口下面的集合類才具備索引值，其他接口下面的集合類都沒有索引值

叠代：

listIterator() 　　　　返回List接口中特有的叠代器

hasPrevious() 　　　　判斷是否存在上一個元素
previous() 　　　　獲取上一個元素　　　　當前指針先向上移動一個單位，然後再取出當前指針指向的元素

next（）　　　　先取出當前指針指向的元素，然後指針向下移動一個單位
————————————————————

add(E e) 　　　　把當前元素插入到當前指針指向的位置上
set(E e) 　　　　替換叠代器最後一次返回的元素

public class Demo3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        list.add("狗娃");
        list.add("狗剩");
        list.add("鐵蛋");
        list.add("美美");
        
        ListIterator it=list.listIterator();
        /*System.out.println("有上一個元素嗎？"+it.hasPrevious());
        it.next();
        System.out.println("獲取上一個元素:"+it.previous());
        it.next();
        it.next();
        it.add("張三");*/
        it.next();
        it.next();
        it.set("張三");
        System.out.println("集合的元素:"+list);
    }

}

結果：
集合的元素:[狗娃, 張三, 鐵蛋, 美美]

使用三種遍歷方式遍歷集合中的元素：

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

public class Demo4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        list.add("張三");
        list.add("李四");
        list.add("王五");
        
        System.out.println("---------get方法遍歷----------");
        for (int i=0;i<list.size();i++) {
            System.out.print(list.get(i)+",");
        }
        
        System.out.println("\r\n---------使用叠代器正序遍歷---------");
        ListIterator it=list.listIterator();//獲取到叠代器
        while (it.hasNext()) {
            System.out.print(it.next()+",");
        }
        
        System.out.println("\r\n---------使用叠代器逆序遍歷---------");
        while (it.hasPrevious()) {
            System.out.print(it.previous()+",");
        }
    }

}

結果：
---------get方法遍歷----------
張三,李四,王五,
---------使用叠代器正序遍歷---------
張三,李四,王五,
---------使用叠代器逆序遍歷---------
王五,李四,張三,

叠代器在叠代元素的時候的時候要註意的事項：

在叠代器叠代元素的過程中，不允許使用集合對象改變集合中的元素個數，如果需要添加或者刪除只能使用叠代器的方法進行操作。

如果使用過了集合對象改變集合中的元素個數，那麽就會出現ConcurrentModificationException異常。

叠代器叠代元素的過程中：叠代器一旦創建到使用的時間。

List：有序，可重復

常用的：

----------------| ArrayList ArrayList底層是維護了一個Object數組實現的，特點：查詢速度快，增刪慢。

----------------| LinkedList

----------------| Vector（了解即可）

ArrayList特有的方法:
ensureCapacity(int minCapacity)　　指定容量

trimToSize()　　　　把數組中無用的刪除比如初始容量為10 只用了3個那麽就把剩下的7個刪除

筆試題目：使用ArrayList無參的構造函數創建一個對象時，默認的容量是多少？如果長度不夠使用時又自動增長多少？

ArrayList底層是維護了一個Object數組實現的，使用無參構造函數時，Object數組默認的容量是10，當長度不夠時，自動增長0.5倍

private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//左移一位就是除以2，所以就是+0.5
        if (newCapacity - minCapacity <= 0) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }

查詢速度快：因為維護的數組元素與元素之間的內存地址是連續的，所以就像一個線性表，只需要知道首元素地址，就可以很方便的找到後面的元素了

增加：創建一個新的數組將原數組復制進去

刪除：刪除待刪除元素然後把後面的全部向前移動一位

什麽時候使用ArrayList：如果目前的數據是查詢比較多增刪比較少的時候，就用ArrayList存儲這批數據比如：高校的圖書館

需求：編寫一個函數清除集合中的重復元素如果書號一樣就是重復的元素。要求：遍歷集合元素時必須使用叠代器

package cn.itcast.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
//需求：編寫一個函數清除集合中的重復元素 如果書號一樣就是重復的元素。要求：遍歷集合元素時必須使用叠代器
public class Demo7 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList list=new ArrayList();
        list.add(new Book(110,"Java編程思想"));
        list.add(new Book(220,"Java核心技術"));
        list.add(new Book(330,"深入JavaWeb"));
        list.add(new Book(110,"Java神書"));
        
        ArrayList list2=clearRepeat(list);
        System.out.println("新集合的元素是:"+list2);
    }
    
    public static ArrayList clearRepeat(ArrayList list) {
        ArrayList newList =new ArrayList();//創建一個新的集合
        //獲取叠代器
        Iterator it=list.iterator();
        while (it.hasNext()) {
            Book book=(Book)it.next();//從舊集合中獲取的元素
            if (!newList.contains(book)) {
                //如果新集合沒有包含該書籍，那麽就存儲到新集合中
                newList.add(book);
            }
        }
        return newList;
    }
}
class Book{
    int id;
    String name;
    public Book(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "{書號:"+this.id+" 書名:"+this.name+" }";
    }
    
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        Book book=(Book)obj;
        return this.id==book.id;
    }
}

結果：
新集合的元素是:[{書號:110 書名:Java編程思想 }, {書號:220 書名:Java核心技術 }, {書號:330 書名:深入JavaWeb }]

LinkedList：LinkedList底層是使用了鏈表數據結構實現的特點：查詢速度慢，增刪快

LinkedList特有的方法：

LinkedList特有的方法:
1：方法介紹
addFirst(E e) 把元素加到集合的首位置上
addLast(E e) 把元素添加到集合的末尾處
getFirst() 獲取集合中首位置的元素
getLast() 獲取集合中末尾處的元素
removeFirst() 刪除集合中的首位置元素並返回
removeLast() 刪除集合中的末尾元素並返回
如果集合中沒有元素，獲取或者刪除元素拋：NoSuchElementException
2：數據結構
1：棧（1.6）：主要用於實現堆棧數據結構的存儲方式
先進後出
push()
pop()
2：隊列（雙端隊列1.5）：主要是為了讓我們可以使用LinkedList模擬隊列數據結構的存儲方式
先進先出
offer()
poll()
3：返回逆序的叠代器對象
descendingIterator() 返回逆序的叠代器對象

import java.util.LinkedList;

public class Demo8 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkedList list=new LinkedList();
        list.add("張三");
        list.add("李四");
        list.add("王五");
        list.addFirst("狗娃");
        list.addLast("狗剩");
        System.out.println("獲取集合中首位置的元素:"+list.getFirst());
        System.out.println("獲取集合中末尾的元素:"+list.getLast());
        
        System.out.println("刪除集合中的首位置元素並返回:"+list.removeFirst());
        System.out.println("刪除集合中的末尾元素並返回:"+list.removeLast());
        System.out.println("集合中的元素:"+list);
        
    }

}

結果：
獲取集合中首位置的元素:狗娃
獲取集合中末尾的元素:狗剩
刪除集合中的首位置元素並返回:狗娃
刪除集合中的末尾元素並返回:狗剩
集合中的元素:[張三, 李四, 王五]

需求：使用LinkedList實現堆棧數據結構的存儲方式與隊列的數據結構存儲方式

package cn.itcast.list;

import java.util.LinkedList;

/*
     1：棧 （1.6）:主要用於實現堆棧數據結構的存儲方式
    先進後出
    push() 
    pop()
    2：隊列（雙端隊列1.5）：主要是為了讓我們可以使用LinkedList模擬隊列數據結構的存儲方式
    先進先出
    offer()
    poll()
需求：使用LinkedList實現堆棧數據結構的存儲方式與隊列的數據結構存儲方式
*/
public class Demo9 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StackList list=new StackList();
        list.add("馬雲");
        list.add("校長");
        list.add("思聰");
        //System.out.println(list.pop());
        int size=list.size();
        for (int i=0;i<size;i++) {
            System.out.println(list.pop());
        }
        System.out.println("----------------------");
        TeamList list2=new TeamList();
        list2.add("馬雲");
        list2.add("校長");
        list2.add("思聰");
        //System.out.println(list.pop());
        int size2=list2.size();
        for (int i=0;i<size2;i++) {
            System.out.println(list2.remove());
        }
    }

}
//使用LinkedList模擬堆棧的數據結構存儲方式
class StackList{
    LinkedList list;
    public StackList() {
        list=new LinkedList();
    }
    //進棧
    public void add(Object o) {
        list.push(o);
    }
    //出棧
    public Object pop() {
        return list.pop();
    }
    //獲取元素個數
    public int size() {
        return list.size();
    }
}
//使用LinkedList模擬隊列的存儲方式
class TeamList{
    LinkedList list;
    public TeamList() {
        list=new LinkedList();
    }
    public void add(Object o) {
        list.offer(o);
    }
    public Object remove() {
        return list.poll();
    }
    //獲取元素個數
        public int size() {
            return list.size();
        }
}

結果：
思聰
校長
馬雲
----------------------
馬雲
校長
思聰

Java學習筆記（15）

構造函數上一個 scan 否則筆記 poll() pre 最後一個元素 reg iterator方法叠代器的作用：就是用於抓取集合中的元素註：叠代器返回的一個接口類型的實現類，是一種多態的用法，而不是接口在調用方法 public class Demo2 {

Java學習筆記（15）

Java學習筆記（15）

java/android 設計模式學習筆記（15）---責任鏈模式

java學習筆記（15-高階api）

JAVA學習筆記（1）——a++與++a的區別

JAVA學習筆記（三）

java學習筆記（二）圖形用戶接口

Java學習筆記（二）-------String，StringBuffer，StringBuilder區別以及映射到的同步，異步相關知識

java學習筆記（四）：import語法

java學習筆記（六）：變量類型

java學習筆記（八）：繼承

java學習筆記（九）：Java 流(Stream)、文件(File)和IO

PCIe學習筆記（15）--- TLP的ROUTING方式

Java學習筆記（一）

Java學習筆記（二）---java 修飾符

Linux第一周學習筆記（15）

JAVA學習筆記——（一）

java 學習筆記（四） java連接ZooKeeper

抽象代數學習筆記（15）環

Java學習筆記（三）：面向對象

.net轉java 學習筆記（二）

Java學習筆記（15）

相關推薦