JAVA語言基礎-面向對象（集合框架02List、泛型）
16.01_集合框架(去除ArrayList中重複字符串元素方式)(掌握)
-
A:案例演示java
- 需求：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; //將新集合返回 }
package com.heima.list;
import java.util.ArrayList;
import java.util.Iterator;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo1_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("c");
list.add("c");
list.add("c");
list.add("c");
ArrayList newList = getSingle(list);
System.out.println(newList);
}
/*
* 建立新集合將重複元素去掉
* 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.02_集合框架(去除ArrayList中重複自定義對象元素)(掌握)
- A:案例演示
- 需求：ArrayList去除集合中自定義對象元素的重複值(對象的成員變量值相同)
- B:注意事項
- 重寫equals()方法的
package com.heima.list;
import java.util.ArrayList;
import java.util.Iterator;
import com.heima.bean.Person;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo2_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);
package com.heima.list;
import java.util.LinkedList;
public class Demo3_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);
}
/*dcbae*/
}
16.04_集合框架(棧和隊列數據結構)(掌握)
- 棧
- 先進後出
- 隊列
- 先進先出
package com.heima.list;
import java.util.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();
}
}
16.05_集合框架(用LinkedList模擬棧數據結構的集合並測試)(掌握)
-
A:案例演示安全
- 需求：請用LinkedList模擬棧數據結構的集合，並測試
- 建立一個類將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()方法 } }
package com.heima.list;
import java.util.LinkedList;
public class Demo4_LinkedList {
/**
* 用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());
}
}
}
16.06_集合框架(泛型概述和基本使用)(掌握)
- A:泛型概述
- B:泛型好處
- 提升安全性(將運行期的錯誤轉換到編譯期)
- 省去強轉的麻煩
- C:泛型基本使用
- <>中放的必須是引用數據類型
- D:泛型使用注意事項
- 先後的泛型必須一致,或者後面的泛型能夠省略不寫(1.7的新特性菱形泛型)
package com.heima.generic;
import java.util.ArrayList;
import java.util.Iterator;
import com.heima.bean.Person;
public class Demo1_Generic {
/**
* A:泛型概述
* B:泛型好處
* 提升安全性(將運行期的錯誤轉換到編譯期)
* 省去強轉的麻煩
* C:泛型基本使用
* <>中放的必須是引用數據類型
* D:泛型使用注意事項
* 先後的泛型必須一致,或者後面的泛型能夠省略不寫(1.7的新特性菱形泛型)
*/
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.07_集合框架(ArrayList存儲字符串和自定義對象並遍歷泛型版)(掌握)
- A:案例演示
- ArrayList存儲字符串並遍歷泛型版
package com.heima.generic;
import java.util.ArrayList;
import java.util.Iterator;
import com.heima.bean.Person;
public class Demo2_Generic {
/**
* * 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提供了泛型來解決這個安全問題。
package com.heima.generic;
import com.heima.bean.Student;
import com.heima.bean.Tool;
import com.heima.bean.Worker;
public class Demo3_Generic {
/**
* 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:泛型類概述
- 把泛型定義在類上
- B:定義格式
- public class 類名<泛型類型1,…>
- C:注意事項
- 泛型類型必須是引用類型
- D:案例演示
- 泛型類的使用
16.10_集合框架(泛型方法的概述和使用)(瞭解)
- A:泛型方法概述
- 把泛型定義在方法上
- B:定義格式
- public <泛型類型> 返回類型 方法名(泛型類型 變量名)
- C:案例演示
- 泛型方法的使用
16.11_集合框架(泛型接口的概述和使用)(瞭解)
- A:泛型接口概述
- 把泛型定義在接口上
- B:定義格式
- public interface 接口名<泛型類型>
- C:案例演示
- 泛型接口的使用
package com.heima.generic;
public class Demo4_Generic {
/**
* * A:泛型接口概述
* 把泛型定義在接口上
* B:定義格式
* public interface 接口名<泛型類型>
* C:案例演示
* 泛型接口的使用
*/
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> { //沒有必要在實現接口的時候給本身類加泛型
@Override
public void show(T t) {
System.out.println(t);
}
}
16.12_集合框架(泛型高級之通配符)(瞭解)
- A:泛型通配符<?>
- 任意類型，若是沒有明確，那麼就是Object以及任意的Java類了
- B:? extends E
- 向下限定，E及其子類
- C:? super E
- 向上限定，E及其父類
package com.heima.generic;
import java.util.ArrayList;
import java.util.List;
import com.heima.bean.Person;
import com.heima.bean.Student;
public class Demo5_Generic {
/**
* * 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:好處
- 簡化遍歷
package com.heima.jdk5;
import java.util.ArrayList;
import java.util.Iterator;
import com.heima.bean.Person;
public class Demo1_Foreach {
/**
* * 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");
//1,普通for循環刪除,索引要--
/*for(int i = 0; i < list.size(); i++) {
if("b".equals(list.get(i))) {
list.remove(i--); //經過索引刪除元素
}
}*/
//2,迭代器刪除
/*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();
}
}*/
//3,加強for循環,加強for循環不能刪除,只能遍歷
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");
list.add("d");
for (String string : list) {
System.out.println(string);
}
}
}
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循環,能夠刪除,可是索引要--
- 迭代器,能夠刪除,可是必須使用迭代器自身的remove方法,不然會出現併發修改異常
- 加強for循環不能刪除
16.16_集合框架(靜態導入的概述和使用)(瞭解)
- A:靜態導入概述
- B:格式：
- import static 包名….類名.方法名;
- 能夠直接導入到方法的級別
- C:注意事項
- 方法必須是靜態的,若是有多個同名的靜態方法，容易不知道使用誰? 這個時候要使用，必須加前綴。因而可知，意義不大，因此通常不用，可是要能看懂。
package com.heima.jdk5;
import static java.util.Arrays.sort; //靜態導入
import static java.util.Arrays.toString; //靜態導入
public class Demo2_StaticImport {
/**
* * A:靜態導入概述
* 靜態導入是導入類中靜態方法
* B:格式：
* import static 包名….類名.方法名;
* 能夠直接導入到方法的級別
* C:注意事項
* 方法必須是靜態的,若是有多個同名的靜態方法，容易不知道使用誰?這個時候要使用，必須加前綴。因而可知，意義不大，因此通常不用，可是要能看懂。
靜態導入開發不用,可是須要能看懂
*/
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:注意事項：
- 這裏的變量實際上是一個數組
- 若是一個方法有可變參數，而且有多個參數，那麼，可變參數確定是最後一個
package com.heima.jdk5;
public class Demo3_ChangeableArgs {
/**
* * 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)泛型版的集合轉數組
package com.heima.jdk5;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Demo4_AsList {
/**
* 數組轉換成集合
* 數組轉換成集合雖然不能增長或減小元素,可是能夠用集合的思想操做數組,也就是說可使用其餘集合中的方法
*/
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
package com.heima.list;
import java.util.ArrayList;
import com.heima.bean.Person;
public class Demo5_ArrayListArrayList {
/**
* * 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);
}
}
}
}
16.20_day16總結
- 把今天的知識點總結一遍。
相關文章
- 1. JAVA語言基礎-面向對象（集合框架：Map集合）
- 2. JAVA語言基礎-面向對象（集合框架01Collection）
- 3. JAVA語言基礎-面向對象（集合框架02Set）
- 4. JAVA語言基礎-面向對象（集合框架總結）
- 5. JAVA語言基礎-面向對象（IO：File）
- 6. Java面向對象——泛型
- 7. Java集合框架泛型
- 8. 面向對象（5）集合框架
- 9. C語言之面向對象基礎
- 10. JAVA基礎--JAVA 集合框架（泛型、file類）
- 更多相關文章...
- • R 語言基礎 - R 語言教程
- • PHP 面向對象 - PHP教程
- • Kotlin學習（二）基本類型
- • Kotlin學習（一）基本語法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
