黑马程序员-集合-Set和Map和Collections

最新推荐文章于 2022-01-09 11:15:55 发布
最新推荐文章于 2022-01-09 11:15:55 发布
阅读量314 收藏
点赞数
分类专栏： Java学习总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuyao22/article/details/47207905
版权

第一讲 Set

1.      Set接口的概述

不包含重复的元素，无序（存储和取出的顺序不一样）。和collection的功能是一样的，无特殊。

 

|--HashSet: HashSet底层数据结构是哈希表，保证元素唯一性的原理是：判断元素的hashCode()是否相同，相同就判断equalis()方法是否为true；不保证Set的迭代顺序。

 

|--TreeSet: TreeSet 底层是二叉树结构，元素是唯一，有序的（按照某种规则排序）

 

2.      HashSet

HashSet中和元素唯一性相关的操作都依赖于hashCode()和euqals()方法

如add()方法的源码可知

步骤：比较哈希值

                             相同：比较地址值或equals()

                                                         相同：不添加

                                                         不同：添加到集合中

                             不同：添加到集合中

注意：String重写了hashCode()和equals()方法，所以内容相同的会直接去掉

示例：HashSet存储自定义对象并遍历

//先是声明一个学生类Student.java,两个成员变量，名字和年龄
public class Student {
private String name;
private int age;
 
public Student() {
           super();
}
 
public Student(String name, int age) {
           super();
           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;
}
 
//重写hashCode和equals
@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;
}
}


在HashSetDemo.java中遍历

public class HashSetDemo{
	public static void main(String[] args) {
		// 创建集合对象
		HashSet<Student> hs = new HashSet<Student>();

		// 创建学生对象
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("柳岩", 22);
		Student s3 = new Student("王祖贤", 30);
		Student s4 = new Student("林青霞", 27);
		Student s5 = new Student("林青霞", 20);
		Student s6 = new Student("范冰冰", 22);

		// 添加元素
		hs.add(s1);
		hs.add(s2);
		hs.add(s3);
		hs.add(s4);
		hs.add(s5);
		hs.add(s6);

		// 遍历集合
		for (Student s : hs) {
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}


3.      TreeSet

TreeSet的特点是唯一，有序的，有序是指让元素按照某种规则排序

规则分为两种，自然排序和比较器排序。

TreeSet的底层是依赖于二叉树中的红黑树

3.1   红黑树---一种自平衡的二叉查找树

 



 

3.2   TreeSet的排序规则—自然排序

自然排序是让元素本身具备比较性，所比较的元素的类实现实现Comparable接口，覆盖compareTo()方法。

如果返回值为0，则表示此对象等于指定对象，所以排序后保存其中之一

返回值为正数，则此对象大于指定对象；返回值为负数，则此对象小于指定对象

Student.java

/*
 * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
 */
public class Student implements Comparable<Student> {
	private String name;
	private int age;

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		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 compareTo(Student s) {
	        // 这里返回什么，其实应该根据排序规则来做
		// 按照年龄排序,主要条件
		int num = this.age - s.age;
		// 次要条件
		// 年龄相同的时候，还得去看姓名是否也相同
		// 如果年龄和姓名都相同，才是同一个元素
		int num2 = num == 0 ? this.name.compareTo(s.name) : num;
		return num2;
	}
}
TreeSetDemo.java 

public class TreeSetDemo {
	public static void main(String[] args) {
		// 创建集合对象
		TreeSet<Student> ts = new TreeSet<Student>();

		// 创建元素
		Student s1 = new Student("linqingxia", 27);
		Student s2 = new Student("zhangguorong", 29);
		Student s3 = new Student("wanglihong", 23);
		Student s4 = new Student("linqingxia", 27);
		Student s5 = new Student("liushishi", 22);
		Student s6 = new Student("wuqilong", 40);
		Student s7 = new Student("fengqingy", 22);

		// 添加元素
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
		ts.add(s6);
		ts.add(s7);

		// 遍历
		for (Student s : ts) {
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}

显示结果：




3.3  TreeSet的排序规则—比较器排序

 集合自身具备比较性。  在集合初始化时，定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。也可以定义一个类，实现Comparator接口，覆盖compare()方法

我们使用的是直接将比较器对象作为参数传递给TreeSet集合的构造函数

public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {

			@Override
			public int compare(Student s1, Student s2) {
				// 姓名长度
				int num = s1.getName().length() - s2.getName().length();
				// 姓名内容
				int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
						: num;
				// 年龄
				int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
				return num3;
			}
		});

		// 创建元素
		Student s1 = new Student("linqingxia", 27);
		Student s2 = new Student("zhangguorong", 29);
		Student s3 = new Student("wanglihong", 23);
		Student s4 = new Student("linqingxia", 27);
		Student s5 = new Student("liushishi", 22);
		Student s6 = new Student("wuqilong", 40);
		Student s7 = new Student("fengqingy", 22);
		Student s8 = new Student("linqingxia", 29);

		// 添加元素
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
		ts.add(s6);
		ts.add(s7);
		ts.add(s8);

		// 遍历
		for (Student s : ts) {
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}

结果显示：符合设定的规定，先比较姓名长度，再比较年龄大小都是按照升序排序

         wuqilong---40

         fengqingy---22

         liushishi---22

         linqingxia---27

         linqingxia---29

         wanglihong---23

    zhangguorong---29

第二讲 Map

1.   Map概述

Map<K,V>接口存储键值对的元素，其中K代表的是键，V代表的是值，K是唯一的，不可重复的。

键与值的关系：

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

注意：Map集合的数据结构针对键有效，跟值无关

2.  Map的功能

1:添加功能

  V put(Kkey,V value):添加元素。

  如果键是第一次存储，就直接存储元素，返回null

  如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值

2:删除功能

 voidclear():移除所有的键值对元素

  Vremove(Object key)：根据键删除键值对元素，并把值返回

3:判断功能

  booleancontainsKey(Object key)：判断集合是否包含指定的键

 booleancontainsValue(Object value):判断集合是否包含指定的值

  booleanisEmpty()：判断集合是否为空

4:获取功能

  Set<Map.Entry<K,V>>entrySet():获取map所有键值对

  Vget(Object key):根据键获取值

  Set<K> keySet():获取集合中所有键的集合

  Collection<V> values():获取集合中所有值的集合

5：长度功能

      intsize()：返回集合中的键值对的对数

3.   集合的两种遍历方式

3.1   通过键找值：

思路：A:获取所有的键

               B:遍历键的集合，获取得到每一个键

        C:根据键去找值

             

public class MapDemo3 {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();

		// 创建元素并添加到集合
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("陈玄风", "梅超风");

		Set<String> set = map.keySet();
		for (String s : set) {
			String value = map.get(s);
			System.out.println(s + "---" + value);
		}
	}
}

注意：为什么通过Set存储键集合，因为Set集合具有唯一性的特点，且Set具备迭代器。所以可以通过迭代方式取出键，再通过get方法，获取每一个键对应的值。

3.2  键值对形式

思路：

A:获取所有键值对对象的集合

B:遍历键值对对象的集合，得到每一个键值对对象

          C:根据键值对对象获取键和值

public class MapDemo4 {
	public static void main(String[] args) {

		// 创建集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 创建元素并添加到集合
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("陈玄风", "梅超风");

		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);
		}
	}
}

4.    HashMap：

HashMap是基于哈希表的Map接口实现，哈希表的作用是保证键的唯一性

HashMap<K,V>,如果K为引用类型，需要重写内部的equals()和hashCode()方法

示例:一个引用类型的遍历

public class Student {
//省略部分代码
@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;
	}

}

测试代码

          

public class HashMapDemo4 {
	public static void main(String[] args) {

		// 创建集合对象
		HashMap<Student, String> hm = new HashMap<Student, String>();

		// 创建学生对象
		Student s1 = new Student("貂蝉", 27);
		Student s2 = new Student("王昭君", 30);
		Student s3 = new Student("西施", 33);
		Student s4 = new Student("杨玉环", 35);
		Student s5 = new Student("貂蝉", 27);
		// 添加元素
		hm.put(s1, "8888");
		hm.put(s2, "6666");
		hm.put(s3, "5555");
		hm.put(s4, "7777");
		hm.put(s5, "9999");

		Set<Student> set = hm.keySet();
		for (Student key : set) {
			String value = hm.get(key);
			System.out.println(key.getName() + "---" + key.getAge() + "---"
					+ value);
		}

	}
}

测试结果：重复的值根本就没有保存在map中

 

 

5.  TreeMap

TreeMap的键是红黑树结构，保证键的排序性和唯一性

依旧是两种排序方式：自然排序和比较器排序

示例：比较器排序

public class TreeMapDemo2 {
	public static void main(String[] args) {
		TreeMap<Student, String> tm = new TreeMap<Student, String>(
				new Comparator<Student>() {

					@Override
					public int compare(Student s1, Student s2) {
						// 主要条件
						int num = s1.getAge() - s2.getAge();
						// 次要条件
						int num2 = num == 0 ? s1.getName().compareTo(
								s2.getName()) : num;
						return num2;
					}

				});
		// 创建学生对象
		Student s1 = new Student("潘安", 30);
		Student s2 = new Student("柳下惠", 35);
		Student s3 = new Student("唐伯虎", 33);
		Student s4 = new Student("燕青", 32);
		Student s5 = new Student("唐伯虎", 33);

		// 存储元素
		tm.put(s1, "宋朝");
		tm.put(s2, "元朝");
		tm.put(s3, "明朝");
		tm.put(s4, "清朝");
		tm.put(s5, "汉朝");
		
		Set<Student> set = tm.keySet();
		for(Student key:set){
			String value = tm.get(key);
			System.out.println(key.getName() + "---" + key.getAge() + "---"
					+ value);
		}
	}
}
测试结果：可以看出“唐伯虎--33”元素并没有重复


第三讲 Collections

1. Collections类概述

针对集合操作的工具类，都是静态方法

2. 需要掌握的方法

  要知道的方法
  public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
  public static <T> int binarySearch(List<?> list,T key):二分查找
  public static <T> T max(Collection<?> coll):最大值
  public static void reverse(List<?> list):反转
  public static void shuffle(List<?> list):随机置换，每调一次，元素的位置随机换一次

示例：Collections类针对自定义对象的排序

/*
 * Collections可以针对ArrayList存储自定义对象的元素排序
 */
public class CollectionsDemo {
	public static void main(String[] args) {
		// 创建集合对象
		List<Student> list = new ArrayList<Student>();

		// 创建学生对象
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("风清扬", 30);
		Student s3 = new Student("刘晓曲", 28);
		Student s4 = new Student("武鑫", 29);
		Student s5 = new Student("林青霞", 27);

		// 添加元素对象
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add(s5);

		// 排序
		// 自然排序
		// Collections.sort(list);
		// 比较器排序
		// 如果同时有自然排序和比较器排序，以比较器排序为主
		Collections.sort(list, new Comparator<Student>() {
			@Override
			public int compare(Student s1, Student s2) {
				int num = s2.getAge() - s1.getAge();
				int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
						: num;
				return num2;
			}
		});

		// 遍历集合
		for (Student s : list) {
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}





xuyao22
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员-集合
u014300492的专栏
05-29 609
---------------------- android开发、java培训、期待与您交流！ ---------------------- 黑马程序员-集合 Collection层次结构的根接口。Collection表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则
集合框架（set、Map、Collections）
qq_52253798的博客
07-30 127
List 有序 ：访问顺序和插入顺序一致 添加了根据下标来操作元素 Set 参考 数学上集合的概念 无序（访问顺序和插入顺序不一致） 不允许重复 可以null 没有添加额外的方法 HashSet 最常用的实现类，此实现不是同步的 实际上是一个 HashMap 实例 LinkedHashSet 维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序 保证访问顺序...
Java基础——Java中的集合（List、Set、Map）以及Collections工具类（一万多字的精细总结）
haust_允谦的博客
01-09 851
Java中的集合 集合框架的概述 1、集合、数组都是对多个数据进行存储操作的结构，简称Java容器 说明：此时的存储，只要指的是内存层面的存储，不涉及到持久化的存储 2、数组在存储多个数据方面的特点： 一旦初始化以后，其长度就确定了 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据。比如：String[] arr, int[] arr1; 2.2、数组在存储多个数据方面的缺点： 一旦初始化，长度就不可修改 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效
黑马程序员--集合（Map以及Collections)
李大壮的专栏
08-07 257
Map集合：  |--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。  |--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.  |--TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。  Map集合存储和Collection有着很大不同：  Collec
黑马程序员-----集合
cui1kcan2的博客
06-30 614
JAVASE笔记—集合
黑马程序员--集合
大大男孩
01-02 552
------- android培训、java培训、期待与您交流！ ---------- 1：集合  (1)java是一种面向对象语言，如果我们要针对多个对象进行操作，就必须对多个对象进行存储。     而对多个元素进行存储，前面我们学习过数组，数组的弊端，长度固定。这样，数组将不能     满足变化的要求。所以，java就提供了集合供我们使用。  (2)集合的特点：   A:长度可以发
黑马程序员-集合框架
jyhonggang13848的专栏
10-29 320
——-android培训java培训期待与您交流!———-介绍 出现的原因：面向对象语言对事物的体现都是以对象的形式存在，为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。集合就是将若干用途、性质相同或相近的”数组”组合而成一个整体。 数组和集合的不同：数组可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。 集合的特点：集合只用
黑马程序员-集合总结
BekaCode的专栏
09-24 413
Collection接口 　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。 　　所
黑马程序员--集合框架：List、Set和Map体系
u014481780的博客
05-10 450
1、为什么出现集合类？ 面向对象对事物的体现都是以对象的形式，为了方便对多个对象的操作，就对对象进行存储。 集合就是存储对象最常用的一种方式. 2、数组和集合都是容器，两者有何不同？ 数组长度固定，而集合长度是可变的 数组值可以存储对象，还可以存储基本数据类型;而集合只能存储对象 数组存储数据类型是固定的，而集合存储的数据类型不固定 3、集合类的特点： 集合只能存储对象 集合的长
黑马程序员-Java语言进阶-源码、教程笔记.zip
12-16
day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda表达式 day08_File类、递归 day09_字节流、字符流 day10_缓冲流、转换流、...
黑马程序员--Java基础之集合框架（2）
AliceAutumn的专栏
11-25 1100
五、Map集合 1、Map集合特点：该集合存储键值对，一对一对往里存，而且要保证键的唯一性。 2、该接口主要方法：　*添加： V put(K key,V value);// put方法添加元素时，如果相同的键添加两次，那么后添加的值会覆盖原有键对应的值，并且put方法会返回该键原来对应的value值 void putAll(Mapm); *删除： void clear();//删除所
黑马程序员---Java数据结构
Most_want的博客
10-08 1114
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- 集合（Collection）是Java数据结构中的列表（List）、集（Set）、队列（Queue）等的超级接口。其中定义了公共的API。 除了特殊实现外，集合与数组的区别在于集合是无界的，可以保存任意多个元素。
黑马程序员---IO流
u011045065的专栏
06-30 1213
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 12、IO流 12.1、IO（Input Output）流    ·IO流用来处理设备之间的数据传输    ·java对数据的操作是通过流的方式    ·java用于操作流的对象都是在IO包中
2进制3位数过去现在将来输赢公式代码.txt
09-07
2进制3位数过去现在将来输赢公式代码
福州大学在广东2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
WordPress 集网址、资源、资讯于一体的导航类主题开心版
09-07
WordPress 集网址、资源、资讯于一体的导航类主题开心版； 运行环境 PHP7.4 + MYSQL5.6
【Java学习】activemq消息中间件学习demo.zip
09-07
【Java学习】activemq消息中间件学习demo.zip 【Java学习】activemq消息中间件学习demo.zip 【Java学习】activemq消息中间件学习demo.zip
爬取淘宝热销(热门)手机支架商品信息公开透明的数据集
09-07
本资源专注于收集淘宝热销(热门)手机支架商品信息，内容涵盖商品的店铺所在省份、城市位置、商品的名称、销售价格、累积销量、单价（以人民币计价）、付款的顾客人数、是否提供包邮服务、是否为天猫平台的商品，以及相关的满减优惠情况。这些详细的数据点均来源于淘宝平台的公开透明信息，经过精确抓取和整理，旨在为分析电商平台上的新品推荐策略和消费者购买行为提供实用数据。 这些数据严格遵循淘宝平台的公开政策和隐私保护原则获取，确保了信息的合法性与合规性。然而，本资源仅作为学习参考之用，意在帮助研究人员、市场分析师或学生等理解电商领域的商品推荐机制、销售动态及市场趋势。 任何将此数据用于商业目的或其他未授权的活动都是不恰当的，甚至可能触犯相关法律条款。 在使用这些数据进行学术研究或个人学习时，用户应自觉遵守相关法律法规，尊重数据来源和版权，正确引用数据源，并不得用于任何形式的商业盈利。 注意：这是一份数据集
Java集合框架详解：Collection、List、Set、Map
Collection接口有两个主要的子接口：Set和List。 - Set：不允许有重复元素，无序。代表性的实现类有HashSet、TreeSet等。 - List：有序，允许重复元素，通过索引访问。常见的实现类有ArrayList、LinkedList等。 - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值