十五、Java集合框架

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量1k 收藏 6
点赞数 2
分类专栏： JavaSE-上 文章标签： java 经验分享 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49576031/article/details/121301469
版权

集合框架：Java做好的用来管理乱七八糟 的一堆数据的Java库。

集合：[一堆东西]；

框架：做好Java类库。

1.Java中集合框架总体分为2个大部分

Collection接口  和 Map接口。

Collection单列数据

Collection接口下面有两个子接口 List/Set接口

List接口是用来处理有序的单列数据的，可以有重复的元素

Set是一个无序的单列数据，不可以重复元素。

1.List接口

是用来处理有序的单列数据，可以有重复的元素。

ArrayList类

1.用来处理有序的单列数据，可以有重复的数据。

2.添加的元素会自动扩展

3.动态数组的结构，查询快，添加删除比较慢。

LinkedList类

1.用来处理有序的单列数据，可以有重复的元素。

2.添加元素会自动扩展

3.双向链表结构，查询速度慢，添加删除速度快

Set接口

是用来处理无序的单列数据，没有重复的元素,重复的元素算一个。

HashSet类

用来处理无序的单列数据，没有重复的元素,重复的元素算一个。

LinkedHashSet类

用来处理无序的单列数据，没有重复的元素,重复的元素算一个。

Map接口

第二个大部分是用来处理键值对数据的集合,最大的接口是Map接口

例如: name[键]=zhangsan[值]   输的目录

HashMap类

1.用来处理键值对数据的集合

2.允许有null【键--null  值--null】

Hashtable类

1.用来处理键值对数据的集合

2.不允许有null

ConcurrentHashMap类

支持检索的完全并发性和更新的高预期并发性的哈希表

2.关于List接口下的常用类

1)ArrayList类

特点：

(1)用来处理有序的单列数据，可以有重复的元素。

(2)添加的元素会自动扩展。

(3)动态数组结构，查询速度快，添加删除速度慢。

构造方法:

ArrayList() 构造一个初始容量为10的空列表。

ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表。

ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。

例子：

//1.无参构造方法

ArrayList<Object> arrlist = new ArrayList<Object>();

//2,控制初始容量

ArrayList<Object> arraylist1 = new ArrayList<Object>();

//3.Collection接口的子类间的转换

HashSet<Object> test  = new HashSet<Object>();

ArrayList<Object> arrayList3 = new ArrayList<Object>(test);

实例方法:

返回值

方法结构

作用

boolean

add(Object o)

将指定的元素追加到此列表的末尾。

boolean

contains(Object o)

如果此列表包含指定的元素，则返回 true 。

Object

get(int index)

返回此列表中指定位置的元素。

int

indexOf(Object o)

返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

int

lastIndexOf(Object o)

返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

Object

remove(int index)

删除该列表中指定位置的元素。

boolean

remove(Object o)

 从列表中删除指定元素的第一个出现（如果存在）。

Object 

set(int index,Object  element)

用指定的元素替换此列表中指定位置的元素。

int

size()

返回此列表中的元素数。

boolean

isEmpty()

如果此列表不包含元素，则返回 true 。

void

clear()

从列表中删除所有元素。

Iterator<E>

iterator()

 以正确的顺序返回该列表中的元素的迭代器。

例子：

package com20211111;

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

public class ArrayListTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.无参构造方法
		ArrayList<Object> arrlist = new ArrayList<Object>();
		//2,控制初始容量
		ArrayList<Object> arraylist1 = new ArrayList<Object>();
		//3.Collection接口的子类间的转换
		HashSet<Object> test  = new HashSet<Object>();
		ArrayList<Object> arrayList3 = new ArrayList<Object>(test);
		
		
		/**
		 * 实例方法
		 * */
		//1.add进行添加
		arrlist.add("张三");
		arrlist.add(null);
		arrlist.add(18);
		arrlist.add(true);
		arrlist.add(18);
		
		System.out.println(arrlist.size());
		arrlist.remove(true);
		//2.size查看元素的个数
		System.out.println("size方法查询元素的个数==" + arrlist.size());
		//3.contains元素是否包含指定的元素
		System.out.println("contains方法判断是否存在对应的元素" + arrlist.contains(18));
		//4.get通过位置/索引获取指定的元素，arrlist是有序的单列表。
		System.out.println("get通过整数下标获取对应的元素" + arrlist.get(0));
		System.out.println("get通过整数下标获取对应的元素"  + arrlist.get(arrlist.size()-1));
		
		//5.indexOf 和lastIndexOf
		System.out.println("和String中的indexOf一样，查询元素，返回元素的下标:" + arrlist.indexOf(18));
		System.out.println("和String中的indexOf一样，从末查询元素，返回元素的下标:" + arrlist.lastIndexOf(18));
		
		//6reomve通过下标删除列表中的元素 也可以通过元素删除元素
		/*
		arrlist.remove(1);
		Integer a = 18; 
		arrlist.remove(a);
		System.out.println("列表的长度" + arrlist.size());
		*/
		
		//7set替换指定位置的元素通过第二个参数替换
		arrlist.set(2, 20);
		//8isEmpty判断是否为空
		
		System.out.println("isEmpty判断列表是否为空" + arrlist.isEmpty());
		System.out.println("isEmpty判断列表是否为空" + arraylist1.isEmpty());
		//9.clear清除列表
		
		//arrlist.clear();
		System.out.println("列表的长度为：" + arrlist.size());
		
		
		//10遍历列表的方式
		//		(1) 通过arrayList中的迭代方法，返回一个迭代器进行对列表的遍历
		System.out.println("-------------遍历列表1");
		Iterator<Object> ites = arrlist.iterator();
		while (ites.hasNext()) {
			System.out.println(ites.next());
		}
		//(2)通过普通for循环遍历
		System.out.println("-------------遍历列表2");
		for (int i = 0,le = arrlist.size(); i < le; i++) {
			System.out.println(arrlist.get(i));
		}
		//通过for增强
		System.out.println("-------------遍历列表3");
		for (Object object :arrlist) {
			System.out.println(object);
		}
	}
}

2)LinkedList类（无初始大小）

特点

(1)用来处理有序的单列数据，可以重复元素。

(2).添加的元素会自动扩展。

(3)双向链表结构，查询慢，添加删除快。

构造方法：

1.LinkedList() ：构造一个空列表。 （没有默认长度）

2. LinkedList(Collection c)：通过一个实现Collection接口的子类/子接口对象创建一个列表（Collection的子类之间相互转换）

public static void main(String[] args) {

// TODO Auto-generated method stub

//构造方法

//1.无参构造函数  创建一个空列表

LinkedList<Object> linkedList  = new LinkedList<Object>();

//2.通过Collect结构的子类/子接口对象穿件一个列表  说白了  就是转换
ArrayList<Object> arrlink = new ArrayList<Object>();

LinkedList<Object> linkedList1 = new LinkedList<Object>(arrlink);

}

实例方法

返回值

方法结构

作用

boolean

add(Object o)

将指定的元素追加到此列表的末尾。

boolean

contains(Object o)

如果此列表包含指定的元素，则返回 true 。

Object

get(int index)

返回此列表中指定位置的元素。

int

indexOf(Object o)

返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

int

lastIndexOf(Object o)

返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

Object

remove(int index)

删除该列表中指定位置的元素。

boolean

remove(Object o)

 从列表中删除指定元素的第一个出现（如果存在）。

Object 

set(int index,Object  element)

用指定的元素替换此列表中指定位置的元素。

int

size()

返回此列表中的元素数。

boolean

isEmpty()

如果此列表不包含元素，则返回 true 。

void

clear()

从列表中删除所有元素。

Iterator<E>

iterator()

 以正确的顺序返回该列表中的元素的迭代器。

Object 

getFirst()

返回此列表中的第一个元素。

Object

getLast()

返回此列表中的最后一个元素。

Object 

removeFirst()

 从此列表中删除并返回第一个元素。

Object 

removeLast()

从此列表中删除并返回最后一个元素。

为什么LinkedList会比ArrayList多出一组对第一个元素和最后一个元素的操作方法？

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

例子：

import java.util.ArrayList;
import java.util.LinkedList;

public class LinkedListTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//构造方法
		//1.无参构造函数  创建一个空列表
		LinkedList<Object> linkedList  = new LinkedList<Object>();
		
		//2.通过Collect结构的子类/子接口对象穿件一个列表  说白了  就是转换
		ArrayList<Object> arrlink = new ArrayList<Object>();
		LinkedList<Object> linkedList1 = new LinkedList<Object>(arrlink);
		
        //测试方法
		linkedList.add("张三");
		linkedList.add(null);
		linkedList.add("18");
		linkedList.add(true);
		linkedList.add(18);
		linkedList.add(18);
		System.out.println("元素的个数为1111："+linkedList.size());
        //linkedList.remove(true);
		
        //Boolean c= new Boolean(true);
		Boolean c = true;
		linkedList.remove(c);
		//查看元素的个数size
		System.out.println("元素的个数为2222："+linkedList.size());
		
		//删除元素
		//		1.通过下标删除元素
		//linkedList.remove(5);
		System.out.println("元素的个数为："+linkedList.size());
		//		2.通过元素删除列表中的元素
		//linkedList.remove("张三");
		System.out.println("元素的个数为："+linkedList.size());
		
		//3.set通过索引修改对应的值
		linkedList.set(0,"李四");
		//4.通过；列表的下标获取值
		System.out.println(linkedList.get(0));
		
		//5判断是否为空
		System.out.println("列表是否为空："+linkedList.isEmpty());
		
		//6清除列表
		//linkedList.clear();
		System.out.println(linkedList.size());
		
		//7.indexOf 或者 lastIndexOf 通过元素获取下标，没有找到返回-1
		//1.indeOf从前往后
		System.out.println(linkedList.indexOf(18));
		//2.lastIndexOf从后往前
		System.out.println(linkedList.lastIndexOf(18));
		
    /**Linkedlsit类特有的四个方法*/
    //1获取第一个元素
		System.out.println("第一个元素是--" + linkedList.getFirst());
    //2.获取最后一个元素
		System.out.println("最后一个元素是--" + linkedList.getLast());
    //3.删除第一个元素
		System.out.println(linkedList.removeFirst());
    //3.删除最后一个元素
		System.out.println(linkedList.removeLast());
		System.out.println("第一个元素是--" + linkedList.getFirst());
		System.out.println("最后一个元素是--" + linkedList.getLast());
		
	}
}

3.关于Set接口的常用类

1.数据是单列的、没有顺序的。（没有索引）

2.没有重复的元素，重复的元素算一个。

1.HashSet类

用来处理无序的单列数据，没有重复的元素,重复的元素算一个。

构造方法：

  1. HashSet（）无惨构造函数，构建一个新的空集合，默认大小（16）和0.75的负载因子。
  2. HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。 （就是Collection子类得相互转换）
  3. HashSet(int initialCapacity)构造一个指定大小的空集合，负载因子默认为0.75不变。
  4. HashSet(int initialCapacity,float loadFactor)指定大小，指定的负载因子（float 小数+f）

例子：

//构造函数
//1.无参数的构造方法 默认大小为16.负载因子为0.75
HashSet<Object> hashSet = new HashSet<Object>();
//2有初始容两个大小，但是没有设置负载因子
HashSet<Object> hashSet2 = new HashSet<Object>(10);
		
//3可以设置初始大小、负载因子(float类型)
HashSet<Object> hashSet3 = new HashSet<>(12,0.5f);
		
//4传递Collection的参数进行转换成HashSet
LinkedList<Object> linklist = new LinkedList<Object>();
HashSet<Object> hashSet4 = new HashSet<Object>(linklist);;

事例方法：

返回值

方法结构

作用

boolean

add(Object o)

将指定的元素追加到此列表的末尾。

boolean

contains(Object o)

如果此列表包含指定的元素，则返回 true 。

boolean

remove(Object o)

 从列表中删除指定元素的第一个出现（如果存在）。

int

size()

返回此列表中的元素数。

boolean

isEmpty()

如果此列表不包含元素，则返回 true 。

void

clear()

从列表中删除所有元素。

Iterator<E>

iterator()

 以正确的顺序返回该列表中的元素的迭代器。

例子：

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

public class HashSetTest {
	public static void main(String[] args) {
		//构造函数
		//1.无参数的构造方法 默认大小为16.负载因子为0.75
		HashSet<Object> hashSet = new HashSet<Object>();
		//2有初始容两个大小，但是没有设置负载因子
		HashSet<Object> hashSet2 = new HashSet<Object>(10);
		
		//3可以设置初始大小、负载因子(float类型)
		HashSet<Object> hashSet3 = new HashSet<>(12,0.5f);
		
		//4传递Collection的参数进行转换成HashSet
		LinkedList<Object> linklist = new LinkedList<Object>();
		HashSet<Object> hashSet4 = new HashSet<Object>(linklist);
		
		//事例方法
		//1.添加元素
		hashSet.add("张三");
		hashSet.add(18);
		hashSet.add(true);
		System.out.println(hashSet.size());
		Boolean a = true;
		hashSet.remove(a);
		System.out.println(hashSet.size());
		hashSet.add(null);
		hashSet.add("张三");
		//2.删除元素
		System.out.println("当前Hashset的元素个数为" + hashSet.size());
		//4.remove删除元素
		hashSet.remove("张三");
		System.out.println("当前Hashset的元素个数为" + hashSet.size());
		//5.清空哈希列表
//		hashSet.clear();
		//6.清空哈希表
		hashSet.isEmpty();
		//7.返回迭代器
		Iterator<Object> ites = hashSet.iterator();
		while (ites.hasNext()) {
			System.out.println(ites.next());
		}
		System.out.println("*---------通过for增强遍历");
		/**便利hashset集合*/
		for (Object object : hashSet) {
			System.out.println(object);
		}
	}
}

2.LinkedHashSet类

用来处理无序的单列数据，没有重复的元素,重复的元素算一个。

特点：按照插入的顺序进行排列

构造方法：

  1. LinkedHashSet（）无惨构造函数，构建一个新的空集合，默认大小（16）和0.75的负载因子。
  2. LinkedHashSet(Collection c) 构造一个包含指定集合中的元素的新集合。 （就是Collection子类得相互转换）
  3. LinkedHashSet(int initialCapacity)构造一个指定大小的空集合，负载因子默认为0.75不变。
  4. LinkedHashSet(int initialCapacity,float loadFactor)指定大小，指定的负载因子（float 小数+f）

例子：

// LinkedHashSet继承了HashSet

//特性基本一样，方法基本一样

//构造函数
//1无惨构造函数默认集合大小为16，负载因子0.75
LinkedHashSet<Object> linkedHashSet = new LinkedHashSet<Object>();

//2.有一个参数的构造函数控制集合的初始大小
LinkedHashSet<Object> linkedHashSet1 = new LinkedHashSet<Object>(8);

//3.有一个参数的构造函数设置集合的初始代大小和负载因子大小
LinkedHashSet<Object> linkedHashSet2 = new LinkedHashSet<Object>(18,0.9F);

//4.可以传递Collection借口的子类 就是转换Set 和List;
ArrayList<Object> fn = new ArrayList<Object>();

LinkedHashSet<Object> linkedHashSet3= new LinkedHashSet<Object>( fn );

事例方法：

返回值

方法结构

作用

boolean

add(Object o)

将指定的元素追加到此列表的末尾。

boolean

contains(Object o)

如果此列表包含指定的元素，则返回 true 。

boolean

remove(Object o)

 从列表中删除指定元素的第一个出现（如果存在）。

int

size()

返回此列表中的元素数。

boolean

isEmpty()

如果此列表不包含元素，则返回 true 。

void

clear()

从列表中删除所有元素。

Iterator<E>

iterator()

 以正确的顺序返回该列表中的元素的迭代器。

例子：

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

public class HashSetTest {
	public static void main(String[] args) {
		//构造函数
		//1.无参数的构造方法 默认大小为16.负载因子为0.75
		HashSet<Object> hashSet = new HashSet<Object>();
		//2有初始容两个大小，但是没有设置负载因子
		HashSet<Object> hashSet2 = new HashSet<Object>(10);
		
		//3可以设置初始大小、负载因子(float类型)
		HashSet<Object> hashSet3 = new HashSet<>(12,0.5f);
		
		//4传递Collection的参数进行转换成HashSet
		LinkedList<Object> linklist = new LinkedList<Object>();
		HashSet<Object> hashSet4 = new HashSet<Object>(linklist);
		
		//事例方法
		//1.添加元素
		hashSet.add("张三");
		hashSet.add(18);
		hashSet.add(true);
		System.out.println(hashSet.size());
		Boolean a = true;
		hashSet.remove(a);
		System.out.println(hashSet.size());
		hashSet.add(null);
		hashSet.add("张三");
		//2.删除元素
		System.out.println("当前Hashset的元素个数为" + hashSet.size());
		//4.remove删除元素
		hashSet.remove("张三");
		System.out.println("当前Hashset的元素个数为" + hashSet.size());
		//5.清空哈希列表
        //hashSet.clear();
		//6.清空哈希表
		hashSet.isEmpty();
		//7.返回迭代器
		Iterator<Object> ites = hashSet.iterator();
		while (ites.hasNext()) {
			System.out.println(ites.next());
		}
		System.out.println("*---------通过for增强遍历");
		/**便利hashset集合*/
		for (Object object : hashSet) {
			System.out.println(object);
		}
	}
}

4.Map映射（键值对）

Map接口用来处理键值对数据的集合

1.HashMap类

1)允许null的值和null键

2)数据保存无序

3)重复的键别算作一个数据

构造方法

1.HashMap()构造一个空的HashMap，默认初始容量（16）和默认负载稀疏（0.75）；

2.HashMap(int initialCapacity)构造一个空的HashMap具有特定的初始容量的和默认负载系数为（0.75）的集合。

3.HashMap(int initialCapacity int loadFactor)构造一个空的HashMap具有特定特定大小，特定负载系数的集合。

4.HashMap(Map m)构造一个新的HashMap与局定的相同的映射Map(即就是Map子类的相互转换)。

例子：

// 构造函数

 //1.无参数构造函数 默认初始容量16，负载系数0.75
HashMap<Object, Object> hashMap = new HashMap<Object,Object>();

//2.创建有初始容量的的集合，负载系数0.75
HashMap<Object, Object> hashMap2 = new HashMap<Object,Object>(10);

//3.创建有初始容量的的  初始负载系数float
HashMap<Object, Object> hashMap3 = new HashMap<Object,Object>(10,0.5f);

//4.Map借口的子类对象相互转换
HashMap<Object, Object> hashMap4 = new HashMap<Object,Object>(hashMap3);

实例方法

返回值

方法(参数)

功能

void

clear()

清空集合。

Object

put(Object key, Object value)

向集合中添加键值对数据。

boolean

containsKey(Object key)

判断集合中是否包含指定的键

boolean

containsValue(Object value)

判断集合中是否包含指定的值

Object 

get(Object key)

根据指定的键得到该键对应的值

boolean

isEmpty()

判断集合是否为空。

int

size()

得到集合中键值对元素的个数。

void

remove(Object key)

根基指定的键删除对应的键值对数据值

Set

keySet()

 得到集合中所有的键保存到Set集合中

Collection

values()

得到集合中所有的值保存到Collection集合中

Enumeration<K>

keys()

返回此散列表中键的枚举。

Enumeration<V>

elements()

返回此散列表中值的枚举。

例子：

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

public class HashMapTest {

	public static void main(String[] args) {
		// 构造函数
		//1.无参数构造函数 默认初始容量16，负载系数0.75
		HashMap<Object, Object> hashMap = new HashMap<Object,Object>();
		//2.创建有初始容量的的集合，负载系数0.75
		HashMap<Object, Object> hashMap2 = new HashMap<Object,Object>(10);
		//3.创建有初始容量的的  初始负载系数float
		HashMap<Object, Object> hashMap3 = new HashMap<Object,Object>(10,0.5f);
		//4.Map借口的子类对象相互转换
		HashMap<Object, Object> hashMap4 = new HashMap<Object,Object>(hashMap3);
		
		//实例方法
		//1.isEmpty是否为空
		System.out.println("这个集合和是否为空" + hashMap.isEmpty());
		//2.put添加元素
		hashMap.put(1001, "张三");
		hashMap.put(1002, "李四");
		hashMap.put(1003, "王五");
		//3.size查询这个集合的元素个数
		System.out.println("hashmap的个数："+hashMap.size());
		//4.clear清空集合
		//hashMap.clear();
		//System.out.println("hashmap的个数："+hashMap.size());
		
		//4.查询是存在key值
		System.out.println( "是否包含1002" + hashMap.containsKey(1002));
		System.out.println( "是否包含1005" + hashMap.containsKey(1005));
		//5.查询是否存在val值
		System.out.println("张三是否存在：" + hashMap.containsValue("张三"));
		
		//6.get通过key获取对应的值
		System.out.println("通过1001获取:"+ hashMap.get(1001));
		
		//7.keySet得到所有的集合返回Set
		Set<Object> keyset= hashMap.keySet();
		for (Object object : keyset) {
			System.out.println(object);
		}
		//8.values得到所有的值的集合
		Collection<Object> valcollection = hashMap.values();
		for (Object object : valcollection) {
			System.out.println(object);
		}
		
	}
}

2.TreeMap

特点：

1.按照键的字母顺序排列。

2.键不能为null。

3.重复的键被算作是一个数据。

4.非线程安全。

构造方法：

1.TreeMap() 使用其键的自然排序构造一个新的空树状图。

2.TreeMap(Map<? extends K,? extends V> m) 构造一个新的树状图，其中包含与给定地图相同的映射，根据其键的自然顺序进行排序 。

//构造方法

//1无参数的构造方法
TreeMap<Object, Object> treeMap = new TreeMap<Object,Object>();

//2构造一个新的ThreeMap
//相互转换  key和val必须事HashMap

HashMap<Object, Object> hashMap = new HashMap<Object,Object>();

TreeMap<Object, Object> treeMap2 = new TreeMap<Object,Object>(hashMap);

实例方法：

返回值

方法(参数)

功能

void

clear()

清空集合。

Object

put(Object key, Object value)

向集合中添加键值对数据。

boolean

containsKey(Object key)

判断集合中是否包含指定的键

boolean

containsValue(Object value)

判断集合中是否包含指定的值

Object 

get(Object key)

根据指定的键得到该键对应的值

boolean

isEmpty()

判断集合是否为空。

int

size()

得到集合中键值对元素的个数。

void

remove(Object key)

根基指定的键删除对应的键值对数据值

Set

keySet()

 得到集合中所有的键保存到Set集合中

Collection

values()

得到集合中所有的值保存到Collection集合中

Enumeration<K>

keys()

返回此散列表中键的枚举。

Enumeration<V>

elements()

返回此散列表中值的枚举。

实例方法：

//实例方法
		//1.isEmpty是否为空
		System.out.println("这个集合和是否为空" + treeMap.isEmpty());
		//2.put添加元素
		treeMap.put(1001, "张三");
		treeMap.put(1002, "李四");
		treeMap.put(1003, "王五");
		//3.size查询这个集合的元素个数
		System.out.println("hashmap的个数："+treeMap.size());
		//4.clear清空集合
		//treeMap.clear();
		//System.out.println("hashmap的个数："+treeMap.size());
		
		//4.查询是存在key值
		System.out.println( "是否包含1002" + treeMap.containsKey(1002));
		System.out.println( "是否包含1005" + treeMap.containsKey(1005));
		//5.查询是否存在val值
		System.out.println("张三是否存在：" + treeMap.containsValue("张三"));
		
		//6.get通过key获取对应的值
		System.out.println("通过1001获取:"+ treeMap.get(1001));
		
		//7.keySet得到所有的集合返回Set
		Set<Object> keyset= treeMap.keySet();
		for (Object object : keyset) {
			System.out.println(object);
		}
		//8.values得到所有的值的集合
		Collection<Object> valcollection = treeMap.values();
		for (Object object : valcollection) {
			System.out.println(object);
		}

HashMap类与Hashtable类与TreeMap类与ConcurrentHashMap类区别？

特点

HashMap

Hashtable

TreeMap

ConcurrentHashMap

结构：

键值对

单列表

键值对

键值对

是否允许null

可以为null

不允许有null

允许有null

允许有null

是否线程安全

否

是

否

是

支持检索的完全并发性和更新的高预期并发性的哈希表

都是无序的都不可以重复

特征：

ConcurrentHashMap类线程安全支出检索是的高并发处理。

如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable。

Set和Collection借口的区别

Set是无序的不能有重复的数据

Collection是有序的可以有重复的数据

ArrList和LinkedList的区别

ArrList存储的机构为动态数组

优点查询快，添加/删除慢

初始容量为10

LinkedList存储的结构为双向链表

优点添加/删除快 ， 查询慢。

无初始容量

无奈源于不够强大

HJHO
关注
专栏目录
java集合框架实验心得_关于Java集合框架的总结
weixin_32322859的博客
02-27 1773
本篇文章先从整体介绍了Java集合框架包含的接口和类，然后总结了集合框架中的一些基本知识和关键点，并结合实例进行简单分析。当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型。一、综述所有集合类都位于java.util包下。集合中只能保存对象(保存对象的引用变...
【Java】Java集合框架思维导图。
04-13
xmind格式的Java集合框架学习导图，包括Collection接口/Map接口以及具体实现类。 同样包含大厂面试题，也在导图中有所体现。 能学到什么： 更加成体系的知识框架，更加全面的、系统的知识。 思维导图： 思维导图具有...
处理键值对RDD
weixin_34293902的博客
09-06 106
保存Key/Value对的RDD叫做Pair RDD。1.创建Pair RDD:1.1 创建Pair RDD的方式：很多数据格式在导入RDD时，会直接生成Pair RDD。我们也可以使用map()来将之前讲到的普通RDD转化为Pair RDD。1.2 Pair RDD转化实例：下面例子中，把原始RDD，修改成首单词做Key，整行做Value的Pair RDD。Java中没有t...
Java集合框架总结
ThinkWon的博客
08-08 6万+
简介 集合框架：用于存储数据的容器。 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。 任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。 接口：表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现，从而达到“多态”。在面向对象编程语言中，接口通常用来形成规范。 实现：集合接口的具体实现，是重用性很高的数据结构。 算法：在一个实现了某个集合框架中的接口的...
Java集合框架关系图
diweikang的博客
03-10 3万+
集合的特点： 集合用来存储不同类型的对象（基本数据类型除外），存储长度可变。 Java集合中实际存放的只是对象的引用，每个集合元素都是一个引用变量，实际内容都放在堆内存或者方法区里面，但是基本数据类型是在栈内存上分配空间的，栈上的数据随时就会被收回的。 集合框架图： 上述类图中，实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，...
Java集合框架
weixin_54204139的博客
04-15 4557
目录 一、集合 1.1概念 1.2集合与数组区别 二、集合的架构 三、Collection接口 3.1 List集合 1、List实现类——ArrayList集合 2、List实现类——LinkedList集合 3.2 Set集合 1、HashSet 一、集合框架 1.1概念 Java集合框架(Java Collections Framework简称JCF)是为表示和操作集合，而规定的一种统一的标准的体系结构。集合框架包含三大块内容：对外的接口、接口的实现和对集合运算的..
java集合框架优点
qq_45840774的博客
05-22 948
java集合框架优点  1，java集合框架，提供了多种集合类型，以及高性能/高质量的数据结构实现  2，集合之间可以方便的实现相互转换  3，各种类型的集合接口与具体实现分离  4，使开发者将时间精力致力于改善程序本身的质量和性能   （1）减少程序工作量   （2）提高程序速度和质量   （3）减少学习和使用新API的工作量  5，避免了直接操作对象数组带来的同步/异步/性能/效率/异常/接口设计等繁琐问题  6，java集合框架是典型的面向对象接口编程的体现 ...
Java集合框架的全面分析和性能增强
沉淀、分享、成长，让自己和他人都能有所收获！
07-28 8758
Java集合框架在Java编程中起着至关重要的作用。它提供了一系列的数据结构和算法，用于存储、操作和访问数据。然而，为了充分利用集合框架的强大功能，开发人员需要深入了解其内部机制，并注意性能优化。本博客将深度解析Java集合框架的核心组件，包括List、Set、Map等接口及其实现类，同时提供优化技巧和示例，助力新手更好地理解和学习。
Java集合框架底层原理
weixin_35720385的博客
02-15 2165
Java集合框架Java集合框架List集合ArrayList底层实现原理ArrayList数组扩容技术（数组拷贝）扩容大小查询和删除集合中的泛型LinkedListVector 线程安全LinkedList和ArrayList区别Map集合HashMap底层实现原理链表存放的都是那些数据？数组初始化HashMap的扩容机制 Java集合框架 所有集合类都位于java.util包下。Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口。
Java中常见的集合框架及常用的方法
热门推荐
刘跃辉的博客
09-05 9万+
本篇文章主要说明Java中一些常见的集合框架及经常用到的一些方法 , 由于都是一些父类 , 所以没有做太深入的分析说明 , 后面的文章将会分别对List , Set , Map及其常用子类进行深入研究分析。
Java集合框架面试题总结及解析
暴力扬
11-16 2250
文章目录说出 collection 的常用子接口？说出 3 个以上的常 用方法？都有什么作用？如果向 TreeSet 中加入类对象，需要做什么？Set 里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是 equals()? 它们有何区别?ArrayList 和 Vector 的区别？集合当中能存放基本数据类型的数据吗？ArrayList 与数组的区别?java 集合框架的四种主要接口是HashMap 和 Hashtable 的区别?Collection 框架中实现比较方法在 Java 中，
JAVA集合框架专题
08-19
JAVA集合框架专题 JAVA集合框架是JAVA编程语言中的一种常用的数据结构，用于存储和操作对象信息。下面是JAVA集合框架的主要知识点： 一、集合框架概述 JAVA集合框架是一种容器，用于存储对象信息。所有集合类都...
Java集合框架.ppt
06-04
集合是将多个元素组成一个单元的...Java集合框架，为我们提供了一套性能优良、使用方便的接口和类，我们不必再重新发明轮子，只需学会如何使用它们，就可以处理实际应用中出现的问题了Java集合框架位于java.util包中
Java企业面试题3
最新发布
m0_74972727的博客
09-15 556
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1105
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 148
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 626
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值