泛型:
陣列就是一種容器,可以在其中放置物件或基本型別資料.
陣列的優勢：是一種簡單的線性序列,可以快速地存取陣列元素,效率高.如果從效率和型別檢查的角度講,
陣列是最好的.
陣列的劣勢：不靈活.容量需要事先定義好,不能隨著需求的變化而擴容.
以下是容器的介面層次結構圖:
-----------------------------------------
Collection Map
^ ^
/ \ |
/ \ HashMap
/ \
Set List
/ |
/ / \
HashSet / \
ArrayList LinkedList
-----------------------------------------
泛型是JDK1.5以後增加的,它可以幫助我們建立型別安全的集合.在使用了泛型的集合中,遍歷時不必進行強制型別轉換.
JDK提供了支援泛型的編譯器,將執行時的型別檢查提前到了編譯時執行,提高了程式碼可讀性和安全性.
泛型的本質就是「資料型別的引數化」. 我們可以把「泛型」理解為資料型別的一個預留位置(形式引數),即告訴編譯器,
在呼叫泛型時必須傳入實際型別.
-----------------------------------------
自定義泛型:
我們可以在類的宣告處增加泛型列表,如：<T,E,V>.
此處,字元可以是任何識別符號,一般採用這3個字母.
----------------------------------------
public class TestGeneric {
public static void main(String[] args) {
MyCollection<String> mm = new MyCollection<String>();
mm.set("字串", 0);
String str = mm.get(0);
}
}
class MyCollection<E>{
Object[] obj = new Object[6];
public void set(E e,int index) {
obj[index] = e;
}
public E get(int index) {
return (E)obj[index];
}
}
----------------------------------------
容器中使用泛型:
容器相關類都定義了泛型,我們在開發和工作中,在使用容器類時都要使用泛型.這樣,在容器的儲存資料、
讀取資料時都避免了大量的型別判斷,非常便捷.
----------------------------------
public class Test {
public static void main(String[] args) {
// 以下程式碼中List、Set、Map、Iterator都是與容器相關的介面;
List<String> list = new ArrayList<String>();
Set<Man> mans = new HashSet<Man>();
Map<Integer, Man> maps = new HashMap<Integer, Man>();
Iterator<Man> iterator = mans.iterator();
}
}
-----------------------------------
Collection、List、Set、Map、Iterator介面都定義了泛型.
Collection介面:
Collection 表示一組物件.Collection介面的兩個子介面是List、Set介面.
-----------------------------------
方法 說明
boolean add(Object element) 增加元素到容器中
boolean remove(Object element) 從容器中移除元素
boolean contains(Object element) 容器中是否包含該元素
int size() 容器中元素的數量
boolean isEmpty() 容器是否為空
void clear() 清空容器中所有元素
Iterator iterator() 獲得迭代器,用於遍歷所有元素
boolean containsAll(Collection c) 本容器是否包含c容器中的所有元素
boolean addAll(Collection c) 將容器c中所有元素增加到本容器
boolean removeAll(Collection c) 移除本容器和容器c中都包含的元素
boolean retainAll(Collection c) 取本容器和容器c中都包含的元素,移除非交集元素.
Object[] toArray() 轉化成Object陣列
-----------------------------------
由於List、Set是Collection的子介面,意味著所有List、Set的實現類都有上面的方法.
List特點和常用方法:
List是有序、可重複的容器.
有序：List中每個元素都有索引標記.可以根據元素的索引標記(在List中的位置)存取元素,從而精確控制這些元素.
可重複：List允許加入重複的元素.更確切地講,List通常允許滿足 e1.equals(e2) 的元素重複加入容器.
除了Collection介面中的方法,List多了一些跟順序(索引)有關的方法:
-----------------------------------
方法 說明
void add(int index,Object element) 在指定位置插入元素,以前元素全部後移一位
Object set(int index,Object element) 修改指定位置的元素
Object get(int index) 返回指定位置的元素
Object remove(intindex) 刪除指定位置的元素,後面元素全部前移一位
int indexOf(Object o) 返回第一個匹配元素的索引,如果沒有該元素,返回-1.
int lastIndexOf(Object o) 返回最後一個匹配元素的索引,如果沒有該元素,返回-1.
-----------------------------------
List介面常用的實現類有3個：ArrayList、LinkedList和Vector.
-----------------------------------
例:
import java.util.ArrayList;
import java.util.Collection;
public class TestList {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
System.out.println(c.size());
System.out.println(c.isEmpty()); // 判斷容器中是否為空
// 向容器中新增元素
c.add("dog");
c.add("cat");
System.out.println(c.contains("dog")); // 判斷容器中是否包含此元素
System.out.println(c);
System.out.println(c.size()); // 容器中元素的個數
Object[] obj = c.toArray(); // 將容器轉換成物件陣列
System.out.println(obj);
c.remove("cat"); // 從容器中移除某元素
System.out.println(c);
c.clear(); // 移除容器中的所有元素
System.out.println(c);
}
}
-----------------------------------
兩個List之間的元素操作:
import java.util.*;
public class TestList02 {
public static void main(String[] args) {
List<String> c1 = new ArrayList<>();
c1.add("aaa");
c1.add("bbb");
c1.add("ccc");
List<String> c2 = new ArrayList<>();
c2.add("bbb");
c2.add("ddd");
c2.add("eee");
System.out.println("List01:"+c1);
System.out.println("List02:"+c2);
c1.addAll(c2); // 將c2中所有元素都加入到c1中
boolean b = c1.containsAll(c2); // 判斷c1中是否包含c2的所有元素
c1.removeAll(c2); // 將c2中在c1中出現的所有元素都刪除(刪除交集元素)
c1.retainAll(c2); // 取交集
System.out.println("List01:"+c1);
System.out.print(b);
}
}
List中操作索引的常用方法:
import java.util.*;
public class Test03 {
public static void main(String[] args) {
List<String> c = new ArrayList<>();
c.add("A");
c.add("B");
c.add("C");
c.add("D");
System.out.println(c);
c.add(1, "X"); // 在指定位置插入元素
System.out.println(c);
c.remove(2); // 刪除指定位置的元素
System.out.println(c);
c.set(2,"MMM"); // 將指定位置設定為指定元素
System.out.println(c);
System.out.println(c.get(1)); // 獲取指定索引位置的元素
c.add("D");
c.add("C");
c.add("B");
c.add("A");
System.out.println(c);
System.out.println(c.indexOf("D")); // 獲取元素第一次出現的位置索引,沒有則返回-1
System.out.println(c.lastIndexOf("A")); // 獲取元素最後一次出現的位置索引
}
}
手動實現容器ArrayList:
ArrayList底層是用陣列實現的儲存. 特點：查詢效率高,增刪效率低,執行緒不安全.我們一般使用它.
--------------------------------
public class MyCollection<E> {
private Object[] elementData;
private int size;
private static final int DEFAULT_CAPACITY = 10;
public MyCollection() {
elementData = new Object[DEFAULT_CAPACITY];
}
public int size() {
return size;
}
public boolean isEmpty() {
if(size==0) {
return true;
}
return false;
}
public MyCollection(int capacity) {
if(capacity < 0) {
throw new RuntimeException("索引不能為負數");
}else if(capacity == 0){
elementData = new Object[DEFAULT_CAPACITY];
}
elementData = new Object[capacity];
}
// 新增元素
public void add(E element) {
if(size==elementData.length) {
// 對容器擴容
Object[] newArray = new Object[elementData.length+(elementData.length >> 1)];
System.arraycopy(elementData, 0, newArray, 0, elementData.length);
this.elementData = newArray;
}
elementData[size++] = element;
}
// 重寫toString方法,列印所有元素
@Override
public String toString() {
StringBuilder str = new StringBuilder();
str.append("[");
for(int i=0;i<size;i++) {
str.append(elementData[i]+", ");
}
str.setCharAt(str.length()-2, ']');
str.delete(str.length()-1, str.length());
return str.toString();
}
// 獲取指定位置元素
public E get(int index) {
checkRange(index);
return (E)elementData[index];
}
// 設定指定位置的元素
public void set(int index, E element) {
checkRange(index);
elementData[index] = element;
}
// 檢查是否越界
public void checkRange(int index) {
if(index<0||index>size-1) {
throw new RuntimeException("索引錯誤");
}
}
// 刪除指定元素
public void remove(E element) {
for(int i=0;i<size;i++) {
if(elementData[i].equals(element)) {
remove(i);
}
}
}
public void remove(int index) {
checkRange(index);
if(index!=size-1) {
// 移動的長度
int moveLen = size-index-1;
System.arraycopy(elementData, index+1, elementData, index, moveLen);
}
elementData[--size] = null; // 最後位置的索引為size-1,所以應該先減一
}
public static void main(String[] args) {
MyCollection<String> arr = new MyCollection<>(20);
for(int i=0;i<50;i++) {
arr.add("dog:"+i);
}
System.out.println(arr);
arr.set(10, "cat");
String s = arr.get(10);
System.out.println(s);
System.out.println(arr);
arr.remove(3);
System.out.println(arr);
arr.remove("dog:8");
System.out.println(arr);
System.out.println(arr.size());
System.out.println(arr.isEmpty());
}
}
手動實現容器LinkedList:
LinkedList底層用雙向連結串列實現的儲存.特點：查詢效率低,增刪效率高,執行緒不安全.
雙向連結串列也叫雙連結串列,是連結串列的一種,它的每個資料節點中都有兩個指標,分別指向前一個節點和後一個節點.
所以,從雙向連結串列中的任意一個節點開始,都可以很方便地找到所有節點.
------------------------------------
public class Node {
Node previous;
Node next;
Object element;
public Node(Node previous, Node next, Object element) {
super();
this.previous = previous;
this.next = next;
this.element = element;
}
public Node(Object element) {
super();
this.element = element;
}
}
------------------------------------
public class LinkedList<E>{
private Node first;
private Node last;
private static int size;
// 在指定位置插入元素
public void add(int index,E element) {
Node temp = getNode(index);
Node newNode = new Node(element);
if(temp!=null) {
Node up = temp.previous;
Node down = temp.next;
if(up!=null) {
up.next = newNode;
newNode.previous = up;
}else {
first = newNode;
}
newNode.next = temp;
temp.previous = newNode;
}
size++;
}
// 刪除指定位置元素
public void remove(int index) {
Node temp = getNode(index);
Node down;
Node up;
if(temp!=null) {
down = temp.next;
up = temp.previous;
if(up!=null) {
up.next = down;
}else {
first = down;
}
if(down!=null) {
down.previous = up;
}else {
last=up;
}
}
size--;
}
// 獲取指定位置節點元素的值
public E get(int index) {
Node temp = getNode(index);
return temp!=null ? (E)temp.element:null;
}
private void checkRange(int index) {
if(index<0||index>size-1) {
throw new RuntimeException("索引數位不合法:"+index);
}
}
// 獲取指定索引位置節點
private Node getNode(int index) {
checkRange(index);
Node temp = null;
if(index<(size>>1)) {
temp = first;
for(int i=0;i<index;i++) {
temp = temp.next;
}
}else {
temp = last;
for(int i=size-1;i>index;i--) {
temp = temp.previous;
}
}
return temp;
}
@Override
public String toString() {
StringBuilder str = new StringBuilder("[");
Node temp = first;
while(temp!=null) {
str.append(temp.element+", ");
temp = temp.next;
}
str.setCharAt(str.length()-2, ']');
str.delete(str.length()-1, str.length());
System.out.println(str);
return "";
}
// 增加節點
public void add(E element) {
Node node = new Node(element);
if(first==null) {
first = node;
last = node;
}else {
node.previous = last;
node.next = null;
last.next = node;
last = node;
}
size++;
}
public static int size() {
return size;
}
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("a");
list.add("b");
list.add("c");
list.toString();
System.out.println(list.get(2));
list.remove(5);
list.toString();
list.add(0, "123");
list.toString();
list.add(2,"222");
list.toString();
list.add(list.size()-1,"00");
list.toString();
}
}
Vector向量:
Vector底層是用陣列實現的List,相關的方法都加了同步檢查,因此「執行緒安全,效率低」.很多方法增加了synchronized同步標記.
1. 涉及執行緒安全時,用Vector.
2. 不存線上程安全問題時,並且查詢較多用ArrayList.
3. 不存線上程安全問題時,增加或刪除元素較多用LinkedList.
Map介面:
Map就是用來儲存「鍵(key)-值(value) 對」的. Map類中儲存的「鍵值對」通過鍵來標識,所以「鍵物件」不能重複.
Map 介面的實現類有HashMap、TreeMap、HashTable、Properties等.
---------------------------------------
Map介面中常用的方法
方法 說明
Object put(Object key, Object value) 存放鍵值對
Object get(Object key) 通過鍵物件查詢得到值物件
Object remove(Object key) 刪除鍵物件對應的鍵值對
boolean containsKey(Object key) Map容器中是否包含鍵物件對應的鍵值對
boolean containsValue(Object value) Map容器中是否包含值物件對應的鍵值對
int size() 包含鍵值對的數量
boolean isEmpty() Map是否為空
void putAll(Map t) 將的所有鍵值對存放到本map物件
void clear() 清空本map物件所有鍵值對
---------------------------------------
HashMap和HashTable:
HashMap採用雜湊演演算法實現,是Map介面最常用的實現類. 由於底層採用了雜湊表儲存資料,我們要求鍵不能重複,
如果發生重複,新的鍵值對會替換舊的鍵值對. HashMap在查詢、刪除、修改方面都有非常高的效率.
HashTable類和HashMap用法幾乎一樣,底層實現幾乎一樣,只不過HashTable的方法新增了synchronized關鍵字確保執行緒同步檢查,效率較低.
HashMap與HashTable的區別:
1. HashMap: 執行緒不安全,效率高.允許key或value為null.
2. HashTable: 執行緒安全,效率低.不允許key或value為null.
---------------------------------------
例一:
import java.util.HashMap;
import java.util.Map;
public class TestMap {
public static void main(String[] args) {
Map<Integer,String> m1 = new HashMap<>();
m1.put(1, "a");
m1.put(2, "b");
m1.put(3, "c");
System.out.println(m1.get(1));
System.out.println(m1.size());
System.out.println(m1.isEmpty());
System.out.println(m1.containsKey(2));
System.out.println(m1.containsValue("c"));
Map<Integer,String> m2 = new HashMap<>();
m2.put(4, "++");
m2.put(5, "**");
m1.putAll(m2);
System.out.println(m1);
// 重複鍵時(根據equals方法判斷),前面鍵對應的值會被覆蓋
m1.put(3, "三");
System.out.println(m1);
}
}
---------------------------------------
例二:
import java.util.HashMap;
import java.util.Map;
public class TestMap2 {
public static void main(String[] args) {
Map<Integer,Employee> em1 = new HashMap<>();
Employee e1 = new Employee(10001, "張一", 3211.11);
Employee e2 = new Employee(10002, "張二", 123);
Employee e3 = new Employee(10003, "張三", 2367.64);
Employee e4 = new Employee(10001, "張四", 1022);
em1.put(10001, e1);
em1.put(10002, e2);
em1.put(10002, e2);
em1.get(10001).toString();
em1.put(10001, e4);
em1.get(10001).toString();
}
}
class Employee{
private int id;
private String ename;
private double salary;
public Employee(int id, String ename, double salary) {
super();
this.id = id;
this.ename = ename;
this.salary = salary;
}
@Override
public String toString() {
System.out.println("id:" + id + " name:"+ename);
return super.toString();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
---------------------------------------
手動實現HashMap基礎功能:
---------------------------------------
public class Node2<K,V>{
int hash;
K key;
V value;
Node2 next;
}
---------------------------------------
public class TestHashMap<K,V> {
Node2[] table; // 位桶陣列,bucket array
int size; // 存放的鍵值對的個數
public TestHashMap() {
table = new Node2[16]; // 長度一般定義成2的整數冪
}
public void put(K key, V value) {
// 定義新的節點
Node2 newNode = new Node2();
newNode.hash = myHash(key.hashCode(),table.length);
newNode.key = key;
newNode.value = value;
newNode.next = null;
// 取出hash值對應的那個陣列位置的初節點
Node2 temp = table[newNode.hash];
Node2 iterLast = null; // 正在遍歷的最後一個元素
boolean keyRepeat = false;
if(temp==null) {
// 此處陣列元素為空,直接將新節點放進去
table[newNode.hash] = newNode;
size++;
}else {
// 此處陣列不為空,遍歷對應的連結串列
while(temp!=null) {
// 判斷key如果重複,則覆蓋
if(temp.key.equals(key)) {
keyRepeat = true;
temp.value = value; // 更新鍵對應的值
break;
}else {
// key不重複,則遍歷下一個
iterLast = temp;
temp = temp.next;
}
}
if(!keyRepeat) {
// 如果沒有發生key重複的情況,則新增到連結串列最後
iterLast.next = newNode;
size++;
}
}
}
public V get(K key) {
int hash = myHash(key.hashCode(),table.length);
V value = null;
if(table[hash]!=null) {
Node2 temp = table[hash];
while(temp!=null) {
if(temp.key.equals(key)) {
value = (V)temp.value;
break;
}else {
temp = temp.next;
}
}
}
return value;
}
public int myHash(int v,int length) {
// System.out.println("hash in myHash:"+(v&(length-1))); // 直接位運算,效率高
// System.out.println("hash in myHash:"+(v%(length-1))); // 取模運算,效率低
return v&(length-1);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("{");
// 遍歷bucket陣列
for(int i=0;i<table.length;i++) {
Node2 temp = table[i];
// 遍歷連結串列
while(temp!=null) {
sb.append(temp.key+":"+temp.value+", ");
temp = temp.next;
}
}
sb.setCharAt(sb.length()-2, '}');
sb.deleteCharAt(sb.length()-1);
System.out.println(sb);
return super.toString();
}
public static void main(String[] args) {
TestHashMap<Integer,String> m = new TestHashMap<>();
m.put(10, "aa");
m.put(20, "bb");
m.put(30, "cc");
m.put(20, "adawd");
m.put(53, "ee");
m.put(69, "tt");
m.put(85, "oo");
System.out.println(m);
System.out.println(m.get(30));
}
}
---------------------------------------
TreeMap的使用和Comparable介面的使用:
TreeMap是紅黑二元樹的典型實現.我們開啟TreeMap的原始碼,發現裡面有一行核心程式碼：
private transient Entry<K,V> root = null;
Entry(是TreeMap的內部類)裡面儲存了本身資料、左節點、右節點、父節點、以及節點顏色. TreeMap的put()/remove()方法大量使用了紅黑樹的理論.
TreeMap和HashMap實現了同樣的介面Map,因此,用法對於呼叫者來說沒有區別.HashMap效率高於TreeMap;在需要排序的Map時才選用TreeMap.
---------------------------------------
import java.util.Map;
import java.util.TreeMap;
public class TestTreeMap {
public static void main(String[] args) {
Map<Integer,String> treemap1 = new TreeMap<>();
treemap1.put(450, "aa");
treemap1.put(55, "aa");
treemap1.put(99, "aa");
// 按照key遞增的方式排序
for(Integer key:treemap1.keySet()) {
System.out.println(key+"---"+treemap1.get(key));
}
Map<Emp,String> treemap2 = new TreeMap<>();
treemap2.put(new Emp(10001,"xiaowang", 9000), "salary many");
treemap2.put(new Emp(10002,"xiaoli", 4000), "salary low");
treemap2.put(new Emp(10003,"xiaozhang", 9000), "salary many");
for(Emp temp:treemap2.keySet()) {
System.out.println(temp+"---"+treemap2.get(temp));
}
}
}
class Emp implements Comparable<Emp>{
int id;
String name;
double salary;
public Emp(int id, String name, double salary) {
super();
this.id = id;
this.name = name;
this.salary = salary;
}
@Override
public int compareTo(Emp o) {
if(this.salary>o.salary) {
return 1;
}else if(this.salary<o.salary) {
return -1;
}else {
if(this.id>o.id) {
return 1;
}else if(this.id<this.id) {
return -1;
}
return 0;
}
}
@Override
public String toString() {
System.out.print("id:"+id+" salary:"+salary+" name:"+name);
return "";
}
}
---------------------------------------
Set介面:
Set介面繼承自Collection,Set介面中沒有新增方法,方法和Collection保持完全一致.我們在前面通過List學習的方法,在Set中仍然適用.
Set容器特點：無序、不可重複.無序指Set中的元素沒有索引,我們只能遍歷查詢;不可重複指不允許加入重複的元素.更確切地講,
新元素如果和Set中某個元素通過equals()方法對比為true,則不能加入;甚至,Set中也只能放入一個null元素,不能多個.
Set常用的實現類有：HashSet、TreeSet等,我們一般使用HashSet.
HashSet的使用:
---------------------------------------
HashSet是採用雜湊演演算法實現,底層實際是用HashMap實現的(HashSet本質就是一個簡化版的HashMap),
因此,查詢效率和增刪效率都比較高.
--------------------------------------
import java.util.HashSet;
import java.util.Set;
public class TestHashSet {
public static void main(String[] args) {
Set<String> set1 = new HashSet<>();
set1.add("aaa");
set1.add("bbb");
set1.add("aaa"); // 相同的元素不會被加入
System.out.println(set1);
set1.remove("bbb");
System.out.println(set1);
Set<String> set2 = new HashSet<>();
set2.add("xiaozhang");
set2.addAll(set1);
System.out.println(set2);
}
}
-------------------------------------
TreeSet的使用:
TreeSet底層實際是用TreeMap實現的,內部維持了一個簡化版的TreeMap,通過key來儲存Set的元素.
TreeSet內部需要對儲存的元素進行排序,因此,我們對應的類需要實現Comparable介面.這樣,
才能根據compareTo()方法比較物件之間的大小,才能進行內部排序.
-------------------------------------
public class Test {
public static void main(String[] args) {
User u1 = new User(1001, "xiaowang", 18);
User u2 = new User(2001, "xiaoli", 5);
Set<User> set = new TreeSet<User>();
set.add(u1);
set.add(u2);
}
}
class User implements Comparable<User> {
int id;
String uname;
int age;
public User(int id, String uname, int age) {
this.id = id;
this.uname = uname;
this.age = age;
}
// 返回0 表示 this == obj 返回正數表示 this > obj 返回負數表示 this < obj
@Override
public int compareTo(User o) {
if (this.id > o.id) {
return 1;
} else if (this.id < o.id) {
return -1;
} else{
return 0;
}
}
}
-------------------------------------
使用TreeSet要點：
(1) 由於是二元樹,需要對元素做內部排序. 如果要放入TreeSet中的類沒有實現Comparable介面,則會丟擲異常：java.lang.ClassCastException.
(2) TreeSet中不能放入null元素.
使用Iterator迭代器遍歷容器元素(List/Set/Map):
迭代器為我們提供了統一的遍歷容器的方式:
------------------------------------
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class TestInterator {
public static void main(String[] args) {
testIteratorList();
testIteratorSet();
testIteratorMap();
}
public static void testIteratorMap() {
Map<Integer,String> map1 = new HashMap<>();
map1.put(10, "aa");
map1.put(20, "bb");
map1.put(30, "cc");
// 第一種遍歷Map的方式
Set<Entry<Integer,String>> ss = map1.entrySet();
for(Iterator<Entry<Integer,String>> iter = ss.iterator();iter.hasNext();) {
Entry<Integer,String> temp = iter.next();
System.out.println(temp.getKey()+"--"+temp.getValue());
}
// 第二種遍歷Map的方式
Set<Integer> keySet = map1.keySet();
for(Iterator<Integer> iter=keySet.iterator();iter.hasNext();) {
Integer key = iter.next();
System.out.println(key+"----"+map1.get(key));
}
}
public static void testIteratorList() {
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// 使用Iterator遍歷List
for(Iterator<String> iter=list.iterator();iter.hasNext();) {
String temp = iter.next();
System.out.println(temp);
}
}
public static void testIteratorSet() {
Set<String> set = new HashSet<>();
set.add("aaa");
set.add("bbb");
set.add("ccc");
// 使用Iterator遍歷Set
for(Iterator<String> iter=set.iterator();iter.hasNext();) {
String temp = iter.next();
System.out.println(temp);
}
}
}
------------------------------------
iter.remove()在容器中刪除此時迭代器所指向的元素
遍歷集合的方法總結:
-----------------------------------
for(int i=0;i<list.size();i++){ // list為集合的物件名
String temp = (String)list.get(i);
System.out.println(temp);
}
for(String temp : list) {
System.out.println(temp);
}
for(Iterator iter= list.iterator();iter.hasNext();){
String temp = (String)iter.next();
System.out.println(temp);
}
Iterator iter =list.iterator();
while(iter.hasNext()){
Object obj = iter.next();
iter.remove(); // 如果要遍歷時,刪除集合中的元素,建議使用這種方式！
System.out.println(obj);
}
--------------------------------
for(String temp:set){
System.out.println(temp);
}
for(Iterator iter = set.iterator();iter.hasNext();){
String temp = (String)iter.next();
System.out.println(temp);
}
--------------------------------
Map<Integer, Man> maps = new HashMap<Integer, Man>();
Set<Integer> keySet = maps.keySet();
for(Integer id : keySet){
System.out.println(maps.get(id).name);
}
Set<Entry<Integer, Man>> ss = maps.entrySet();
for (Iterator iterator = ss.iterator(); iterator.hasNext();) {
Entry e = (Entry) iterator.next();
System.out.println(e.getKey()+"--"+e.getValue());
}
--------------------------------
Collections工具類:
類 java.util.Collections 提供了對Set、List、Map進行排序、填充、查詢元素的輔助方法.
1. void sort(List) // 對List容器內的元素排序,排序的規則是按照升序進行排序.
2. void shuffle(List) // 對List容器內的元素進行隨機排列.
3. void reverse(List) // 對List容器內的元素進行逆續排列 .
4. void fill(List, Object) // 用一個特定的物件重寫整個List容器.
5. int binarySearch(List, Object) // 對於順序的List容器,採用折半查詢的方法查詢特定物件.
Collections工具類的常用方法:
public class Test {
public static void main(String[] args) {
List<String> aList = new ArrayList<String>();
for (int i = 0; i < 5; i++){
aList.add("a" + i);
}
System.out.println(aList);
Collections.shuffle(aList); // 隨機排列
System.out.println(aList);
Collections.reverse(aList); // 逆續
System.out.println(aList);
Collections.sort(aList); // 排序
System.out.println(aList);
System.out.println(Collections.binarySearch(aList, "a2"));
Collections.fill(aList, "hello");
System.out.println(aList);
}
}
表格資料儲存(map和list結合):
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class TestStoreData {
public static void main(String[] args) {
Map<String,Object> row1 = new HashMap<>();
row1.put("id", 1001);
row1.put("姓名", "張三");
row1.put("薪水", 20000);
row1.put("入職日期", "2020.8.5");
Map<String,Object> row2 = new HashMap<>();
row2.put("id", 1002);
row2.put("姓名", "李四");
row2.put("薪水", 21332);
row2.put("入職日期", "2051.5.7");
Map<String,Object> row3 = new HashMap<>();
row3.put("id", 1003);
row3.put("姓名", "王五");
row3.put("薪水", 123123);
row3.put("入職日期", "2023.9.8");
List<Map<String,Object>> table1 = new ArrayList<>();
table1.add(row1);
table1.add(row2);
table1.add(row3);
for(Map<String,Object> row : table1) {
Set<String> keySet = row.keySet();
for(String key:keySet) {
System.out.print(key+"--"+row.get(key)+"\t");
}
System.out.println();
}
}
}