day16(List集合&泛型)
###16.01_集合框架(去除ArrayList中重複字串元素方式)(掌握)
* A:案例演示
* 需求：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("b");
list.add("c");
list.add("c");
list.add("c");
list.add("c");
System.out.println(list);
ArrayList newList = getSingle(list);
System.out.println(newList);
}
/*
* 去除重複
* 1,返回ArrayList
* 2,引數列表ArrayList
*/
public static ArrayList getSingle(ArrayList list) {
ArrayList newList = new ArrayList(); //建立一個新集合
Iterator it = list.iterator(); //獲取迭代器
while(it.hasNext()) { //判斷老集合中是否有元素
String temp = (String)it.next(); //將每一個元素臨時記錄住
if(!newList.contains(temp)) { //如果新集合中不包含該元素
newList.add(temp); //將該元素新增到新集合中
}
}
return newList; //將新集合返回
}
###16.02_集合框架(去除ArrayList中重複自定義物件元素)(掌握)
* A:案例演示
* 需求：ArrayList去除集合中自定義物件元素的重複值(物件的成員變數值相同)
* B:注意事項
* 重寫equals()方法的
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));
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);
}
/*
* 建立新集合將重複元素去掉
* 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);
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
list.addFirst("d");
list.addLast("e");
//System.out.println(list.getFirst());
//System.out.println(list.getLast());
//System.out.println(list.removeFirst());
//System.out.println(list.removeLast());
System.out.println(list.get(1));
System.out.println(list);
}
###16.04_集合框架(棧和佇列資料結構)(掌握)
* 棧
* 先進後出
* 佇列
* 先進先出
###16.05_集合框架(用LinkedList模擬棧資料結構的集合並測試)(掌握)
* A:案例演示
* 需求：請用LinkedList模擬棧資料結構的集合，並測試
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();
}
}
public class 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());
}
}
}
* 建立一個類將Linked中的方法封裝
*
public class Stack {
private LinkedList list = new LinkedList(); //建立LinkedList物件
public void in(Object obj) {
list.addLast(obj); //封裝addLast()方法
}
public Object out() {
return list.removeLast(); //封裝removeLast()方法
}
public boolean isEmpty() {
return list.isEmpty(); //封裝isEmpty()方法
}
}
###16.06_集合框架(泛型概述和基本使用)(掌握)
* A:泛型概述
* B:泛型好處
* 提高安全性(將執行期的錯誤轉換到編譯期)
* 省去強轉的麻煩
* C:泛型基本使用
* <>中放的必須是引用資料型別
* D:泛型使用注意事項
* 前後的泛型必須一致,或者後面的泛型可以省略不寫(1.7的新特性菱形泛型)
###16.07_集合框架(ArrayList儲存字串和自定義物件並遍歷泛型版)(掌握)
* A:案例演示
* ArrayList儲存字串並遍歷泛型版
public static void main(String[] args) {
//demo1();
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(); //將集合中的每一個元素用Person記錄
System.out.println(p.getName() + "..." + p.getAge());
}
}
public static void demo1() {
ArrayList<String> list = new ArrayList<>(); //建立集合物件
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提供了泛型來解決這個安全問題。
public static void main(String[] args) {
//demo1();
Tool<String> t = new Tool<>();
//t.show("abc");
t.show(true);
}
public static void demo1() {
Tool<Student> t = new Tool<>(); //建立工具類物件
t.setObj(new Student("張三",23));
//Worker w = (Worker) t.getObj(); //向下轉型
//System.out.println(w);
}
###16.09_集合框架(泛型類的概述及使用)(瞭解)
* A:泛型類概述<T>
* 把泛型定義在類上
* B:定義格式
* public class 類名<泛型型別1,…>
* C:注意事項
* 泛型型別必須是引用型別
* D案例演示
* 泛型類的使用:
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,沒有意義
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());//next方法只能呼叫一次,如果呼叫多次會將指標向後移動多次
Person p = it.next();
System.out.println(p.getName() + "..." + p.getAge());
}
}
###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); //如果不一致,需要在方法上宣告該泛型
}
public static<W> void print(W w) { //靜態方法必須宣告自己的泛型
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及其父類
public static void main(String[] args) {
//List<?> list = new ArrayList<Integer>(); //當右邊的泛型是不確定時,左邊可以指定為?
ArrayList<Person> list1 = new ArrayList<>();
list1.add(new Person("張三", 23));
list1.add(new Person("李四", 24));
list1.add(new Person("王五", 25));
ArrayList<Student> list2 = new ArrayList<>();
list2.add(new Student("趙六", 26));
list2.add(new Student("周七", 27));
list1.addAll(list2);
System.out.println(list1);
}
###16.13_集合框架(增強for的概述和使用)(掌握)
* A:增強for概述
* 簡化陣列和Collection集合的遍歷
* B:格式：
for(元素資料型別 變數 : 陣列或者Collection集合) {
使用變數即可，該變數就是元素
}
* C:案例演示
* 陣列，集合儲存元素用增強for遍歷
* D:好處
* 簡化遍歷
增強for迴圈底層依賴的是迭代器(Iterator)
public static void main(String[] args) {
//demo1();
//demo2();
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
}
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");
list.add("d");
for (String string : list) {
System.out.println(string);
}
}
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);
}
}
###16.14_集合框架(ArrayList儲存字串和自定義物件並遍歷增強for版)(掌握)
* A:案例演示
* ArrayList儲存字串並遍歷增強for版
*
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for(String s : list) {
System.out.println(s);
}
###16.15_集合框架(三種迭代的能否刪除)(掌握)
* 普通for迴圈,可以刪除,但是索引要—
for(int i = 0; i < list.size(); i++) {
if("b".equals(list.get(i))) {
list.remove(i--); //通過索引刪除元素
}
}
* 迭代器,可以刪除,但是必須使用迭代器自身的remove方法,否則會出現併發修改異常
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();
}
}
* 增強for迴圈不能刪除，只能遍歷
for (String string : list) {
if("b".equals(string)) {
list.remove("b");
}
}
System.out.println(list);
}
###16.16_集合框架(靜態匯入的概述和使用)(瞭解)
* 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_集合框架(可變引數的概述和使用)(掌握)
* 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 main(String[] args) {
//demo1();
//demo2();
//集合轉陣列,加泛型的
ArrayList<String> list = new ArrayList<>();
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.println(string);
}
}
public static void demo2() {
//int[] arr = {11,22,33,44,55};
//List<int[]> list = Arrays.asList(arr); 基本資料型別的陣列轉換成集合,會將整個陣列當作一個物件轉換
//System.out.println(list);
Integer[] arr = {11,22,33,44,55}; //將陣列轉換成集合,陣列必須是引用資料型別
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); //將陣列轉換成集合
//list.add("d"); //不能新增
System.out.println(list);
}
###16.19_集合框架(集合巢狀之ArrayList巢狀ArrayList)(掌握)
* A:案例演示
* 集合巢狀之ArrayList巢狀ArrayList
案例:
* 我們學科,學科又分為若個班級
* 整個學科一個大集合
* 若干個班級分為每一個小集合
public static void main(String[] args) {
ArrayList<ArrayList<Person>> list = new ArrayList<>();
ArrayList<Person> first = new ArrayList<>(); //建立第一個班級
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));
//將班級新增到學科集合中
list.add(first);
list.add(second);
//遍歷學科集合
for(ArrayList<Person> a : list) {
for(Person p : a) {
System.out.println(p);
}
}
}