黑馬程序員 java集合框架筆記(一)

-------android培訓、java培訓、期待與您交流！ ----------

集合框架

集合類用來存儲對象（數據多了用對象存，對象多了用集合存）

爲什麼會出現這麼多容器呢？

因爲每個容器對數據的存儲方式都不同。這個存儲方式同城爲數據結構

共性方法

集合裏存的是地址

1 add方法中的參數類型是object 以便於接受任意類型的對象。

2 集合中存儲的都是對象的引用（地址）

迭代器

什麼是迭代器

其實就是集合卻出元素的方式

取出的方式定義在集合的內部，這樣取出方式就可以直接訪問集合內的元素，那麼取出方式就被定義成了內部類，而每一個容器的數據結構不同，所以取出的動作細節也不一樣。但是都是具有共性內容判斷和取出，那麼可以講這些共性抽取，這些內部類都符合一個規則，該規則是iterator。

如何獲取集合的取出對象呢?

通過對外提供的方法較多， iterator()方法， list集合共性方法。

下面將collection定義了集合框架的共性功能

1，添加
add(e);
addAll(collection);
2，刪除
remove(e);
removeAll(collection);
clear();
3，判斷。
contains(e);
isEmpty();
4，獲取
iterator();
size();
5，獲取交集。
retainAll();
6，集合變數組。
toArray();

import java.util.*;

class  CollectionDemo
{
	public static void main(String[] args) 
	{
		
		method_get();
	}
	public static void method_get()
	{
		ArrayList al = new ArrayList();

		//1，添加元素。
		al.add("java01");//add(Object obj);
		al.add("java02");
		al.add("java03");
		al.add("java04");

		/*
		Iterator it = al.iterator();//獲取迭代器，用於取出集合中的元素。

		while(it.hasNext())
		{
			sop(it.next());
		}
		*/

		for(Iterator it = al.iterator(); it.hasNext() ; )
		{
			sop(it.next());
		}
	}


	public static void method_2()
	{
		ArrayList al1 = new ArrayList();

		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");
		ArrayList al2 = new ArrayList();

		al2.add("java03");
		al2.add("java04");
		al2.add("java05");
		al2.add("java06");

		
		//al1.retainAll(al2);//去交集，al1中只會保留和al2中相同的元素。
		al1.removeAll(al2);

		sop("al1:"+al1);
		sop("al2:"+al2);




	}

	public static void base_method()
	{
		//創建一個集合容器。使用Collection接口的子類。ArrayList
		ArrayList al = new ArrayList();

		//1，添加元素。
		al.add("java01");//add(Object obj);
		al.add("java02");
		al.add("java03");
		al.add("java04");

		//打印原集合。
		sop("原集合:"+al);


		//3，刪除元素。
		//al.remove("java02");
		//al.clear();//清空集合。


		//4，判斷元素。
		sop("java03是否存在:"+al.contains("java03"));
		sop("集合是否爲空？"+al.isEmpty());


		//2，獲取個數。集合長度。
		sop("size:"+al.size());

		//打印改變後的集合。
		sop(al);

	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

LinkedList 特有方法

addFirst(); 往頭上加 addFirst(“1”);addFirst(“2”);addFirst(“3”); ---> 3 2 1
addLast(); 往尾部加 addLast("1");addLast("2");addLast("3"); ---> 1 2 3

getFirst();
getLast();
獲取元素但不刪除元素如果集合中沒有元素會出現 NoSuchElementException

removeFirst();
removeLast();
獲取元素但是元素被刪除如果集合中沒有元素會出現 NoSuchElementException

在jdk1.6 出現了代替方法

offerFirst();
offerLast();

peekFirst();
peekLast();
獲取元素但是元素不被刪除如果集合中沒有元素會返回 null

pollFirst();
pollLast();
獲取元素但是元素被刪除如果集合中沒有元素會返回null

class LinkedListDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		LinkedList link = new LinkedList();

		link.addFirst("j  01 ");
		link.addFirst("j  02 ");
		link.addFirst("j  03 ");
		link.addFirst("j  04 ");
		sop(link);
		//不用迭代器取出
			while (!link.isEmpty())
			{
				sop(link.removeFirst());
			}
		
	}
}

---------------------------------------------------------------------------------

import java.util.*;
/*
去除arraylist中的重複元素

注意在迭代時 循環中next調用一次 就好hasnext判斷一次、
*/

class  ArrayListTest
{
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();
		al.add("java 01 ");
		al.add("java 01 ");
		al.add("java 02 ");
		al.add("java 03 ");
		al.add("java 04 ");
		sop(al);

		al = singleElement(al);

		sop(al);


	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static ArrayList singleElement(ArrayList al)
	{
		//定義一個臨時容器
		ArrayList newAl = new ArrayList();
		
		Iterator it = al.iterator();

		while (it.hasNext())
		{
			Object obj = it.next();
			if(!newAl.contains(obj))
				newAl.add(obj);
		}
		return newAl;
	}
}

枚舉就是vector特有的取出方式。發現枚舉和迭代器很像
其實枚舉和迭代時一樣的因爲枚舉的名稱以及方法的名稱都過長

所以被迭代器取代了枚舉就過時了。

class VectorDemo 
{
	public static void main(String[] args) 
	{
		Vector v = new Vector();
		v.add("jv 1");
		v.add("jv 2");
		v.add("jv 3");
		v.add("jv 4");
		v.add("jv 5");
	Enumeration en = v.elements();
	while (en.hasMoreElements())
	{
		System.out.println(en.nextElement());
	}
		
	}
}

import java.util.*;
/*
將自定義對象作爲元素存儲到ArrayList集合中，並去除重複元素
比如 存人對象，同姓名童年兩視爲同一個人 爲重複元素。

思路
1 對人描述 將數據封裝進人對象，
2 定義容器，將人存入
3 取出 。

list集合判斷元素是否相同 是調用對象的equals方法  

*/
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	/*
	 不重寫 equals方法 重複的就幹不掉， 爲什麼呢 
	 ArrayList這個容器 不知道判斷相同的條件 它只判斷往裏面存的對象是否相同
	 而判斷對象是否相同用equals  記住  ArrayList這個容器裏面判斷元素是否相同
	 用的是equals方法  那麼在這個比較過程中使用的是對象的 equals方法來與另一個對象比較
	 相同返回真否則假， person類是繼承自object類的 object類裏面的equals比較的是地址值
	 按地址值來比較 你新加的這幾個對象的地址值都是不一樣的 所以幹不掉重複的。

	 所以 我們要告訴他按着我們的方法做 那就iushi重寫equals 。
	*/
	public boolean equals(Object obj) 
	{
		if(!(obj instanceof Person)) // obj instanceof Person 如果這個obj對象是 Person類的 返回true 不是則返回false
			return false;
		Person p = (Person)obj;

		return this.name.equals(p.name)&&this.age == p.age;
	}
	public int getAge()
	{
		return age;
	}
	public String getName()
	{
		return name;
	}

	
}

class  ArrayListTest2
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
			ArrayList al = new ArrayList();
			al.add(new Person("lisi01",31));
			al.add(new Person("lisi05",35));
			al.add(new Person("lisi02",32));
			al.add(new Person("lisi03",33));
			al.add(new Person("lisi04",34));
			al.add(new Person("lisi03",33));//
			al.add(new Person("lisi04",34));//
		al = singleElement(al);
		Iterator it = al.iterator();
		// 比如想刪除03 這個元素  如果把上面那個重寫的equals刪掉 則這個就沒法刪
		// 說明remove底層也是調用的equals
		//sop("remove 03 : "+al.remove(new Person("lisi03",33)));
		while (it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"....."+p.getAge());
		}
		

	
	}
	public static ArrayList singleElement(ArrayList al)
	{
		//定義一個臨時容器
		ArrayList newAl = new ArrayList();
		
		Iterator it = al.iterator();

		while (it.hasNext())
		{
			Object obj = it.next();
			if(!newAl.contains(obj)) //contains底層調用的是equals
				newAl.add(obj);
		}
		return newAl;
	}
}

去除arraylist中的重複元素

注意在迭代時循環中next調用一次就好hasnext判斷一次、

import java.util.*;
/*
Set 元素無序（存入和取出的順序不一定一致 有序是怎麼存入怎麼取出 ） 元素不可以重複
	|-- HashSet 底層數據結構是哈希表
			HashSet 是如何保證 元素的唯一性的呢
			是通過元素的兩個方法，hashCode和equals 來完成的
			如果元素的hashCode值形同，纔會判斷equals是否爲true
			如果元素的hashCode值不同，不會調用equals

			注意 對於判斷元素是否存在，以及刪除等操作，依賴的方法是元素的hashcode（先）和equals（後）方法

	|-- TreeSet 

set 集合的功能和collection是一致的


哈希這個判斷相同的時候是不讀equals的 
它在往內存裏面放數據之前要先對對象生成哈希值
根據哈希值在內存裏面分配位置直接存。
那麼我們要做的是覆蓋Person的哈希函數，建立Person對象自己的
哈希值  

所以說寫這樣的類一般都要複寫hashcode和equals函數。
*/

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public int getAge()
	{
		return age;
	}
	public String getName()
	{
		return name;
	}
	public int  hashCode()
	{
		System.out.println(this.name+"....hasCode");//演示調用了hashcode
		return name.hashCode()+age*39; // *39是隨便乘一個不超範圍數保證搞出的哈希值不一樣，省的判斷equals 提高效率
	}

	public boolean equals(Object obj) 
	{
		if(!(obj instanceof Person)) 
			return false;
		Person p = (Person)obj;
		System.out.println(this.name+"...equals.."+p.name);//演示equals的比較過程
		return this.name.equals(p.name)&&this.age == p.age;
	}
	
}

class HashSetDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();

		hs.add(new Person("jva01",11));
		hs.add(new Person("jva01",11));
		hs.add(new Person("jva03",13));
		hs.add(new Person("jva04",14));
		
		Iterator it = hs.iterator();
		while (it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"....."+p.getAge());
		}
		
	}
}

使用linkedlist模擬一個堆棧或者隊列數據結構

堆棧先進後出杯子
隊列先進先出水管

必須要會使用linkedlist模擬一個堆棧或者隊列數據結構

堆棧先進後出杯子
隊列先進先出水管

必須要會

class DuiLie
{
	private LinkedList link;
	DuiLie()
	{
		link = new LinkedList();
	}
	public void myAdd(Object obj)
	{
		link.addFirst(obj);
	}
	public Object myGet()
	{
		return link.removeFirst();
	}
	public boolean isNull()
	{
		return link.isEmpty();
	}
}
class  LinkedListTest
{
	public static void main(String[] args) 
	{
		DuiLie dl  = new DuiLie();
		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");

		

		while (!dl.isNull())
		{
			System.out.println(dl.myGet());
		}
		
	}
}

ArrayList : 底層使用的數據結構是數組結構特點是查詢修改速度快線程不同步效率高
LinkList 底層使用的數鏈表數據結構特點是增加刪除速度快，查詢稍微慢
Vector 底層是數組數據結構線程同步效率低被ArrayList替代了。

List集合特有的迭代器叫做 ListIterator是Iterator的子接口
在迭代時，不可以通過集合對象的方法操作集合中的元素，因爲會發生併發修改異常
ConcurrentModificationException 所以在迭代時只能用迭代器的方法操作元素，可是
Iterator的方法是有限的，只能對元素進行判斷取出刪除的操作，如果想要其他的操作如添加
修改等就需要使用其子接口ListIterator。該接口只能通過list集合的ListIterator方法獲取

import java.util.*;

class  ListDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		//掩飾列表迭代器
		ArrayList al = new ArrayList();
		//添加元素

		al.add("jva01");
		al.add("jva02");
		al.add("jva03");
		al.add("jva04");
		sop(al);
		
		ListIterator li  = al.listIterator();
		while (li.hasNext())
		{
			Object obj = li.next();
			if(obj.equals("jva02"))
				//li.add("jva009");
			li.set("jva 006 ");
				
		}

		sop(al);
		/*
		//在迭代過程中準備 添加或者刪除元素。
		Iterator it = al.iterator();

		while (it.hasNext())
		{
			//sop("next : "+it.next());
			Object obj = it.next();
			if (obj.equals("jva02"))
				//al.add("jva0008");
				it.remove();// 將jva02的引用從集合中刪除了。
			sop("obj = "+obj);
			

			
		}*/

		
	}
}

-------android培訓、java培訓、期待與您交流！ ----------

大仁

發佈了28 篇原創文章 · 獲贊 2 · 訪問量 2萬+

私信關注

黑馬程序員 java集合框架筆記(一)

《Python進階》學習筆記

Leetcode 3161. 物塊放置查詢

leetcode 60 排列序列

一個docker容器暴露多個端口

微服務實踐之使用 Visual Studio 2022 調試Dapr 應用程序

wpf附加屬性理解 WPF附加屬性

黑馬程序員 java面向對象（二）

黑馬程序員 java多線程筆記（二）

黑馬程序員 java String 筆記

黑馬程序員 java多線程筆記（一）

黑馬程序員 java基礎函數數組查找與排序總結

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結