這是我自己學集合的時候一些總結
一、集合：瞭解使用集合的步驟
1.建立集合物件
2.建立元素物件
3.將元素物件新增到集合物件中
4.遍歷集合
(1)list集合程式碼如下：
public class test {
public static void main(String[] args) {
//1.建立集合物件
List list = new ArrayList();
//2.建立元素物件
student s1 = new student(1, "蘇少有");
student s2 = new student(2, "蘇少有2");
//3.將元素物件新增到集合物件中
list.add(s1);
list.add(s2);
System.out.println("list有"+list);
//獲取索引為1的元素
Object obj = list.get(1);
System.out.println("索引為1的是"+obj);
//獲取集合中的元素個數
System.out.println("集合長度為"+list.size());
//遍歷集合
for (int i = 0; i < list.size() ; i++) {
Object obj2 = list.get(i);
System.out.println("集合有"+obj2+"資料");
}
}
}
(2)增強for迴圈（for Each/迭代器）
*增強for迴圈
for(資料型別 變數名 :陣列或者集合物件) {
//迴圈體，變數以及元素
}
//增強for迴圈快捷鍵 iter+enter
增強for迴圈就是迭代器的簡寫模式。
*
* */
public class demo2 {
public static void main(String[] args) {
List list=new ArrayList();
list.add(10);
list.add(10);
list.add(20);
list.add(30);
list.add(40);
for(Object obj :list){
System.out.println(obj);
}
System.out.println("=========");
for (Object obj2 : list) {
Integer ii=(Integer)obj2;
System.out.println(ii);
}
}
}
(3)通過迭代器遍歷list集合
package demo3;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/*迭代器的常用方法
E.next(); 返回迭代器的下一個元素物件.再寫三層dao層查詢用到resultset 遍歷時while迴圈裡面有rs.next()
boolean hasNext(); 如果有元素可以迭代，則返回true
注意:列表迭代器是List體系中獨有的遍歷方式，可以在對集合遍歷的同時進行新增、刪除等操作。
但是必須通過呼叫列表迭代器的方法來實現。
迭代器的使用步驟:
1.根據集合物件獲取其物件的迭代器物件
2.判斷迭代器中是否有物件
3.如果有就獲取元素
總結:普通迭代器在遍歷集合的同時不能新增或刪除元素，否則會報:併發修改異常
列表迭代器在遍歷集合的同時可以新增刪除集合中的元素，但必須要用列表迭代器的方法
* */
public class test {
public static void main(String[] args) {
//需求:測試列表迭代器
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
//需求:判斷集合中如果有字串”b“,就在其後面新增一個新的字串：java
//1.根據集合物件獲取列表迭代器物件
ListIterator lit = list.listIterator();
//2.判斷迭代器中是否有物件
while (lit.hasNext()) {
//3.如果有就獲取元素
String s=(String)lit.next();
if ("b".equals(s)){
// list.add("java");這樣寫不行，必須呼叫列表迭代器的方法來實現
lit.add("java");
}
System.out.println(s);
}
System.out.println("========");
System.out.println(list);
}
}
(4)set集合
package demo6;
/* 單列集合(Collection)之Set集合
特點:無序，唯一
結論:Set集合保證所有的元素的唯一性依賴: equals()方法和hashCode()方法
*/
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class test {
public static void main(String[] args) {
//需求:往Set集合中新增五個學生物件，然後遍歷
Set<student> set =new HashSet<student>();
student s1=new student("蘇少有",21);
student s2=new student("蘇少有2",22);
student s3=new student("蘇少有3",23);
student s4=new student("蘇少有4",24);
student s5=new student("蘇少有",21);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
System.out.println(set);
System.out.println("-----------");
/*列印輸出語句時Set集合沒有“去重”？
因為Set集合保證元素的唯一性依賴:equals()和hashCode()兩個方法
你沒有在student類中重寫這兩個方法，預設呼叫的是Object類中的這兩個方法，
而Object類中的equals()方法預設比較的是地址值是否相同
解決方案:
在student類中重寫equals()和hashCode()方法
*/
//通過迭代器遍歷Set集合
//1.通過集合物件獲取物件的迭代器物件
Iterator<student> it = set.iterator();
//2.判斷迭代器中是否有元素
while (it.hasNext()){
//3.如果有就獲取元素
student s=it.next();
System.out.println(s);
}
System.out.println("--------");
//增強for迴圈
for (student stu : set) {
System.out.println(stu);
}
}
}
student實體類
package demo6;
import java.util.Objects;
public class student {
private String name;
private int age;
public student() {
}
public student(String name, int age) {
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 "student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
student student = (student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
(5)Map集合
package demo7;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/* Map集合的特點
特點：
雙列集合，元素由鍵值對(Entry)構成;
key(鍵)----value(值)
注意:
鍵(key)不可以重複，值(value)可以重複
應用:
Map<T1,T2> map = new HashMap<>();
解釋:
T1:表示鍵的資料型別
T2:表示值的資料型別
成員方法:
V put(K key,V value);新增元素(鍵值對的形式)
V get(Object key);根據鍵獲取對應的值
Set<k> keySet() 獲取所有鍵的集合；
遍歷Map集合步驟:
1.獲取所有鍵的集合 keySet()
2.遍歷所有的鍵，獲取到每一個鍵 迭代器 增強for
3.根據鍵，獲取指定值 get()
* */
public class test {
public static void main(String[] args) {
Map<Integer,student> map=new HashMap<Integer,student>();
student s1=new student("張三",21);
student s2=new student("李四",22);
student s3=new student("王五",23);
student s4=new student("張三",21);
map.put(1,s1);
map.put(2,s2);
map.put(3,s3);
map.put(4,s4);
//根據鍵獲取值
student stu1=map.get(2);
System.out.println(stu1);
//列印集合
System.out.println(map);
System.out.println("-----");
//遍歷集合
//1.獲取所有鍵的集合 keySet()
Set<Integer> keys = map.keySet();
//2.遍歷所有的鍵，獲取到每一個鍵 迭代器 增強for
Iterator<Integer> it = keys.iterator();
while(it.hasNext()){
//.根據鍵，獲取指定值 get()
Integer key = it.next();
student value = map.get(key);
System.out.println("key:"+key+"...value:"+value);
}
System.out.println("-------------");
//增強for
for (Integer key : keys) {
student value = map.get(key);
System.out.println("key:"+key+"....value:"+value);
}
}
}
二.泛型
/*泛型的好處
型別安全
避免了型別轉換
* */
public class test {
public static void main(String[] args) {
//需求:演示泛型
//1.建立集合物件
List<String> list2=new ArrayList<String>();
//2.建立元素物件
list2.add("a");
list2.add("b");
list2.add("c");
//3.將元素物件新增到集合物件中
for (String s : list2) {
System.out.println(s);
}
}
}
三.Collection類的使用
/* Collections:針對集合操作的工具類
成員方法:
max(Collection<T>) ;返回集合的最大元素
sort(List<T>); 根據元素的自然順序，將指定列表升序排列
reverse(List<T>); 反轉集合list裡的元素
shuffle(List<T>); 使用預設的隨機源隨機置換指定的列表
* */
public class test {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(2);
list.add(3);
list.add(5);
list.add(7);
list.add(4);
System.out.println("沒操作前，集合裡的元素有" + list);
System.out.println("----------");
//獲取集合最大元素
Integer max = Collections.max(list);
System.out.println("集合中的最大元素為"+max);
System.out.println("------------");
//對集合進行升序排列
Collections.sort(list);
System.out.println("s升序排列後集合為"+list);
Collections.reverse(list);
System.out.println("反轉後集合為"+list);
Collections.shuffle(list);
System.out.println("隨機集合元素為"+list);
}
}