JAVA基础8 集合框架

最新推荐文章于 2022-05-27 16:17:50 发布

NNHZNo1

最新推荐文章于 2022-05-27 16:17:50 发布

阅读量89

点赞数

本文链接：https://blog.csdn.net/m0_49585382/article/details/107567814

版权

JAVA基础

8.集合框架

8.1集合框架的体系结构

集合–集中合并数据----文件夹是一个集合的表现
–统一管理/处理数据
框架–jdk提供操作类库
集合框架–jdk提供的对集中合并数据进行统一管理/处理的开发类库。

交由集合统一管理/处理的数据有两种表现形式：
1、单列数据【独立的一个数据–数字，字符串,…】
100 ,”hello”
2、键值对数据【一个数据是由键和建对应的值组成】
书的目录就是一种典型的键值对数据
【标题：页码】

8.2Conllection与Map

1、Collection接口是Jdk提供的处理单列数据的顶级接口。
2、Collection接口的子接口List接口处理有顺序的单列数据。
List接口可以有重复的数据元素，按照顺序区分。
ArrayList类
LinkedList类
3、Collection接口的子接口Set接口处理没有顺序的单列数据。
Set接口不能有重复的数据元素，【重复的元素被视为同一个】
HashSet类
LinkedHashSet类
在这里插入图片描述
Map接口是处理键值对数据的顶级集合接口

8.3List与Set

List和Set是用来存放集合的接口，并且二者都继承自接口Collection。
Collection接口的子接口List接口处理有顺序的单列数据。
List接口可以有重复的数据元素，按照顺序区分。
ArrayList类
LinkedList类
Collection接口的子接口Set接口处理没有顺序的单列数据。
Set接口不能有重复的数据元素，【重复的元素被视为同一个】
HashSet类
LinkedHashSet类

8.4ArrayList与LinkedList

ArrayList类
1.处理有顺序的单列数据
2.保存数据的存储空间，会自动扩展【注意与数组的区别】
3.可以保存任意数据类型的数据【注意与数组的区别】
4.数据存储结构是动态数组结构【优势：查询速度快缺点：添加/删除速度慢】
所属包：java.util
构造方法：
ArrayList() 构造一个初始容量为10的空列表。
ArrayList(Collection c) 将实现Collection接口的集合类转换成ArrayList
ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestMain {
	public static void main(String[] args) {
		//测试ArrayList的构造方法--创建对象
		//ArrayList() 构造一个初始容量为10的空列表。
		ArrayList  list1=new ArrayList();
		//ArrayList(Collection c) 将实现Collection接口的集合类转换成ArrayList
		ArrayList  list2=new ArrayList(list1);
		//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
		ArrayList  list3=new ArrayList(30);
		//可以利用List接口
		List  list11=new ArrayList();
		List  list22=new ArrayList(list11);
		List  list33=new ArrayList(40);
		//可以利用Collection接口
		Collection  list111=new ArrayList();
		Collection  list222=new ArrayList(list111);
		Collection  list333=new ArrayList(50);
	}
}

实例方法
add(E e) 将指定的元素追加到此列表的末尾。
clear() 从列表中删除所有元素。
contains(Object o) 如果此列表包含指定的元素，则返回 true 。
get(int index) 返回此列表中指定位置的元素。
indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
isEmpty() 如果此列表不包含元素，则返回 true 。
remove(int index) 删除该列表中指定位置的元素。
remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
size() 返回此列表中的元素数。
toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组
例如：

package com.click369.test2;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestMain {
	public static void main(String[] args) {
		//ArrayList中的实例方法
		ArrayList list1=new ArrayList();
		//1.add(E e) 将指定的元素追加到此列表的末尾。
		list1.add("hello");
		list1.add(true);
		list1.add(12.5);
		list1.add("hello");
		//2.size() 返回此列表中的元素数。
		System.out.println("list1的元素数="+list1.size());
		//3.clear() 从列表中删除所有元素。[清空]
		//list1.clear();
		//System.out.println("list1的元素数="+list1.size());
		//4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
		System.out.println("判断hello元素是否在list1这个集合中=="+list1.contains("hello1"));
		//5.get(int index) 返回此列表中指定位置的元素。
		//System.out.println("get(5)=="+list1.get(5));
		//6.indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
		System.out.println("hello元素在list1中第一次出现的位置=="+list1.indexOf("hello"));
		//7.lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
		System.out.println("hello元素在list1中最后一次出现的位置=="+list1.lastIndexOf("hello"));
		//8.isEmpty() 如果此列表不包含元素，则返回 true 。
		//list1.clear();
		//System.out.println("list1集合是否为空="+list1.isEmpty());
		//9.remove(int index) 删除该列表中指定位置的元素。 
		//list1.remove(2);
		//System.out.println("list1的元素数="+list1.size());
		//10.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		//list1.remove("hello");
		//System.out.println("list1的元素数="+list1.size());
		//System.out.println("get(0)=="+list1.get(0));
		//11.set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
		list1.set(0,"world");
		System.out.println("get(0)=="+list1.get(0));
		//12.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
		Object[] objs=list1.toArray();
	}
}

Iterator iterator() 以正确的顺序返回该列表中的元素的迭代器接口。【遍历ArrayList中的数据元素】
ArrayList集合的遍历
例如：

package com.click369.test3;
import java.util.ArrayList;
import java.util.Iterator;
public class TestMain {
	public static void main(String[] args) {
		//ArrayList集合的遍历
		ArrayList  list=new ArrayList();
		list.add("hello");
		list.add(1001);
		list.add("world");
		list.add(true);
		list.add(12.5);
		//1.通过普通的for循环遍历ArrayList集合
		for(int i=0;i<list.size();i++){
			System.out.println("list---"+list.get(i));
		}
		//2、使用增强的for循环
		for(Object obj:list){
			System.out.println("obj---"+obj);
		}
		//3.使用Iterator  iterator()迭代器
		Iterator it=list.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			System.out.println("Iterator---"+obj);
		}
	}
}

LinkedList类
1.处理有顺序的单列数据
2.保存数据的存储空间，会自动扩展【注意与数组的区别】
3.可以保存任意数据类型的数据【注意与数组的区别】
4.数据存储结构是链表【火车】结构【优势：添加/删除速度快缺点：查询速度慢】

构造方法：
LinkedList() 构造一个空列表。
LinkedList(Collection c) 将实现Collection接口的集合类转换成LinkedList
例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
public class TestMain {
	public static void main(String[] args) {
		//测试LinkedList的构造方法--创建对象
		//LinkedList() 构造一个空列表。
		LinkedList  list1=new LinkedList();
		//LinkedList(Collection c) 将实现Collection接口的集合类转换成LinkedList
		ArrayList  alist=new ArrayList();
		LinkedList  list2=new LinkedList(alist);
		//可以利用List接口
		List  list11=new LinkedList();
		List  list22=new LinkedList(list11);
		//可以利用Collection接口
		Collection  list111=new LinkedList();
		Collection  list222=new LinkedList(list111);
	}
}

实例方法与ArrayList一样：
add(E e) 将指定的元素追加到此列表的末尾。
clear() 从列表中删除所有元素。
contains(Object o) 如果此列表包含指定的元素，则返回 true 。
get(int index) 返回此列表中指定位置的元素。
indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
isEmpty() 如果此列表不包含元素，则返回 true 。
remove(int index) 删除该列表中指定位置的元素。
remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
size() 返回此列表中的元素数。
toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组

LinkedList类提供了一组针对第一个元素和最后一个元素的操作方法：
addFirst(E e) 在该列表开头插入指定的元素。
addLast(E e) 将指定的元素追加到此列表的末尾
getFirst() 返回此列表中的第一个元素。
getLast() 返回此列表中的最后一个元素。
removeFirst() 从此列表中删除并返回第一个元素。
removeLast() 从此列表中删除并返回最后一个元素。
因为LinkedList类的数据存储结构是链表【火车】结构

例如：

package com.click369.test2;
import java.util.LinkedList;
public class TestMain {
	public static void main(String[] args) {
		//LinkedList中的实例方法
		LinkedList list1=new LinkedList();
		//1.add(E e) 将指定的元素追加到此列表的末尾。
		list1.add("hello");
		list1.add(true);
		list1.add(12.5);
		list1.add("hello");
		//2.size() 返回此列表中的元素数。
		//System.out.println("list1的元素数="+list1.size());
		//3.clear() 从列表中删除所有元素。[清空]
		//list1.clear();
		//System.out.println("list1的元素数="+list1.size());
		//4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
		//System.out.println("判断hello元素是否在list1这个集合中=="+list1.contains("hello"));
		//5.get(int index) 返回此列表中指定位置的元素。
		//System.out.println("get(2)=="+list1.get(2));
		//6.indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
		//System.out.println("hello元素在list1中第一次出现的位置=="+list1.indexOf("hello"));
		//7.lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
		//System.out.println("hello元素在list1中最后一次出现的位置=="+list1.lastIndexOf("hello"));
		//8.isEmpty() 如果此列表不包含元素，则返回 true 。
		//list1.clear();
		//System.out.println("list1集合是否为空="+list1.isEmpty());
		//9.remove(int index) 删除该列表中指定位置的元素。 
		//list1.remove(2);
		//System.out.println("list1的元素数="+list1.size());
		//10.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		//list1.remove("hello");
		//System.out.println("list1的元素数="+list1.size());
		//System.out.println("get(0)=="+list1.get(0));
		//11.set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
		//list1.set(0,"world");
		//System.out.println("get(0)=="+list1.get(0));
		//12.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
		//Object[] objs=list1.toArray();
		
		//LinkedList类提供了一组针对第一个元素和最后一个元素的操作方法：
		//addFirst(E e) 在该列表开头插入指定的元素。
		//addLast(E e) 将指定的元素追加到此列表的末尾
		//getFirst() 返回此列表中的第一个元素。 
		//getLast() 返回此列表中的最后一个元素。
		//removeFirst() 从此列表中删除并返回第一个元素。
		//removeLast() 从此列表中删除并返回最后一个元素。
		//因为LinkedList类的数据存储结构是链表【火车】结构
	}
}

LinkedList集合的遍历

package com.click369.test3;
import java.util.Iterator;
import java.util.LinkedList;
public class TestMain {
	public static void main(String[] args) {
		//LinkedList集合的遍历
		LinkedList  list=new LinkedList();
		list.add("hello");
		list.add(1001);
		list.add("world");
		list.add(true);
		list.add(12.5);
		//1.通过普通的for循环遍历ArrayList集合
		for(int i=0;i<list.size();i++){
			System.out.println("list---"+list.get(i));
		}
		//2、使用增强的for循环
		for(Object obj:list){
			System.out.println("obj---"+obj);
		}
		//3.使用Iterator  iterator()迭代器
		Iterator it=list.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			System.out.println("Iterator---"+obj);
		}
	}
}

8.5HashSet与LinkedHashSet

HashSet类
1.处理的是没有顺序的单列数据【重复的元素算一个】
2.保存数据的存储空间，会自动扩展。
3.可以保存任意数据类型的数据。
构造方法：
HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
HashSet(Collection c)将实现Collection 接口的集合类转换成HashSet
HashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。
HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子
例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
public class TestMain {
	public static void main(String[] args) {
		//测试HashSet的构造方法--创建对象
		//HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
		HashSet set1=new HashSet();
		//HashSet(Collection c)将实现Collection 接口的集合类转换成HashSet
		ArrayList list=new ArrayList();
		HashSet	set2=new HashSet(list);	
		//HashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。 
		HashSet set3=new HashSet(10);
		//HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子
		HashSet set4=new HashSet(10,0.5f);
		//可以使用Set接口
		Set set11=new  HashSet();
		Set set22=new  HashSet(list);
		Set set33=new  HashSet(30);
		Set set44=new  HashSet(40,0.5f);
		//可以使用Collection接口
		Collection set111=new  HashSet();
		Collection set222=new  HashSet(list);
		Collection set333=new  HashSet(30);
		Collection set444=new  HashSet(40,0.5f);
	}
}

实例方法：
add(E e) 将指定的元素添加到此集合。
clear() 从此集合中删除所有元素。
contains(Object o) 如果此集合包含指定的元素，则返回 true 。
isEmpty() 如果此集合不包含元素，则返回 true 。
remove(Object o) 如果存在，则从该集合中删除指定的元素。
size() 返回此集合中的元素数。
toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组

例如：

package com.click369.test2;
import java.util.HashSet;
public class TestMain {
	public static void main(String[] args) {
		//HashSet中的实例方法
		HashSet set1=new HashSet();
		//1.add(E e) 将指定的元素追加到此列表的末尾。
		set1.add("hello");
		set1.add(true);
		set1.add(12.5);
		set1.add("hello");
		//2.size() 返回此列表中的元素数。
		//System.out.println("set1的元素数="+set1.size());
		//3.clear() 从列表中删除所有元素。[清空]
		//set1.clear();
		//System.out.println("set1的元素数="+set1.size());
		//4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
		System.out.println("判断hello元素是否在set1这个集合中=="+set1.contains("hello"));
		//5.isEmpty() 如果此列表不包含元素，则返回 true 。
		//set1.clear();
		//System.out.println("set1集合是否为空="+set1.isEmpty());
		//6.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		set1.remove("hello");
		System.out.println("set1的元素数="+set1.size());
		//7.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
		Object[] objs=set1.toArray();
	}
}

HashSet集合的遍历

package com.click369.test3;
import java.util.HashSet;
import java.util.Iterator;
public class TestMain {
	public static void main(String[] args) {
		//HashSet集合的遍历
		HashSet  set=new HashSet();
		set.add("hello");
		set.add(1001);
		set.add("world");
		set.add(true);
		set.add(12.5);
		//1、使用增强的for循环
		for(Object obj:set){
			System.out.println("obj---"+obj);
		}
		//2.使用Iterator  iterator()迭代器
		Iterator it=set.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			System.out.println("Iterator---"+obj);
		}
	}
}

LinkedHashSet类
定义结构：
public class LinkedHashSet
extends HashSet
implements Set,

LinkedHashSet是HashSet类的子类
只要会使用HashSet，那么就一定会使用LinkedHashSet。

构造方法：
LinkedHashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
LinkedHashSet(Collection c)将实现Collection 接口的集合类转换成LinkedHashSet
LinkedHashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。
LinkedHashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的
实例方法：
add(E e) 将指定的元素添加到此集合。
clear() 从此集合中删除所有元素。
contains(Object o) 如果此集合包含指定的元素，则返回 true 。
isEmpty() 如果此集合不包含元素，则返回 true 。
remove(Object o) 如果存在，则从该集合中删除指定的元素。
size() 返回此集合中的元素数。
iterator() 返回此集合中元素的迭代器。

8.6HashMap与Hashtable与TreeMap与ConcurrentHashMap

java中的集合框架主要处理两类数据值
1.单列数据值—这个数据值是由一个具体的数据值组成
例如： 100 “hello”
2.键值对数据值-- 这个数据值是键和值两部分组成的一个数据值
例如：书的目录就是一个典型的键值对数据值
标题-------页码【键值对】
Java的数据类型------------10
Java中处理键值对数据的集合框架
Map接口是处理键值对数据的顶级集合接口。
HashMap类
Hashtable类

HashMap类
1.可以处理键值对数据
2.保存键值对数据的存储空间会自动扩展。
3.所保存的键值对数据可以为null.[1.null=”sss” 2. “sss”=null 3. null=null]
4.保存的键值对数据是无序的。
5.不能有重复的键【重复的键算一个数据】
标题=页码
【键】=【值】

构造方法：
HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。
HashMap(Map m) 将实现Map接口的集合类转换成HashMap
例如：

package com.click369.test1;
import java.util.HashMap;
import java.util.Map;
public class TestMain {
	public static void main(String[] args) {
		//HashMap的构造方法--创建对象
		//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(30,0.5f);
		//HashMap(Map m) 将实现Map接口的集合类转换成HashMap
		HashMap map4=new HashMap(map1);
		//可以利用Map接口
		Map  map11=new HashMap();
		Map  map22=new HashMap(20);
		Map  map33=new HashMap(30,0.5f);
		Map  map44=new HashMap(map33);
	}
}

HashMap常用的实例方法：
put(K key, V value) 添加键值对数据。
size() 得到集合中键值对元素的个数。
isEmpty() 判断集合书否为空
clear() 清空集合。
containsKey(Object key) 判断指定的键数据在集合中是否存在。
containsValue(Object value) 判断指定的值数据在集合中是否存在。
get(Object key)根据指定的键数据得到与这个键对应的值数据。
remove(Object key)根据指定的键数据删除整个键值对数据。
replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
例如：

package com.click369.test2;
import java.util.HashMap;
import java.util.Map;
public class TestMain {
	public static void main(String[] args) {
		//HashMap的实例方法
		HashMap map1=new HashMap();
		//1.put(K key, V value) 添加键值对数据。 
		//键或者值都可以是任意数据类型
		map1.put("hello", 1001);
		map1.put(1002,"world");
		map1.put(true, 12.5);
		map1.put(120.5, false);
		//所保存的键值对数据可以为null.
		//map1.put(null, "test"); //键为null，值不为null
		//map1.put("test",null); //键不为null，值为null
		//map1.put(null,null); ///键为null，值为null
		//不能有重复的键【重复的键算一个数据】
		//map1.put("java","test1");
		//map1.put("java","test2");
		//2.size() 得到集合中键值对元素的个数。 
		System.out.println("map1集合键值对元素的个数=="+map1.size());
		//3.isEmpty() 判断集合是否为空 
		System.out.println("map1集合判断集合是否为空=="+map1.isEmpty());
		//4.clear() 清空集合。 
		//5.containsKey(Object key) 判断指定的键数据在集合中是否存在。
		System.out.println("判断指定的键数据在集合中是否存在=="+map1.containsKey("hello"));
		//6.containsValue(Object value) 判断指定的值数据在集合中是否存在 。
		System.out.println("判断指定的值数据在集合中是否存在=="+map1.containsValue("hello"));
		//7.get(Object key)根据指定的键数据得到与这个键对应的值数据。
		System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get("hello"));
		//8.remove(Object key)根据指定的键数据删除整个键值对数据。
		//map1.remove(true);
		//System.out.println("map1集合键值对元素的个数=="+map1.size());
		//System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(true));
		//9.replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
		System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(1002));
		map1.replace(1002, "world", "hello");
		System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(1002));
	}
}

遍历键值对对集合：
Set keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
Collection values() 得到键值对集合中所有键值对数据的键数据保存到Collection集合中
Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
例如：

public static void main(String[] args) { 
		HashMap  map=new	HashMap();
		map.put(100,"zhangsan");
		map.put(12.5,true);
		map.put("test",1000);
		map.put(false,168.5);
		//Set<K>  keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
		Set  keyset=map.keySet();
		for(Object  objkey:keyset){
			System.out.println("key==="+objkey);
		}	

		//Collection<V> values() 得到键值对集合中所有键值对数据的键数据保存到Collection<V>集合中
		Collection  vals=map.values();
		for(Object  objvalue:vals){
			System.out.println("value==="+objvalue);
		}	

		//Set<Map.Entry<K,V>>  entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
		Set   k_v_set=map.entrySet();
		for(Object obj:k_v_set){
			System.out.println(obj);
		}
	
		//遍历Map集合的方法
		HashMap<String,String>  testmap=new	HashMap<String,String>();
		testmap.put("name","zhangsan");
		testmap.put("pass","123456");
		testmap.put("address","西安");
		for(Map.Entry<String,String>  entry:testmap.entrySet()){
			//System.out.println("mykey=="+entry.getKey());
			//System.out.println("myvalue=="+entry.getValue());
			System.out.println("k-v=="+entry.getKey()+":"+entry.getValue());
		}
	}

Hashtable类
1.可以处理键值对数据
2.保存键值对数据的存储空间会自动扩展。
3.不允许null出现
4.不能有重复的键【重复的键算一个数据】
5.保存的键值对数据是无序的。
构造方法：
Hashtable() 构造一个空的 Hashtable，默认初始容量（11）和默认负载系数（0.75）。
Hashtable(int initialCapacity) 构造一个空的 Hashtable具有指定的初始容量和默认负载因子（0.75）。
Hashtable(int initialCapacity, float loadFactor) 构造一个空的 Hashtable具有指定的初始容量和负载因子。
Hashtable(Map m) 将实现Map接口的集合类转换成Hashtable
例如：

package com.click369.test1;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class TestMain {
	public static void main(String[] args) {
		//Hashtable的构造方法--创建对象
		//Hashtable() 构造一个空的 Hashtable ，默认初始容量（11）和默认负载系数（0.75）。 
		Hashtable  table1=new Hashtable();
		//Hashtable(int initialCapacity) 构造一个空的 Hashtable具有指定的初始容量和默认负载因子（0.75）。
		Hashtable table2=new Hashtable(20);
		//Hashtable(int initialCapacity, float loadFactor) 构造一个空的 Hashtable具有指定的初始容量和负载因子。
		Hashtable table3=new Hashtable(30,0.5f);
		//Hashtable(Map m) 将实现Map接口的集合类转换成Hashtable
		HashMap map4=new HashMap();
		Hashtable table4=new Hashtable(map4);
		//可以利用Map接口
		Map  table11=new Hashtable();
		Map  table22=new Hashtable(20);
		Map  table33=new Hashtable(30,0.5f);
		Map  table44=new Hashtable(table33);
	}
}

实例方法：
put(K key, V value) 添加键值对数据。
size() 得到集合中键值对元素的个数。
isEmpty() 判断集合书否为空
clear() 清空集合。
containsKey(Object key) 判断指定的键数据在集合中是否存在。
containsValue(Object value) 判断指定的值数据在集合中是否存在。
get(Object key)根据指定的键数据得到与这个键对应的值数据。
remove(Object key)根据指定的键数据删除整个键值对数据。
replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
例如：

package com.click369.test2;
import java.util.Hashtable;
public class TestMain {
	public static void main(String[] args) {
		//Hashtable的实例方法
		Hashtable table1=new Hashtable();
		//1.put(K key, V value) 添加键值对数据。 
		//键或者值都可以是任意数据类型
		table1.put("hello", 1001);
		table1.put(1002,"world");
		table1.put(true, 12.5);
		table1.put(120.5, false);
		//不允许null出现
		//table1.put(null, "test"); 
		//table1.put("test",null); 
		//不能有重复的键【重复的键算一个数据】
		//table1.put("java","test1");
		//table1.put("java","test2");
		//2.size() 得到集合中键值对元素的个数。 
		System.out.println("table1集合键值对元素的个数=="+table1.size());
		//3.isEmpty() 判断集合是否为空 
		System.out.println("table1集合判断集合是否为空=="+table1.isEmpty());
		//4.clear() 清空集合。 
		//5.containsKey(Object key) 判断指定的键数据在集合中是否存在。
		System.out.println("判断指定的键数据在集合中是否存在=="+table1.containsKey("hello"));
		//6.containsValue(Object value) 判断指定的值数据在集合中是否存在 。
		System.out.println("判断指定的值数据在集合中是否存在=="+table1.containsValue("hello"));
		//7.get(Object key)根据指定的键数据得到与这个键对应的值数据。
		System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get("hello"));
		//8.remove(Object key)根据指定的键数据删除整个键值对数据。
		table1.remove(true);
		System.out.println("table1集合键值对元素的个数=="+table1.size());
		System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(true));
		//9.replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
		System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(1002));
		table1.replace(1002, "world", "hello");
		System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(1002));
	}
}

遍历兼职对集合：
Set keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
Collection values() 得到键值对集合中所有键值对数据的键数据保存到Collection集合中
Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
例如：

package com.click369.test3;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestMain {
	public static void main(String[] args) {
		//Hashtable的遍历
		Hashtable<Object,Object> table1=new Hashtable<Object,Object>();
		table1.put("hello", 1001);
		table1.put(1002,"world");
		table1.put(true, 12.5);
		table1.put(120.5, false);
		//遍历所有的键数据
		//Set<K>  keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
		Set set1=table1.keySet();
		for(Object obj:set1){
			System.out.println("key=="+obj);
		}
		//使用迭代器遍历键数据对饮的set集合
		Iterator keyit=set1.iterator();
		while(keyit.hasNext()){
			System.out.println("keyit=="+keyit.next());
		}
		//遍历所有的值数据
		//Collection<V> values() 得到键值对集合中所有键值对数据的键数据保存到Collection<V>集合中
		Collection coll=table1.values();
		for(Object val:coll){
			System.out.println("value=="+val);
		}
		//使用迭代器遍历键数据对饮的set集合
		Iterator valit=coll.iterator();
		while(valit.hasNext()){
					System.out.println("valit=="+valit.next());
		}
		//遍历所有的键和值数据
		//Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
		//注意：HashMap<Object,Object> map1=new HashMap<Object,Object>();
		for(Map.Entry<Object,Object> entry : table1.entrySet()){
			Object k=entry.getKey();
			Object v=entry.getValue();
			System.out.println(k+"="+v);
		}
	}
}

在这里插入图片描述

8.7Conllection与Conllections

Collection是集合类的上级接口，继承与他有关的接口主要有List和Set
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作
Collection接口
1、Collection接口是Jdk提供的处理单列数据的顶级接口。
2、Collection接口的子接口List接口处理有顺序的单列数据。
List接口可以有重复的数据元素，按照顺序区分。
ArrayList类
LinkedList类
3、Collection接口的子接口Set接口处理没有顺序的单列数据。
Set接口不能有重复的数据元素，【重复的元素被视为同一个】
HashSet类
LinkedHashSet类
Collections类 【集合操作类的辅助类】
提供对集合进行操作的查询，复制，排序，线程安全操作的一系列静态方法
集合操作类的辅助类，与数组的辅助类【Arrays】相似。
例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collections;
public class TestMain {
	public static void main(String[] args) {
		//Collections类
		//是集合操作类的辅助类
		//提供了一组操作集合的静态方法【查询集合元素，复制集合中的元素进入另一个集合，为集合中的元素排序...】
		ArrayList list1=new ArrayList();
		list1.add("zhangsan");
		list1.add("lisi");
		list1.add("Lisi");
		list1.add("zhaoliu");
		//static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 返回给定集合的最大元素。  
		Object  max=Collections.max(list1);
		System.out.println(max);
		//static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 返回给定集合的最小元素。  
		Object  min=Collections.min(list1);
		System.out.println(min);
		System.out.println("------------------------");
		System.out.println("没有排序之前");
		for(Object obj:list1){
			System.out.println("没有排序之前=="+obj);
		}
		System.out.println("------------------------");
		// sort(List<T> list) 对指定的列表进行排序。
		Collections.sort(list1);
		System.out.println("排序之后");
		for(Object obj:list1){
			System.out.println("排序之后=="+obj);
		}
		//static <T> void copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另一个列表中,会覆盖目标列表中的对应数据元素。  
		//注意：目标集合的元素个数  >= 源集合的元素个数 ，否则java.lang.IndexOutOfBoundsException: Source does not fit in dest
		ArrayList list2=new ArrayList();
		list2.add(234);
		list2.add(547);
		list2.add(13);
		list2.add(464);
		list2.add(4565);
		list2.add(6579823);
		Collections.copy(list2, list1);
		for(Object obj:list2){
			System.out.println("list2=="+obj);
		}
	}
}

NNHZNo1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础8 集合框架

JAVA基础8.集合框架8.1集合框架的体系结构集合–集中合并数据----文件夹是一个集合的表现–统一管理/处理数据框架–jdk提供操作类库集合框架–jdk提供的对集中合并数据进行统一管理/处理的开发类库。交由集合统一管理/处理的数据有两种表现形式：1、单列数据【独立的一个数据–数字，字符串,…】100 ,”hello”2、键值对数据【一个数据是由键和建对应的值组成】书的目录就是一种典型的键值对数据【标题：页码】Jdk提供的处理单列数据的开发类库1、Collection接口是J
复制链接

扫一扫