day15-----------集合框架（傳智視頻）

時間  2019-11-19
標籤 day15 day 集合 框架 視頻 欄目 快樂工作 简体版
原文   原文鏈接 
package cn.itcast_01;

public class Student {
	// 成員變量
	private String name;
	private int age;

	// 構造方法
	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	// 成員方法
	// getXxx()/setXxx()
	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 + "]";
	}
}

package cn.itcast_01;

/*
 * 我有5個學生，請把這個5個學生的信息存儲到數組中，並遍歷數組，獲取獲得每個學生信息。
 *		 學生：Student
 *		 成員變量：name,age
 *		 構造方法：無參,帶參
 *		 成員方法：getXxx()/setXxx()
 *		 存儲學生的數組?本身想一想應該是什麼樣子的?
 * 分析：
 * 		A:建立學生類。
 * 		B:建立學生數組(對象數組)。
 * 		C:建立5個學生對象，並賦值。
 * 		D:把C步驟的元素，放到數組中。
 * 		E:遍歷學生數組。
 */
public class ObjectArrayDemo {
	public static void main(String[] args) {
		// 建立學生數組(對象數組)。
		Student[] students = new Student[5];
		// for (int x = 0; x < students.length; x++) {
		// System.out.println(students[x]);
		// }
		// System.out.println("---------------------");

		// 建立5個學生對象，並賦值。
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("風清揚", 30);
		Student s3 = new Student("劉意", 30);
		Student s4 = new Student("趙雅芝", 60);
		Student s5 = new Student("王力宏", 35);

		// 把C步驟的元素，放到數組中。
		students[0] = s1;
		students[1] = s2;
		students[2] = s3;
		students[3] = s4;
		students[4] = s5;

		// 看到很類似，就想循環改
		// for (int x = 0; x < students.length; x++) {
		// students[x] = s + "" + (x + 1);
		// }
		// 這個是有問題的

		// 遍歷
		for (int x = 0; x < students.length; x++) {
			//System.out.println(students[x]);
			
			Student s = students[x];
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}

對象數組的內存圖解java

集合的繼承體系圖解
android

package cn.itcast_01;

import java.util.ArrayList;
import java.util.Collection;

/*
 * 集合的由來：
 * 		咱們學習的是面嚮對象語言，而面嚮對象語言對事物的描述是經過對象體現的，爲了方便對多個對象進行操做，咱們就必須把這多個對象進行存儲。
 * 		而要想存儲多個對象，就不能是一個基本的變量，而應該是一個容器類型的變量，在咱們目前所學過的知識裏面，有哪些是容器類型的呢?
 * 		數組和StringBuffer。可是呢?StringBuffer的結果是一個字符串，不必定知足咱們的要求，因此咱們只能選擇數組，這就是對象數組。
 * 		而對象數組又不能適應變化的需求，由於數組的長度是固定的，這個時候，爲了適應變化的需求，Java就提供了集合類供咱們使用。
 * 
 * 數組和集合的區別?
 * 		A:長度區別
 * 			數組的長度固定
 * 			集合長度可變
 * 		B:內容不一樣
 * 			數組存儲的是同一種類型的元素
 * 			而集合能夠存儲不一樣類型的元素
 * 		C:元素的數據類型問題	
 * 			數組能夠存儲基本數據類型，也能夠存儲引用數據類型
 * 			集合只能存儲引用類型
 * 
 * 剛說過集合是存儲多個元的，可是呢，存儲多個元素咱們也是有不一樣需求的：好比說，我要這多個元素中不能有相同的元素，
 * 再好比說，我要這多個元素按照某種規則排序一下。針對不一樣的需求，Java就提供了不一樣的集合類，這樣呢，Java就提供了不少個集合類。
 * 這多個集合類的數據結構不一樣,結構不一樣不重要的，重要的是你要可以存儲東西，而且還要可以使用這些東西，好比說判斷，獲取等。
 * 既然這樣，那麼，這多個集合類是有共性的內容的，咱們把這些集合類的共性內容不斷的向上提取，最終就能造成集合的繼承體系結構。
 * 
 * 數據結構：數據的存儲方式。
 * 
 * Collection:是集合的頂層接口，它的子體系有重複的，有惟一的，有有序的，有無序的。(後面會慢慢的講解)
 * 
 * Collection的功能概述：
 * 1：添加功能
 * 		boolean add(Object obj):添加一個元素
 * 		boolean addAll(Collection c):添加一個集合的元素
 * 2:刪除功能
 * 		void clear():移除全部元素
 * 		boolean remove(Object o):移除一個元素
 * 		boolean removeAll(Collection c):移除一個集合的元素(是一個仍是全部)
 * 3:判斷功能
 * 		boolean contains(Object o)：判斷集合中是否包含指定的元素
 * 		boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(是一個仍是全部)
 * 		boolean isEmpty()：判斷集合是否爲空
 * 4:獲取功能
 * 		Iterator<E> iterator()(重點)
 * 5:長度功能
 * 		int size():元素的個數
 * 		面試題：數組有沒有length()方法呢?字符串有沒有length()方法呢?集合有沒有length()方法呢?
 * 6:交集功能
 * 		boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
 * 7：把集合轉換爲數組
 * 		Object[] toArray()
 */
public class CollectionDemo {
	public static void main(String[] args) {
		// 測試不帶All的方法

		// 建立集合對象
		// Collection c = new Collection(); //錯誤，由於接口不能實例化
		Collection c = new ArrayList();

		// boolean add(Object obj):添加一個元素
		// System.out.println("add:"+c.add("hello"));
		c.add("hello");
		c.add("world");
		c.add("java");

		// void clear():移除全部元素
		// c.clear();

		// boolean remove(Object o):移除一個元素
		// System.out.println("remove:" + c.remove("hello"));
		// System.out.println("remove:" + c.remove("javaee"));

		// boolean contains(Object o)：判斷集合中是否包含指定的元素
		// System.out.println("contains:"+c.contains("hello"));
		// System.out.println("contains:"+c.contains("android"));

		// boolean isEmpty()：判斷集合是否爲空
		// System.out.println("isEmpty:"+c.isEmpty());

		//int size():元素的個數
		System.out.println("size:"+c.size());
		
		System.out.println("c:" + c);
	}
}

package cn.itcast_01;

import java.util.ArrayList;
import java.util.Collection;

/*
 * boolean addAll(Collection c):添加一個集合的元素
 * boolean removeAll(Collection c):移除一個集合的元素(是一個仍是全部)
 * boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(是一個仍是全部)
 * boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
 */
public class CollectionDemo2 {
	public static void main(String[] args) {
		// 建立集合1
		Collection c1 = new ArrayList();
		c1.add("abc1");
		c1.add("abc2");
		c1.add("abc3");
		c1.add("abc4");

		// 建立集合2
		Collection c2 = new ArrayList();
//		c2.add("abc1");
//		c2.add("abc2");
//		c2.add("abc3");
//		c2.add("abc4");
		c2.add("abc5");
		c2.add("abc6");
		c2.add("abc7");

		// boolean addAll(Collection c):添加一個集合的元素
		// System.out.println("addAll:" + c1.addAll(c2));
		
		//boolean removeAll(Collection c):移除一個集合的元素(是一個仍是全部)
		//只要有一個元素被移除了，就返回true。
		//System.out.println("removeAll:"+c1.removeAll(c2));

		//boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(是一個仍是全部)
		//只有包含全部的元素，才叫包含
		// System.out.println("containsAll:"+c1.containsAll(c2));
		
		//boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
		//假設有兩個集合A，B。
		//A對B作交集，最終的結果保存在A中，B不變。
		//返回值表示的是A是否發生過改變。
		System.out.println("retainAll:"+c1.retainAll(c2));
		
		System.out.println("c1:" + c1);
		System.out.println("c2:" + c2);
	}
}

集合的遍歷之集合轉數組遍歷
面試

package cn.itcast_01;

import java.util.ArrayList;
import java.util.Collection;

/*
 * 集合的遍歷。其實就是依次獲取集合中的每個元素。
 * 
 * Object[] toArray():把集合轉成數組，能夠實現集合的遍歷
 */
public class CollectionDemo3 {
	public static void main(String[] args) {
		// 建立集合對象
		Collection c = new ArrayList();

		// 添加元素
		c.add("hello"); // Object obj = "hello"; 向上轉型
		c.add("world");
		c.add("java");

		// 遍歷
		// Object[] toArray():把集合轉成數組，能夠實現集合的遍歷
		Object[] objs = c.toArray();
		for (int x = 0; x < objs.length; x++) {
			// System.out.println(objs[x]);
			// 我知道元素是字符串，我在獲取到元素的的同時，還想知道元素的長度。
			// System.out.println(objs[x] + "---" + objs[x].length());
			// 上面的實現不了，緣由是Object中沒有length()方法
			// 咱們要想使用字符串的方法，就必須把元素還原成字符串
			// 向下轉型
			String s = (String) objs[x];
			System.out.println(s + "---" + s.length());
		}
	}
}

Collection 存儲自定義對象並遍歷案例
數組

package cn.itcast_02;

public class Student {
	// 成員變量
	private String name;
	private int age;

	// 構造方法
	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	// 成員方法
	// getXxx()/setXxx()
	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;
	}
}

package cn.itcast_02;

import java.util.ArrayList;
import java.util.Collection;

/*
 * 練習：用集合存儲5個學生對象，並把學生對象進行遍歷。
 * 
 * 分析：
 * A:建立學生類
 * B:建立集合對象
 * C:建立學生對象
 * D:把學生添加到集合
 * E:把集合轉成數組
 * F:遍歷數組
 */
public class StudentDemo {
	public static void main(String[] args) {
		// 建立集合對象
		Collection c = new ArrayList();

		// 建立學生對象
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("風清揚", 30);
		Student s3 = new Student("令狐沖", 33);
		Student s4 = new Student("武鑫", 25);
		Student s5 = new Student("劉曉曲", 22);

		// 把學生添加到集合
		c.add(s1);
		c.add(s2);
		c.add(s3);
		c.add(s4);
		c.add(s5);

		// 把集合轉成數組
		Object[] objs = c.toArray();
		// 遍歷數組
		for (int x = 0; x < objs.length; x++) {
			// System.out.println(objs[x]);

			Student s = (Student) objs[x];
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}

迭代器
安全

package array;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteatorTest2 {

	public static void main(String[] args) {
		
		Collection c = new ArrayList();
		
		Student s1 = new Student("lisi",23);
		Student s2 = new Student("wangwu",24);
		Student s3 = new Student("zhaoliu",34);
		Student s4 = new Student("zhangsan",12);
		
		c.add(s1);
		c.add(s2);
		c.add(s3);
		c.add(s4);

		for(Iterator it = c.iterator();it.hasNext();){
			Student s = (Student)it.next();
			System.out.println(s.getName()+"--------"+s.getAge());
		}
	}

}

package cn.itcast_01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
 * List集合的特色：
 * 		有序(存儲和取出的元素一致)，可重複的。
 */
public class ListDemo2 {
	public static void main(String[] args) {
		// 建立集合對象
		List list = new ArrayList();

		// 存儲元素
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("javaee");
		list.add("android");
		list.add("javaee");
		list.add("android");

		// 遍歷集合
		Iterator it = list.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();
			System.out.println(s);
		}
	}
}

package cn.itcast_03;

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

/*
 * List集合的特有功能：
 * A:添加功能
 * 		void add(int index,Object element):在指定位置添加元素
 * B:獲取功能
 * 		Object get(int index):獲取指定位置的元素
 * C:列表迭代器
 * 		ListIterator listIterator()：List集合特有的迭代器
 * D:刪除功能
 * 		Object remove(int index)：根據索引刪除元素,返回被刪除的元素
 * E:修改功能
 * 		Object set(int index,Object element):根據索引修改元素，返回被修飾的元素
 */
public class ListDemo {
	public static void main(String[] args) {
		// 建立集合對象
		List list = new ArrayList();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// void add(int index,Object element):在指定位置添加元素
		// list.add(1, "android");//沒有問題
		// IndexOutOfBoundsException
		// list.add(11, "javaee");//有問題
		// list.add(3, "javaee"); //沒有問題
		// list.add(4, "javaee"); //有問題

		// Object get(int index):獲取指定位置的元素
		// System.out.println("get:" + list.get(1));
		// IndexOutOfBoundsException
		// System.out.println("get:" + list.get(11));

		// Object remove(int index)：根據索引刪除元素,返回被刪除的元素
		// System.out.println("remove:" + list.remove(1));
		// IndexOutOfBoundsException
		// System.out.println("remove:" + list.remove(11));

		// Object set(int index,Object element):根據索引修改元素，返回被修飾的元素
		System.out.println("set:" + list.set(1, "javaee"));

		System.out.println("list:" + list);
	}
}

list集合的特有遍歷功能數據結構

package cn.itcast_03;

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

/*
 * List集合的特有遍歷功能：
 * 		size()和get()方法結合使用
 */
public class ListDemo2 {
	public static void main(String[] args) {
		// 建立集合對象
		List list = new ArrayList();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// Object get(int index):獲取指定位置的元素
		// System.out.println(list.get(0));
		// System.out.println(list.get(1));
		// System.out.println(list.get(2));
		// IndexOutOfBoundsException
		// System.out.println(list.get(3));

		// 用循環改進
		// for (int x = 0; x < 3; x++) {
		// System.out.println(list.get(x));
		// }
		// 若是元素過多，數起來就比較麻煩，因此咱們使用集合的一個長度功能：size()
		// 最終的遍歷方式就是：size()和get()
		for (int x = 0; x < list.size(); x++) {
			// System.out.println(list.get(x));

			String s = (String) list.get(x);
			System.out.println(s);
		}
	}
}

ListIterator的特有功能
併發

package cn.itcast_04;

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

/*
 * 列表迭代器：
 * 		ListIterator listIterator()：List集合特有的迭代器
 * 		該迭代器繼承了Iterator迭代器，因此，就能夠直接使用hasNext()和next()方法。
 * 
 * 特有功能：
 * 		Object previous():獲取上一個元素
 * 		boolean hasPrevious():判斷是否有元素
 * 
 * 		注意：ListIterator能夠實現逆向遍歷，可是必須先正向遍歷，才能逆向遍歷，因此通常無心義，不使用。
 */
public class ListIteratorDemo {
	public static void main(String[] args) {
		// 建立List集合對象
		List list = new ArrayList();
		list.add("hello");
		list.add("world");
		list.add("java");

		// ListIterator listIterator()
		ListIterator lit = list.listIterator(); // 子類對象
		// while (lit.hasNext()) {
		// String s = (String) lit.next();
		// System.out.println(s);
		// }
		// System.out.println("-----------------");
		
		// System.out.println(lit.previous());
		// System.out.println(lit.previous());
		// System.out.println(lit.previous());
		// NoSuchElementException
		// System.out.println(lit.previous());

		while (lit.hasPrevious()) {
			String s = (String) lit.previous();
			System.out.println(s);
		}
		System.out.println("-----------------");

		// 迭代器
		Iterator it = list.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();
			System.out.println(s);
		}
		System.out.println("-----------------");

	}
}

併發修改異常的產生緣由及解決方案
ide

package cn.itcast_04;

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

/*
 * 問題?
 * 		我有一個集合，以下，請問，我想判斷裏面有沒有"world"這個元素，若是有，我就添加一個"javaee"元素，請寫代碼實現。
 * 
 * ConcurrentModificationException:當方法檢測到對象的併發修改，但不容許這種修改時，拋出此異常。 
 * 產生的緣由：
 * 		迭代器是依賴於集合而存在的，在判斷成功後，集合的中新添加了元素，而迭代器殊不知道，因此就報錯了，這個錯叫併發修改異常。
 * 		其實這個問題描述的是：迭代器遍歷元素的時候，經過集合是不能修改元素的。
 * 如何解決呢?
 * 		A:迭代器迭代元素，迭代器修改元素
 * 			元素是跟在剛纔迭代的元素後面的。
 * 		B:集合遍歷元素，集合修改元素(普通for)
 * 			元素在最後添加的。
 */
public class ListIteratorDemo2 {
	public static void main(String[] args) {
		// 建立List集合對象
		List list = new ArrayList();
		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// 迭代器遍歷
		// Iterator it = list.iterator();
		// while (it.hasNext()) {
		// String s = (String) it.next();
		// if ("world".equals(s)) {
		// list.add("javaee");
		// }
		// }

		// 方式1：迭代器迭代元素，迭代器修改元素
		// 而Iterator迭代器卻沒有添加功能，因此咱們使用其子接口ListIterator
		// ListIterator lit = list.listIterator();
		// while (lit.hasNext()) {
		// String s = (String) lit.next();
		// if ("world".equals(s)) {
		// lit.add("javaee");
		// }
		// }

		// 方式2：集合遍歷元素，集合修改元素(普通for)
		for (int x = 0; x < list.size(); x++) {
			String s = (String) list.get(x);
			if ("world".equals(s)) {
				list.add("javaee");
			}
		}

		System.out.println("list:" + list);
	}
}

List:(面試題List的子類特色)
	ArrayList:
		底層數據結構是數組，查詢快，增刪慢。
		線程不安全，效率高。
	Vector:
		底層數據結構是數組，查詢快，增刪慢。
		線程安全，效率低。
	LinkedList:
		底層數據結構是鏈表，查詢慢，增刪快。
		線程不安全，效率高。
		
	List有三個兒子，咱們到底使用誰呢?
		看需求(狀況)。
		
	要安全嗎?
		要：Vector(即便要安全，也不用這個了，後面有替代的)
		不要：ArrayList或者LinkedList
			查詢多：ArrayList
			增刪多：LinkedList
			
	若是你什麼都不懂，就用ArrayList。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程