集合的基本用法

最新推荐文章于 2025-03-06 23:30:00 发布

心动ヾ

最新推荐文章于 2025-03-06 23:30:00 发布

阅读量350

点赞数 1

分类专栏： java0-21 文章标签： java jvm servlet

本文链接：https://blog.youkuaiyun.com/guoguo0717/article/details/126351999

版权

java0-21 专栏收录该内容

9 篇文章

订阅专栏

活动地址：优快云21天学习挑战赛

8.1.Java中集合框架的体系结构
集合框架–java做好的用来管理乱七八糟的一堆数据的java类库
在这里插入图片描述
8.2.Collection接口与Map接口的区别

在这里插入图片描述
8.3.List接口与Set接口的区别

8.4.ArrayList类和LinkedList类的用法
ArrayList类–public class ArrayList

package com.ListDemo.Test1;

import java.util.ArrayList;

public class TestArrayList1 {

	public static void main(String[] args) {
		//ArrayList()构造一个初始容量为10的空列表
		ArrayList arraylist1 = new ArrayList();
		//ArrayList(Collection c)通过一个实现Collection接口的子类/子接口对象创建一个列表
		ArrayList arraylist2 = new ArrayList(arraylist1);
		//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。  TODO Auto-generated method stub
		ArrayList  arraylist3=new ArrayList(50);	
	}

}

实例方法：
在这里插入图片描述

package com.ListDemo.Test1;

import java.util.ArrayList;

public class TestArrayList2 {

	public static void main(String[] args) {
		//ArrayList()构造一个初始容量位10的空列表
		ArrayList arraylist1 = new ArrayList();
		//boolean add(Object o)将指定的元素追加到此列表的末尾
		arraylist1.add("hello");
		arraylist1.add("123");
		arraylist1.add("false");
		arraylist1.add("3.14");
		arraylist1.add("hello");
		//boolean	contains(Object o) 如果此列表包含指定的元素，则返回 true 。 
		System.out.println("contains=="+arraylist1.contains("world"));
		//Object 	get(int index) 返回此列表中指定位置的元素。
		System.out.println("get=="+arraylist1.get(2));
		//int	indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
		System.out.println("indexOf=="+arraylist1.indexOf("world"));
		//int	lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 
		System.out.println("lastIndexOf=="+arraylist1.lastIndexOf("hello"));
		/*
		//int	size() 返回此列表中的元素数。 
		System.out.println("没有remove之前的size=="+arraylist1.size());
		//Object 	remove(int index) 删除该列表中指定位置的元素。
		arraylist1.remove(1);
		//boolean	remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		arraylist1.remove("hello");
		System.out.println("remove之后的size=="+arraylist1.size());
		System.out.println("lastIndexOf=="+arraylist1.lastIndexOf("hello"));
		*/
		//Object 	set(int index, Object  element) 用指定的元素替换此列表中指定位置的元素。 
		arraylist1.set(arraylist1.indexOf(false), true);
		System.out.println(arraylist1.get(arraylist1.indexOf(true)));
		//boolean	isEmpty() 如果此列表不包含元素，则返回 true 。
		System.out.println("isEmpty=="+arraylist1.isEmpty());
		//void	clear() 从列表中删除所有元素。 
		arraylist1.clear();
		System.out.println("isEmpty=="+arraylist1.isEmpty());
	}

}

遍历ArrayList

package com.ListDemo.Test1;

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

public class TestArrayList3 {

	public static void main(String[] args) {
		//ArrayList()构造一个初始容量位10的空列表
		ArrayList arraylist1 = new ArrayList();
		//boolean add(Object o)将指定的元素追加到此列表的末尾
		arraylist1.add("hello");
		arraylist1.add("123");
		arraylist1.add("false");
		arraylist1.add("3.14");
		arraylist1.add("hello");
		//普通for循环
		for(int i = 0;i<arraylist1.size();i++) {
			System.out.println(arraylist1.get(i));
		}
		System.out.println("-----------------");
		
		//增强的for循环
		for(Object o:arraylist1) {
			System.out.println(o);
		}
		System.out.println("-----------------");
		//迭代器
		Iterator it = arraylist1.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

}

LinkedList类—public class LinkedList
构造方法

package com.ListDemo.Test2;
import java.util.ArrayList;
import java.util.LinkedList;
public class TestLinkedList1 {
	public static void main(String[] args) {
		//LinkedList() 构造一个空列表。 
		LinkedList  linkedList1=new LinkedList();
		//LinkedList(Collection c) 通过一个实现Collection 接口的子类/子接口对象创建一个列表	
		LinkedList  linkedList2=new LinkedList(linkedList1);
		ArrayList  arrayList=new ArrayList();
		LinkedList  linkedList3=new LinkedList(arrayList);
		//总结:代用Collection参数的构造方法可以用来进行集合类之间的转换
	}
}

在这里插入图片描述
一组对第一个元素和最后一个元素的操作方法

为什么LinkedList会比ArrayList多出一组对第一个元素和最后一个元素的操作方法？
因为ArrayList是动态数组结构，他在查找第一个元素和最后一个元素的时很麻烦，而LinkedList采用的是双向链表结构，这种结构在查找第一个元素和最后一个元素的时候是最快的。就像一列火车我们眼前驶过，我们可能不知道这列火车由几节车厢组成，但是我们一定会在第一时间看清第一节与最后一节车厢位置。

遍历LinkedList
package com.ListDemo.Test2;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
public class TestLinkedList3 {
	public static void main(String[] args) {
		//LinkedList() 构造一个的空列表。 
		LinkedList  linkedList=new LinkedList();
		//boolean	add(Object o) 将指定的元素追加到此列表的末尾。 
		linkedList.add("hello");
		linkedList.add(1234);
		linkedList.add(false);
		linkedList.add(12.5);
		linkedList.add("hello");
		//普通的for循环
		for(int i=0;i<linkedList.size();i++) {
			System.out.println(linkedList.get(i));
			}
		System.out.println("________________________");
		//增强的for循环
		for(Object o:linkedList) {
			System.out.println(o);
		   }
		System.out.println("________________________");
		//迭代器
		Iterator  it=linkedList.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

8.5.ArrayList类与LinkedList类的区别
在这里插入图片描述
8.6.HashSet类和LinkedHashSet类的用法
HashSet类–public class HashSet 此类实现Set接口由哈希表支持
HashSet中保存的元素是没有顺序，重复的元素算一个。

package com.set.Test;

import java.util.ArrayList;
import java.util.HashSet;

public class TestHashSet {
	public static void main(String[] args) {
		//HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。
		HashSet set1=new HashSet();
		//HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
		HashSet set2 = new HashSet(set1);
		ArrayList arraylist = new ArrayList();
		HashSet set3 = new HashSet(arraylist);
		//HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）。 
		HashSet set4=new HashSet(20);
		
		//HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 具有指定的初始容量和指定的负载因子。 
		HashSet set5 = new HashSet(20,0.5f);
	}
}

实例方法

package com.set.Test;

import java.util.ArrayList;
import java.util.HashSet;

public class TestHashSet2 {

	public static void main(String[] args) {
		//HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。 
		HashSet  set1=new HashSet();
		//boolean	add(Object e) 将指定的元素添加到此集合（如果尚未存在）。 
		set1.add("hello");
		set1.add(1234);
		set1.add(false);
		set1.add("hello");
		//int	size() 返回此集合中的元素数（其基数）。 
		System.out.println("size=="+set1.size());
		//boolean	contains(Object o) 如果此集合包含指定的元素，则返回 true 。 
		System.out.println("contains=="+set1.contains("hello"));
		//boolean	isEmpty() 如果此集合不包含元素，则返回 true 。 
		System.out.println("isEmpty=="+set1.isEmpty());
		//boolean	remove(Object o) 如果存在，则从该集合中删除指定的元素。
		System.out.println("remove=="+set1.remove("hello"));
		System.out.println("size=="+set1.size());
		//void	clear() 从此集合中删除所有元素。
		set1.clear();
		System.out.println("size=="+set1.size());
	}
}

遍历HashSet

package com.set.Test;
import java.util.HashSet;
import java.util.Iterator;
public class TestHashSet3 {

	public static void main(String[] args) {
		//HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。 
		HashSet  set1=new HashSet();
		//boolean	add(Object e) 将指定的元素添加到此集合（如果尚未存在）。 
		set1.add("hello");
		set1.add(1234);
		set1.add(false);
		set1.add("hello");
		/*
	    for(int i=0;i<set1.size();i++) {
	    	System.out.println(set1.get(i));
	    }
	    */
		 for(Object o:set1) {
		    	System.out.println(o);
		 }
		 System.out.println("_______________");
		 Iterator  it=set1.iterator();
		 while(it.hasNext()) {
			 System.out.println(it.next());
		 }
	}
}

LinkedHashSet类
哈希表和链表实现了Set接口，具有可预测的迭代次序。这种实现不同于HashSet，它维持于所有条目的运行双向链表。
因为LinkedHashSet类是HashSet类的子类，因此会从父类继承集合数据的操作方法。
在这里插入图片描述
实例方法

LinkedHashSet与HashSet区别是HashSet在遍历输出的时候无序，LinkedHashSet在在遍历输出的时候按照插入顺序输出。

8.7.HashMap类和Hashtable类的用法TreeMap与ConcurrentHashMap
Map接口–集合接口–主要处理的是键值对结构的数据
键值对结构的数据—就是一个完成的数据是由键和键所对应的值组合而成的数据
例如:书的目录就是一种键值对结构
【标题----页码】
Map接口下的子类
HashMap类–public class HashMap【基于哈希表的实现的Map接口】
允许null的值和null键
数据保存是无序的
不能有重复的键，重复的键被算作是一个数据。
构造方法
在这里插入图片描述

package com.Test1;

import java.util.HashMap;

public class TestHashMap1 {

	public static void main(String[] args) {
		//HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。 
		HashMap  map1=new HashMap();
		//HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。 
		HashMap  map2=new HashMap(20);
		//HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。 
		HashMap  map3=new HashMap(20,0.5f);
		//HashMap(Map<? extends K,? extends V> m) 构造一个新的 HashMap与指定的相同的映射 Map 。 
		HashMap  map4=new HashMap(map1);

	}

}

实例方法
在这里插入图片描述

package com.Test1;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestHashMap2 {

	public static void main(String[] args) {
		HashMap map1 = new HashMap();
		//Object put(Object key,Object value)想集合中添加键值对数据
		map1.put("id", 1001);
		map1.put(11, "guoguo");
		map1.put("height", "11.5");
		map1.put(11.5, "height");
		map1.put(0, true);
		//不能有重复的键，重复的键被算作一个数据
		//map1.put("id",true);
		//能有重复的值
		map1.put(1,true);
		//键和值都可以为null
		map1.put(null,"test");
		map1.put("java",null);
		//int size()得到集合中键值对元素的个数
		System.out.println("size=="+map1.size());
		System.out.println("---------");
		//boolean containsValue(Object value)判断集合中是否包含指定的值
		System.out.println("containsKey=="+map1.containsKey("zhangsan"));
		System.out.println("---------");
		//boolean	containsValue(Object value) 判断集合中是否包含指定的值
		System.out.println("containsValue=="+map1.containsValue("zhangsan"));
		System.out.println("---------");
		//Object 	get(Object key) 根据指定的键得到该键对应的值
		System.out.println("get=="+map1.get("id"));
		System.out.println("---------");
		//V remove(Object key)根据指定的键删除对应的键值对数据值
		map1.remove(0);
		System.out.println("size=="+map1.size());
		System.out.println("get=="+map1.get(0));
		//Set	keySet() 得到集合中所有的键保存到Set集合中
		Set  keyset=map1.keySet();
		for(Object key:keyset) {
			System.out.println("key===="+key);
		}
		System.out.println("---------");
		//可以使用迭代器来遍历保存有键的set集合
		//Collection	values() 得到集合中所有的值保存到Collection集合中 
		Collection  col=map1.values();
		//使用迭代器来遍历保存有值的Collection集合
		Iterator it=col.iterator();
		while(it.hasNext()) {
			System.out.println("value==="+it.next());
		}
		System.out.println("---------");
		//遍历HashMap集合
		//Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
		Set<Map.Entry<Object,Object>>  mapSet=map1.entrySet();
		for(Map.Entry<Object,Object> entry:mapSet) {
			Object key=entry.getKey();
			Object val=entry.getValue();
			System.out.println(key+":"+val);
		}
	}

}

运行结果
在这里插入图片描述
Hashtable类—public class Hashtable<K,V> 该类实现了一个哈希表，它将键映射到值。
无序
不能有null键/null值
用作键的对象必须实现hashCode方法和equals方法。
不能有重复的键，重复的键被算作是一个数据。
线程安全
构造方法
在这里插入图片描述

package com.Test2;

import java.util.HashMap;
import java.util.Hashtable;

public class TestHashMap1 {

	public static void main(String[] args) {
		//Hashtable() 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。 
		Hashtable  table1=new Hashtable();
		//Hashtable(int initialCapacity) 构造一个新的，空的哈希表，具有指定的初始容量和默认负载因子（0.75）。 
		Hashtable  table2=new Hashtable(30);
		//Hashtable(int initialCapacity, float loadFactor) 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。 
		Hashtable  table3=new Hashtable(30,0.5f);
		//Hashtable(Map<? extends K,? extends V> t) 构造一个与给定地图相同的映射的新哈希表。 
		HashMap  map1=new HashMap();
		Hashtable  table4=new Hashtable(map1);

	}

}

实例方法
在这里插入图片描述

package com.Test2;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestHashMap2 {

	public static void main(String[] args) {
		HashMap map1 = new HashMap();
		//Object put(Object key,Object value)想集合中添加键值对数据
		map1.put("id", 1001);
		map1.put(11, "guoguo");
		map1.put("height", "11.5");
		map1.put(11.5, "height");
		map1.put(0, true);
		//不能有重复的键，重复的键被算作一个数据
		//map1.put("id",true);
		//能有重复的值
		map1.put(1,true);
		//键和值都可以为null
		map1.put(null,"test");
		map1.put("java",null);
		//int size()得到集合中键值对元素的个数
		System.out.println("size=="+map1.size());
		//boolean containsValue(Object value)判断集合中是否包含指定的值
		System.out.println("containsKey=="+map1.containsKey("zhangsan"));
		//boolean	containsValue(Object value) 判断集合中是否包含指定的值
		System.out.println("containsValue=="+map1.containsValue("zhangsan"));
		//Object 	get(Object key) 根据指定的键得到该键对应的值
		System.out.println("get=="+map1.get("id"));
		//V remove(Object key)根据指定的键删除对应的键值对数据值
		map1.remove(0);
		System.out.println("size=="+map1.size());
		System.out.println("get=="+map1.get(0));
		//Set	keySet() 得到集合中所有的键保存到Set集合中
		Set  keyset=map1.keySet();
		for(Object key:keyset) {
			System.out.println("key===="+key);
		}
		//可以使用迭代器来遍历保存有键的set集合
		//Collection	values() 得到集合中所有的值保存到Collection集合中 
		Collection  col=map1.values();
		//使用迭代器来遍历保存有值的Collection集合
		Iterator it=col.iterator();
		while(it.hasNext()) {
			System.out.println("value==="+it.next());
		}
		//遍历HashMap集合
		//Set<Map.Entry<K,V>>	entrySet() 得到集合中所有的键值对数据Set集合中
		Set<Map.Entry<Object,Object>>  mapSet=map1.entrySet();
		for(Map.Entry<Object,Object> entry:mapSet) {
			Object key=entry.getKey();
			Object val=entry.getValue();
			System.out.println(key+":"+val);
		}
	}

}

reeMap类–红黑树基于NavigableMap实现【有序】
ConcurrentHashMap类—线程安全，支持高并发，哈希表
8.8.HashMap类与Hashtable类与TreeMap类与ConcurrentHashMap类的区别
在这里插入图片描述
HashMap底层实现原理
HashMap基于hashing原理，我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，让后找到bucket位置来储存值对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会储存在链表的下一个节点中。 HashMap在每个链表节点中储存键值对对象。当两个不同的键对象的hashcode相同时会发生什么？它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。
在这里插入图片描述

HashTable里使用的是synchronized关键字，这其实是对对象加锁，锁住的都是对象整体，当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。
ConcurrentHashMap使用了分割，将一个map分成多个小的hashtable，对map的一部分进行上锁。保证同步的同时，有提高了性能。
在这里插入图片描述
8.9.认识Collections类【集合类的帮助类】
public class Collections----此类仅由静态方法组合或返回集合
此类中的方法都是静态方法，静态方法为了帮助我们更加方便的操作集合中的数据。

package com.test1;

import java.util.ArrayList;
import java.util.Collections;

public class TestCollections {
	public static void main(String[] args) {
		/*
		//sort(List<T> list) 根据其元素的natural ordering对指定的列表进行排序。
		ArrayList arr1 = new ArrayList();
		arr1.add("zhangsan");
		arr1.add("lisi");
		arr1.add("wangwu");
		arr1.add("zhaoliu");
		Collections.sort(arr1);
		for(Object obj:arr1) {
			System.out.println(obj);
		}
		System.out.println("__________");
		//reverse(List<?> list) 反转指定列表中元素的顺序。
		Collections.reverse(arr1);
		for(Object obj:arr1) {
			System.out.println(obj);
		}
		System.out.println("__________");
		*/
		/*
		ArrayList arr1 = new ArrayList();
		arr1.add(123);
		arr1.add(12);
		arr1.add(1);
		arr1.add(456);
		System.out.println(Collections.max(arr1));	//最大值456
		System.out.println(Collections.min(arr1));	//最小值1
		*/
		ArrayList arr1 = new ArrayList();
		arr1.add("zhangsan");
		arr1.add("lisi");
		arr1.add("wangwu");
		arr1.add("zhaoliu");
		ArrayList arr2 =new ArrayList();
		arr2.add(123);
		arr2.add(12);
		arr2.add(1);
		arr2.add(456);
		for(Object obj:arr2) {
			System.out.println(obj);
		}
		System.out.println("__________");
		Collections.copy(arr2,arr1);
		for(Object obj:arr2) {
			System.out.println(obj);
		}
	}
	
}