Set集合特点、HashSet集合类、Map集合、集合嵌套

最新推荐文章于 2023-06-15 00:01:23 发布
最新推荐文章于 2023-06-15 00:01:23 发布
阅读量386 收藏
点赞数
分类专栏： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tracy19970428/article/details/105005787
版权

Set集合特点、HashSet集合类、Map集合、集合嵌套

Set集合

Set集合的特点

Set:元素唯一,存储元素无序
一个不包含重复元素的 collection
HashSet:
它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变

案例代码
package com.itheima_01;

import java.util.HashSet;
import java.util.Set;

/*
 * Set:
 * 		一个不包含重复元素的 collection
 * 
 * HashSet:
 * 		它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变
 */
public class SetDemo {
	public static void main(String[] args) {
		//创建集合对象
		Set<String> set = new HashSet<String>();
		
		//添加元素
		set.add("hello");
		set.add("world");
		set.add("java");
		//唯一
		set.add("world");
		
		//遍历集合
		for(String s : set) {
			System.out.println(s);
		}
		
	}
}

HashSet集合

HashSet集合特点
它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变
HashSet保证元素唯一性的原理
  • HashSet保证元素唯一性的原理：
    通过查看add方法的源码，我们知道了添加功能的执行过程中，是进行了数据的判断的。
  • 判断流程
    首先比较对象的哈希值是否相同，这个哈希值是根据对象的hashCode()计算出来的。
    如果哈希值不同，就直接添加到集合中
    如果哈希值相同，继续执行equals()进行比较，
    返回的是true，说明元素重复，不添加。
    返回的是false，说明元素不重复，就添加。
    如果我们使用HashSet集合存储对象，你要想保证元素的唯一性，就必须重写hashCode()和equals()方法。
案例代码
package com.itheima_02;

import java.util.HashSet;

/*
 * HashSet保证元素唯一性的原理?
 * 
 * 通过查看add方法的源码，我们知道了添加功能的执行过程中，是进行了数据的判断的。
 * 这个判断的流程是：
 * 		首先比较对象的哈希值是否相同，这个哈希值是根据对象的hashCode()计算出来的。
 * 			如果哈希值不同，就直接添加到集合中
 * 			如果哈希值相同，继续执行equals()进行比较，
 * 				返回的是true，说明元素重复，不添加。
 * 				返回的是false，说明元素不重复，就添加。
 * 
 * 如果我们使用HashSet集合存储对象，你要想保证元素的唯一性，就必须重写hashCode()和equals()方法。
 */
public class HashSetDemo {
	public static void main(String[] args) {
		//创建集合对象
		HashSet<String> hs = new HashSet<String>();
		
		//添加元素
		hs.add("hello");
		hs.add("world");
		hs.add("java");
		hs.add("world");
		
		//遍历集合
		for(String s : hs) {
			System.out.println(s);
		}
	}
}
HashSet集合存储自定义对象并遍历

HashSet集合存储自定义对象并遍历
提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
两种方式遍历
迭代器
增强for

案例代码
package com.itheima_03;

public class Student {
	private String name;
	private int age;

	public Student() {
	}

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

	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 com.itheima_03;

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

/*
 * HashSet集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 两种方式遍历
 * 		迭代器
 * 		增强for
 */
public class HashSetTest {
	public static void main(String[] args) {
		//创建集合对象
		HashSet<Student> hs = new HashSet<Student>();
		
		//创建元素对象
		Student s1 = new Student("林青霞",30);
		Student s2 = new Student("张曼玉",35);
		Student s3 = new Student("王祖贤",33);
		
		//把元素添加到集合
		hs.add(s1);
		hs.add(s2);
		hs.add(s3);
		
		//遍历
		//迭代器
		Iterator<Student> it = hs.iterator();
		while(it.hasNext()){
			Student s = it.next();
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("------------------");
		
		//增强for
		for(Student s : hs) {
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}
HashSet集合存储自定义对象保证元素唯一性

HashSet集合存储自定义对象并遍历
要求：如果对象的成员变量值相同，就认为是同一个元素。
提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
两种方式遍历
迭代器
增强for

因为我们存储的元素所属的类没有重写hashCode()和equals()方法，所以保证不了元素的唯一性。
而我想保证，怎么办呢?重写这两个方法就可以了。
重写方法：自动生成

案例代码
package com.itheima_04;

public class Student {
	private String name;
	private int age;

	public Student() {
	}

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

	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 int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

}

package com.itheima_04;

import java.util.HashSet;

/*
 * HashSet集合存储自定义对象并遍历
 * 要求：如果对象的成员变量值相同，就认为是同一个元素。
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 两种方式遍历
 * 		迭代器
 * 		增强for
 * 
 * 因为我们存储的元素所属的类没有重写hashCode()和equals()方法，所以保证不了元素的唯一性。
 * 而我想保证，怎么办呢?重写这两个方法就可以了。
 * 如何重写呢?自动生成就可以了。
 */
public class HashSetTest {
	public static void main(String[] args) {
		//创建集合对象
		HashSet<Student> hs = new HashSet<Student>();
		
		//创建元素对象
		Student s1 = new Student("林青霞",30);
		Student s2 = new Student("张曼玉",35);
		Student s3 = new Student("王祖贤",33);
		Student s4 = new Student("林青霞",30);
		Student s5 = new Student("张曼玉",35);
		
		//把元素添加到集合
		hs.add(s1);
		hs.add(s2);
		hs.add(s3);
		hs.add(s4);
		hs.add(s5);
		
		//遍历集合
		//增强for
		for(Student s : hs) {
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}
HashMap集合的相关案例
HashMap集合的练习键是String值是Student

练习1：两种方式遍历
HashMap<String,Student>
键：String 学号
值：Student 学生对象

package com.itheima_03;

public class Student {
	private String name;
	private int age;

	public Student() {
	}

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

	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 com.itheima_03;

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

/*
 * 练习1：两种方式遍历
 * HashMap<String,Student>
 * 键：String 学号
 * 值：Student 学生对象
 */
public class HashMapTest {
	public static void main(String[] args) {
		// 创建集合对象
		HashMap<String, Student> hm = new HashMap<String, Student>();

		// 创建元素对象
		Student s1 = new Student("林青霞", 30);
		Student s2 = new Student("张曼玉", 35);
		Student s3 = new Student("王祖贤", 33);

		// 添加元素到集合中
		hm.put("it001", s1);
		hm.put("it002", s2);
		hm.put("it003", s3);

		// 遍历
		// 根据键找值
		Set<String> set = hm.keySet();
		for (String key : set) {
			Student value = hm.get(key);
			System.out.println(key + "---" + value.getName() + "---" + value.getAge());
		}
		System.out.println("---------------------");

		// 根据键值对对象找键和值
		Set<Map.Entry<String, Student>> set2 = hm.entrySet();
		for (Map.Entry<String, Student> me : set2) {
			String key = me.getKey();
			Student value = me.getValue();
			System.out.println(key + "---" + value.getName() + "---" + value.getAge());
		}
	}
}
HashMap集合的练习键是Student值是String

练习2：任选一种方式遍历
HashMap<Student,String>
键：Student 学生对象
值：String 学生住址
要求：如果学生对象的成员变量值相同，就说明是同一个键。

package com.itheima_04;

public class Student {
	private String name;
	private int age;

	public Student() {
	}

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

	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 int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	
}

package com.itheima_04;

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

/*
 * 练习2：任选一种方式遍历
 * HashMap<Student,String>
 * 键：Student 学生对象
 * 值：String 学生住址
 * 要求：如果学生对象的成员变量值相同，就说明是同一个键。
 */
public class HashMapTest {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<Student,String> hm = new HashMap<Student,String>();
		
		//创建元素对象
		Student s1 = new Student("林青霞",30);
		Student s2 = new Student("张曼玉",35);
		Student s3 = new Student("王祖贤",33);
		Student s4 = new Student("张曼玉",35);
		
		//添加元素到集合中
		hm.put(s1, "北京");
		hm.put(s2, "上海");
		hm.put(s3, "西安");
		hm.put(s4, "香港");
		
		//键找值
		Set<Student> set = hm.keySet();
		for(Student key : set) {
			String value = hm.get(key);
			System.out.println(key.getName()+"---"+key.getAge()+"---"+value);
		}
	}
}

Map集合

Map集合概念

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

创建Map集合对象并添加元素

Map:
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

举例：学生的学号和姓名
it001 林青霞
it002 张曼玉
it003 王祖贤
public interface Map<K,V>

案例代码
package com.itheima_01;

import java.util.HashMap;
import java.util.Map;

/*
 * Map:
 * 		将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 
 * 
 * 举例：学生的学号和姓名
 * 		it001	林青霞
 * 		it002	张曼玉
 * 		it003	王祖贤
 * 
 * public interface Map<K,V>
 * 
 */
public class MapDemo {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		
		//添加元素
		//put(K key,V value):添加元素。
		map.put("it001", "林青霞");
		map.put("it002", "张曼玉");
		map.put("it003", "王祖贤");
		
		//输出集合对象
		System.out.println(map);
	}
}

2.2	Map集合的成员方法
V put(K key,V value):添加元素
V remove(Object key):根据键删除键值对元素
void clear():移除所有的键值对元素
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
int size()：返回集合中的键值对的对数

2.2.1	案例代码七:
package com.itheima_01;

import java.util.HashMap;
import java.util.Map;

/*
 * V put(K key,V value):添加元素
 * V remove(Object key):根据键删除键值对元素
 * void clear():移除所有的键值对元素
 * boolean containsKey(Object key)：判断集合是否包含指定的键
 * boolean containsValue(Object value):判断集合是否包含指定的值
 * boolean isEmpty()：判断集合是否为空
 * int size()：返回集合中的键值对的对数
 * 
 * Map集合中的实现类的数据结构只针对键有效。
 */
public class MapDemo2 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		
		//V put(K key,V value):添加元素
		//如果键是第一次存储，就直接存储元素，返回null
		//如果键不是第一次存储，就用值把以前的值替换，返回以前的值
//		System.out.println("put:"+map.put("张无忌", "周芷若"));
//		System.out.println("put:"+map.put("张无忌", "赵敏"));
		map.put("张无忌", "赵敏");
		map.put("郭靖", "黄蓉");
		map.put("杨过", "小龙女");
		
		//V remove(Object key):根据键删除键值对元素
//		System.out.println("remove:"+map.remove("郭靖"));
//		System.out.println("remove:"+map.remove("郭襄"));
		
		//void clear():移除所有的键值对元素
		//map.clear();
		
		//boolean containsKey(Object key)：判断集合是否包含指定的键
//		System.out.println("containsKey:"+map.containsKey("郭靖"));
//		System.out.println("containsKey:"+map.containsKey("郭襄"));
		
		//boolean containsValue(Object value):判断集合是否包含指定的值 自己练习
		
		//boolean isEmpty()：判断集合是否为空
		//System.out.println("isEmpty:"+map.isEmpty());
		
		//int size()：返回集合中的键值对的对数
		System.out.println("size:"+map.size());
		
		//输出集合对象
		System.out.println(map);
	}
}
Map集合的获取功能测试

V get(Object key):根据键获取值
Set keySet():获取所有键的集合
Collection values():获取所有值的集合

案例代码
package com.itheima_01;

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

/*
 * V get(Object key):根据键获取值
 * Set<K> keySet():获取所有键的集合
 * Collection<V> values():获取所有值的集合
 */
public class MapDemo3 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		
		//添加元素
		map.put("郭靖", "黄蓉");
		map.put("杨过", "小龙女");
		map.put("张无忌", "赵敏");
		
		//V get(Object key):根据键获取值
		System.out.println("get:"+map.get("张无忌"));
		System.out.println("get:"+map.get("张三丰"));
		System.out.println("--------------------");
		
		//Set<K> keySet():获取所有键的集合
		Set<String> set = map.keySet();
		for(String key : set) {
			System.out.println(key);
		}
		System.out.println("--------------------");
		
		//Collection<V> values():获取所有值的集合
		Collection<String> values = map.values();
		for(String value : values) {
			System.out.println(value);
		}
	}
}
Map集合的遍历之键找值

Map集合的遍历
思路：Map看成是一个夫妻对的集合
A:把所有的丈夫给集中起来
B:遍历丈夫的集合，获取到每一个丈夫
C:根据丈夫去找对应的妻子
转换：
A:获取所有键的集合
B:遍历键的集合，获取到每一个键
C:根据键去找值

案例代码
package com.itheima_02;

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

/*
 * Map集合的遍历
 * 
 * 思路：Map看成是一个夫妻对的集合
 * 		A:把所有的丈夫给集中起来
 * 		B:遍历丈夫的集合，获取到每一个丈夫
 * 		C:根据丈夫去找对应的妻子
 * 
 * 转换：
 * 		A:获取所有键的集合
 * 		B:遍历键的集合，获取到每一个键
 * 		C:根据键去找值
 */
public class MapDemo {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		
		//添加元素
		map.put("郭靖","黄蓉");
		map.put("杨过","小龙女");
		map.put("张无忌","赵敏");
		
		//获取所有键的集合
		Set<String> set = map.keySet();
		//遍历键的集合，获取到每一个键
		for(String key : set) {
			//根据键去找值
			String value = map.get(key);
			System.out.println(key+"---"+value);
		}
	}
}
Map集合的遍历之键值对对象找键和值

Map集合遍历的方式2
思路：
A:获取所有结婚证的集合
B:遍历结婚证的集合，得到每一个结婚证
C:根据结婚证获取丈夫和妻子
转换：
A:获取所有键值对对象的集合
B:遍历键值对对象的集合，得到每一个键值对对象
C:根据键值对对象获取键和值

案例代码
package com.itheima_02;

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

/*
 * Map集合遍历的方式2
 * 
 * 思路：
 * 		A:获取所有结婚证的集合
 * 		B:遍历结婚证的集合，得到每一个结婚证
 * 		C:根据结婚证获取丈夫和妻子
 * 
 * 转换：
 * 		A:获取所有键值对对象的集合
 * 		B:遍历键值对对象的集合，得到每一个键值对对象
 * 		C:根据键值对对象获取键和值
 */
public class MapDemo2 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		
		//添加元素
		map.put("郭靖","黄蓉");
		map.put("杨过","小龙女");
		map.put("张无忌","赵敏");
		
		//获取所有键值对对象的集合
//		Set<Map.Entry<K,V>> entrySet()
//		获取键值对对象的集合
		Set<Map.Entry<String,String>> set = map.entrySet();
		//遍历键值对对象的集合，得到每一个键值对对象
		for(Map.Entry<String,String> me : set) {
			//根据键值对对象获取键和值
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key+"---"+value);
		}
	}
}

在这里插入图片描述

集合嵌套

集合的嵌套练习之ArrayList嵌套HashMap

需求：ArrayList集合嵌套HashMap集合并遍历。
定义一个ArrayList集合，它包含三个元素，每一个元素都是HashMap类型的。
每一个HashMap集合的键和值都是String类型的，
键：String 丈夫的姓名
值：String 妻子的姓名
给出如下的字符串数据，请用代码实现需求。
第一个HashMap集合的元素：
孙策 大乔
周瑜 小乔
第二个HashMap集合的元素：
郭靖 黄蓉
杨过 小龙女
第三个HashMap集合的元素：
令狐冲 任盈盈
林平之 岳灵珊

案例代码
package com.itheima;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/*
 * 需求：ArrayList集合嵌套HashMap集合并遍历。
 * 定义一个ArrayList集合，它包含三个元素，每一个元素都是HashMap类型的。
 * 每一个HashMap集合的键和值都是String类型的，
 * 键：String		丈夫的姓名
 * 值：String		妻子的姓名
 * 给出如下的字符串数据，请用代码实现需求。
 * 第一个HashMap集合的元素：
 * 		孙策		大乔
 * 		周瑜		小乔
 * 第二个HashMap集合的元素：
 * 		郭靖		黄蓉
 * 		杨过		小龙女
 * 第三个HashMap集合的元素：
 * 		令狐冲	任盈盈
 * 		林平之	岳灵珊
 */
public class ArrayListIncludeHashMapTest {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList<HashMap<String,String>> array = new ArrayList<HashMap<String,String>>();
		
		//创建元素1
		HashMap<String,String> hm1 = new HashMap<String,String>();
		hm1.put("孙策","大乔");
		hm1.put("周瑜","小乔");
		//把元素添加到array中
		array.add(hm1);
		
		//创建元素2
		HashMap<String,String> hm2 = new HashMap<String,String>();
		hm2.put("郭靖","黄蓉");
		hm2.put("杨过","小龙女");
		//把元素添加到array中
		array.add(hm2);
		
		//创建元素3
		HashMap<String,String> hm3 = new HashMap<String,String>();
		hm3.put("令狐冲","任盈盈");
		hm3.put("林平之","岳灵珊");
		//把元素添加到array中
		array.add(hm3);
		
		//遍历ArrayList集合
		for(HashMap<String,String> hm : array) {
			Set<String> set = hm.keySet();
			for(String key : set) {
				String value = hm.get(key);
				System.out.println(key+"---"+value);
			}
			System.out.println("-----------------");
		}
		
	}
}
集合的嵌套练习之HashMap嵌套ArrayList

需求：HashMap集合嵌套ArrayList集合并遍历。
定义一个HashMap集合，它包含三个元素，每一个元素的键是String类型，值是ArrayList类型。
键：String 人物来自哪部电视剧
值：ArrayList 人物的名称
每一个ArrayList集合的数据是String类型的。
给出如下的字符串数据，请用代码实现需求。
第一个ArrayList集合的元素：(三国演义)
诸葛亮
赵云
第二个ArrayList集合的元素：(西游记)
唐僧
孙悟空
第三个ArrayList集合的元素：(水浒传)
武松
鲁智深

案例代码
package com.itheima;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/*
 * 需求：HashMap集合嵌套ArrayList集合并遍历。
 * 定义一个HashMap集合，它包含三个元素，每一个元素的键是String类型，值是ArrayList类型。
 * 键：String			人物来自哪部电视剧
 * 值：ArrayList		人物的名称
 * 每一个ArrayList集合的数据是String类型的。
 * 给出如下的字符串数据，请用代码实现需求。
 * 第一个ArrayList集合的元素：(三国演义)
 * 		诸葛亮
 * 		赵云
 * 第二个ArrayList集合的元素：(西游记)
 * 		唐僧
 * 		孙悟空
 * 第三个ArrayList集合的元素：(水浒传)
 * 		武松
 * 		鲁智深
 */
public class HashMapIncludeArrayListTest {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<String,ArrayList<String>> hm = new HashMap<String,ArrayList<String>>();
	
		//创建元素1
		ArrayList<String> sgyy = new ArrayList<String>();
		sgyy.add("诸葛亮");
		sgyy.add("赵云");
		//把元素添加到hm中
		hm.put("三国演义", sgyy);
		
		//创建元素2
		ArrayList<String> xyj = new ArrayList<String>();
		xyj.add("唐僧");
		xyj.add("孙悟空");
		//把元素添加到hm中
		hm.put("西游记", xyj);
		
		//创建元素3
		ArrayList<String> shz = new ArrayList<String>();
		shz.add("武松");
		shz.add("鲁智深");
		//把元素添加到hm中
		hm.put("水浒传", shz);
		
		//遍历集合
		Set<String> set = hm.keySet();
		for(String key : set) {
			System.out.println(key);
			ArrayList<String> value = hm.get(key);
			for(String s : value) {
				System.out.println("\t"+s);
			}
		}
	}
}
smalllllerr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HaMap源码阅读（put()方法流程图）
yeyeyhehe的博客
10-10 646
@TOC public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } /** * Implements Map.put and related methods * * @param hash hash for key * @param key the key * @param value the value to pu
Map集合特点
m0_67402236的博客
04-20 388
1. Map 1.1 特点：无序、以键值对的形式添加元素，键不能重复，值可以重复 它没有继承Collection接口 1.2 遍历 1.2.1 先取出保存所有键的Set,再遍历Set即可(2种) 1.2.2 先取出保存所有Entry的Set,再遍历此Set即可 2.HashMap与Hashtable之间的区别 HashMap非同步 线程不安全 Hashtable同步 线程安全 同步既排队 HashMap只允许一条记录的键为NULL TreeMap不允许键为NULL ...
Set集合的特点
weixin_57219176的博客
04-19 527
* Set集合是Collection的子接口 * 该集合中的元素是唯一的！无序的 * HashSet:不能保证元素的迭代顺序恒久不变，底层哈希表（HashMap实例） * 无序性（存储和取出不一致） * 哈希表能够保证元素唯一： * public int hashCode() * public boolean equals(Object e) import java.util.HashSet; import java.util.Set; public cla...
Set集合详解
weixin_74268571的博客
06-15 7477
set集合的简介，它的特点和遍历方式。介绍了HashSet重复元素存储底层原理，LinkedHashSet,TreeSet排序方法，SortedSet获取集合值的方法
Set集合概述和特点
weixin_55839814的博客
10-23 1530
特点： 1、不包含重复元素的集合 2、没有带索引的方法，不能使用普通for循环遍历 HashSet对集合的迭代顺序不做保证 Set<String> set = new HashSet<String>(); set.add("java"); set.add("hello"); set.add("world"); set.add("hello"); System.out.println(set); Iterator &lt...
java Date类和集合
01-07
Java中的`Date`类和集合类是编程中非常基础且重要的概念。`Date`类主要用于处理日期和时间，而集合类则提供了存储和操作对象的容器。在这篇笔记中，我们将深入探讨这两个主题。 首先，`java.util.Date`类虽然在Java...
java笔试面试题集合，全！新！
05-04
1. List、Set、Queue接口：ArrayList、LinkedList、HashSet、LinkedHashSet、TreeSet等的实现及特点。 2. Map接口：HashMap、LinkedHashMap、TreeMap的原理和应用场景。 3. 泛型：了解泛型的基本用法，以及类型擦除...
java笔试题大集合及答案
05-30
1. List、Set、Map：理解不同集合接口（如ArrayList、LinkedList、HashSet、HashMap）的特点和使用场景。 2. 集合操作：掌握增删改查操作，理解迭代器的使用。 3. 泛型：了解泛型的概念，知道如何使用泛型限制类型...
自学java基础Xmind思维导图笔记
最新发布
09-05
Set中的`HashSet`和`TreeSet`各有特点，Collections提供了一系列操作集合的方法，而Map接口的实现如`HashMap`和`TreeMap`则提供了键值对的存储和检索。 6. **网络编程** Java的`java.net`包提供了进行网络编程的...
KotlinCollections：这是一个用于学习Kotlin的简单项目
02-25
- **扁平化**：`flatten` 将嵌套的集合合并为单一集合。 - **归并**：`reduce` 可以将所有元素组合成单个值。 - **分组**：`groupBy` 根据指定函数将元素分组。 - **排序**：`sortedBy` 或 `sortedWith` 可按指定...
Java中的Map集合
weixin_54535063的博客
09-17 1307
V put(K key, V value) （可以相同的key值，但是添加的value值会覆盖前面的，返回值是前一个，如果没有就返回null）
HashSet特点
qq_45376750的博客
06-25 757
存储的元素是无序不重复的 底层结构是哈希表，具有良好的存储和查找性能 HashSet集合没有索引，只能通过迭代器和for增强循环遍历集合 哈希表 常用数组实现，元素根据哈希值计算在哈希表中的存储位置。 如果元素出现哈希冲突（在哈希表存储的位置一样），那么会采用链表挂在元素。 哈希值 哈希值代表对象的某种特征，通常使用int整数表示。 Object类中提供hashCode()方法,可以根据内存地址计算出哈希值。由于每个对象的地址不一样，对应的哈希值也不一样。 Java类可以重写hashC
java 的map特点,什么是Map集合？Map集合的特点
weixin_42550597的博客
03-19 1095
Map集合的特点:1.是一个双列集合,赋值的时候必须同时给key和value赋值2.是一个无序的集合(存入和取出元素的顺序可能不一致)3.key值不能重复,value可以重复4.一个key只能对应一个vlaue5.定义集合时,数据类型key和value可以使用相同的数据类型,也可以使用不同的数据类型Map集合的特点java.util.Map接口:集合,是一个双列集合Map集合遍历的第一种方式Map...
set集合的特点
热门推荐
云飞扬°的博客
05-06 1万+
set集合的特点 A:存入集合的顺序和取出集合的顺序不一致 B:没有索引 C:存入集合的元素没有重复 set接口的实现类常用的有HashSet和TreeSet类。语法格式如下： Set<String> set1 = new HashSet<String>(); Set<String> set2 = new TreeSe...
集合（Set、Collections、Map、集合嵌套）
weixin_52270382的博客
02-09 501
Set系列集合特点● 无序：存取顺序不一致● 不重复：可以去除重复● 无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。Set集合实现类特点● HashSet:无序、不重复、无索引。● LinkedHashSet:有序、不重复、无索引。● TreeSet:排序、不重复、无索引。Set集合的功能基本上与Collection的API一致//看看Set系列集合的特点：HashSet LinkedHashSet TreeSet。
Python中的SET集合操作
10-03 721
Python中的SET集合操作 Python中的SET集合操作2009-07-11 16:07python的set和其他语言类似, 是一个无序不重复元素集,基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), ...
List、Map、Set集合的特点及常用方法
Kfie66的博客
01-15 8183
一. List集合:  一次只存储一个元素 1．常用的list集合是ArrayList （1）在创建这个集合的对象时, 需要指定这个集合存储的数据类型! 否则这个集合的数据是不安全的。 （2）与数组的区别: ①数组的长度是固定的, 集合的长度是可变的。 ②数组可以存储基本类型和引用数据类型的数据.集合不可以存储基本数据类型, 只能存储引用数据类型。 2．基本数据类型的包装类 （1）b...
java Map/List/Set 嵌套使用的一点心得
swust_lian的博客
06-20 2631
public static void main(String[] args) { // TODO Auto-generated method stub Set&lt;Integer&gt; set=new HashSet&lt;Integer&gt;(); List&lt;Set&lt;Integer&gt;&gt;list=new ArrayList&lt;Set&lt;Intege...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值