Java开发必备点15_Set,Map集合

最新推荐文章于 2024-03-16 18:57:20 发布

炳烛之明科技

最新推荐文章于 2024-03-16 18:57:20 发布

阅读量114

点赞数

分类专栏： CoreJava 文章标签： java

本文链接：https://blog.csdn.net/qq_40828705/article/details/117431553

版权

CoreJava 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Set,Map集合

Set集合

概述

set集合是Collection根接口的子接口

特点

特点：
	1.无序
	2.不可索引
	3.不可重复
结构图如下

在这里插入图片描述

set集合中的方法

只有Collection中的方法

方法：
- public boolean add(E e)：  把给定的对象添加到当前集合中 。
- public boolean add(Colllection c):将集合c中的元素添加到当前集合中。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e): 把给定的对象在当前集合中删除。
- public boolean removeAll(Colllection c): 从当前集合中删除c集合中的元素。
- public boolean contains(E e): 判断当前集合中是否包含给定的对象。
- public boolean containsAll(Colllection c): 判断c是否是当前集合的子集。
- public boolean isEmpty(): 判断当前集合是否为空。
- public int size(): 返回集合中元素的个数。
- public Object[] toArray(): 把集合中的元素，存储到数组中。

set集合的实现类之HashSet

案例：
package cn.baizhi.day16;

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


public class Deo {
	public static void main(String[] args) {
		//创建一个set集合
		Set<String> set = new HashSet<>();
		
		//添加元素
		set.add("刘洋");
		set.add("古煜");
		set.add("火罐林");
		set.add("桑邦豪")
		set.add("许甲女");
		
		System.out.println(set.add("刘洋"));
		System.out.println(set.add("肖肃羽"));
		System.out.println(set.size());
		//遍历
		for (String string : set) {
			System.out.print(string+"  ");
		}
		
	}
}

遍历

foreach遍历：
代码：
for (String string : set) {
			System.out.print(string+"  ");
}

迭代器遍历：（了解）
代码:
Iterator<String> iterator = set.iterator();
		
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.println(string);
}

HashSet的去重原理

当重写了equals方法后 并没有调用equals方法进行判断两个对象是否为同一个对象 说明HashSet的去重不是只根据equals实现的

实现的原理：
	底层是一个数组的链表结构
	原理：重写hashCode方法是为了让相同的对象返回相同的hash值 放到相同下标位置从而去调用equals方法比较内容，如果结果为true说明是两个相同的对象 那么后者就不会再添加到集合中实现去重
java高级的编程语言  不能直接操作内存地址  每个对象都有地址  经过一个hash算法 返回一个int的值 
	
！！！！！！！注意：如果自定义对象想要去重 必须重写hashCode 和 equals方法 

HashSet去重 有特殊的需求 用Object里自带的hashCode满足不了需求  所以必须重写（自己的需求）  
案例：
package cn.baizhi.day16;

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



public class Demo {
	public static void main(String[] args) {
		//创建一个set集合
		Set<Student> students = new HashSet<>();
		
		//在集合中添加学生对象
		students.add(new Student("桑邦豪",20 ));
		students.add(new Student("火罐林",120 ));
		students.add(new Student("许甲女",66 ));
		students.add(new Student("古煜",77 ));
		students.add(new Student("刘洋",16 ));
		
		//再添加一个重复的元素
		System.out.println(students.add(new Student("刘洋", 16)));
		
		//遍历
		for (Student student : students) {
			System.out.println(student);
		}
		
	}
}

class Student{
	String name;
	int age;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals方法被调用了");
		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;
	}
	
	
}

案例：重写HashCode后
代码：
package cn.baizhi.day16;

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



public class Demo {
	public static void main(String[] args) {
		//创建一个set集合
		Set<Student> students = new HashSet<>();
		
		//在集合中添加学生对象
		students.add(new Student("桑邦豪",20 ));
		students.add(new Student("火罐林",120 ));
		students.add(new Student("许甲女",66 ));
		students.add(new Student("古煜",77 ));
		students.add(new Student("刘洋",16 ));
		
		
		//再添加一个重复的元素
		System.out.println(students.add(new Student("刘洋", 16)));
		
		//遍历
		for (Student student : students) {
			System.out.println(student.hashCode());
			System.out.println(student);
		}
		
	}
}

class Student{
	String name;
	int age;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", 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;
	}
}

LinkedHashSet

LinkedHashSet是HashSet的子类 
特点：具有HashSet的特点 可以去重  还可以维护元素的顺序

案例：
package cn.baizhi.day16;

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



public class Demo {
	public static void main(String[] args) {     
		//定义一个集合
		Set<String> strings = new LinkedHashSet<>();
		//Set<String> strings = new HashSet<>();
		//添加元素
		strings.add("火罐灵");
		strings.add("许甲半男不女");
		strings.add("肖肃羽毛飞");
		strings.add("古煜抽风");
		strings.add("刘洋正常");
		//遍历
		for (String string : strings) {
			System.out.println(string);
		}
	}
}

Set子接口SortedSet的实现类TreeSet

特点：能实现去重的同时 能够排序

案例：对字符串排序
代码：
package cn.baizhi.day16;

import java.util.Set;
import java.util.TreeSet;


public class Demo {
	public static void main(String[] args) {     
		//定义一个集合
		Set<String> strings = new TreeSet<>();
		
		//添加元素
		strings.add("c");
		strings.add("d");
		strings.add("a");
		strings.add("e");
		strings.add("b");
		strings.add("d");
		//遍历
		for (String string : strings) {
			System.out.println(string);
		}
	}
}

案例：对自定义的对象
代码：
package cn.baizhi.day16;

import java.util.Set;
import java.util.TreeSet;




public class Demo {
	public static void main(String[] args) {     
		//定义一个TreeSet
		Set<Student> students = new TreeSet<>();
		
		//添加元素
		students.add(new Student("火罐灵", 21));
		students.add(new Student("刘洋",15 ));
		students.add(new Student("许甲半男不女",34 ));
		students.add(new Student("肖肃羽人妖",45 ));
		students.add(new Student("古煜变性",56 ));
		students.add(new Student("刘洋", 15));
		students.add(new Student("桑邦豪", 15));
		//遍历
		for (Student student : students) {
			System.out.println(student);
		}
	}
}

//学生类
class Student implements Comparable<Student>{
	String name;
	int age;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Student o) {
		//如果年龄不相等 返回差
		if (this.age!=o.age) {
			return this.age-o.age;
		}else {
			//return this.name.hashCode()-o.name.hashCode();
            return this.name.compareTo(o.name);//这个更优化
		}
		
	}
}

Map集合

Map集合的概述

特点：
map集合是一个双列集合
数据的存储形式是以 Key---Value 形式  键值对
key  无序 键是不可以重复的  key的数据类型可以是任意对象类型
value  值是可以重复的 value的数据类型可以是任意对象类型

HashSet的底层是用一个HashMap实现的 键为任意类型 值都为Object类型

结构图

在这里插入图片描述

Map集合的方法

put(Objecdt key，Object value ):向map中存放一个键值对,
	说明：如果key在map中已经存在，则新值覆盖旧值，将旧值返回
		 如果key在map中不存在，则直接添加到map中 返回值为null
remove（ object key ）:根据key的删除map集合中的1个键值对 
get（Object key）:根据key查询对应的值
boolean  containsKey（object key）：判断map集合中是否包含为key的键 返回true  false
boolean  containsValue（object value）:判断集合中受否存在包含value的值 返回true/false
int size（） 集合中键值对的数量

案例：
package cn.baizhi.day16;

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


public class Demo {
	public static void main(String[] args) {     
		//创建一个map集合
		Map<Integer, String> map = new HashMap<>();
		
		//放元素
		
		map.put(1, "刘洋");
		map.put(2, "火罐灵");
		map.put(3, "古煜");
		map.put(4 ,"许甲楠");
		map.remove(2);
		System.out.println(map.size());
		/*
		boolean b = map.containsKey(3);
		System.out.println(b);*/
		
		boolean f = map.containsValue("火罐灵");
		System.out.println(f);
		//通过key 访问 value
		System.out.println(map.get(2));
	}
}

遍历

第一种：通过 keySet（）获取到key的集合  通过遍历这个key的set集合 遍历每个值
案例：
package cn.baizhi.day16;

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


public class Demo {
	public static void main(String[] args) {     
		//创建一个map集合
		Map<Integer, String> map = new HashMap<>();
		//放元素
		map.put(1, "刘洋");
		map.put(2, "火罐灵");
		map.put(3, "古煜");
		map.put(4 ,"许甲楠");
		
		//1.通过keySet方法获得一个key的集合
		Set<Integer> set = map.keySet();
		
		for (Integer key : set) {
			System.out.println(map.get(key));
		}
		
	}
}


第二种方法：
案例：
package cn.baizhi.day16;

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


public class Demo {
	public static void main(String[] args) {     
		//创建一个map集合
		Map<Integer, String> map = new HashMap<>();
		//放元素
		map.put(1, "刘洋");
		map.put(2, "火罐灵");
		map.put(3, "古煜");
		map.put(4 ,"许甲楠");
		
		//2 通过values方法 获得map中所有值的集合 遍历这个集合
		Collection collection = map.values();
		
		for (Object object : collection) {
			System.out.println(object);
		}
		
	}
}

Map集合的其他实现类

Hashtable:垃圾  没人用  线程安全的的  效率低 不允许键和值 为null
HashMap：可以允许 键和值为 null 线程不安全 效率比较高
案例：
package cn.baizhi.day17;
import java.util.HashMap;
import java.util.Map;
public class Demo {
	public static void main(String[] args) {     
		Map<Integer, String> map = new HashMap<Integer, String>();
		
		map.put(null, null);
		
		System.out.println(map.get(null));
	}
}
========================================================================================

LinkedHashMap：
案例：
package cn.baizhi.day17;


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


public class Demo {
	public static void main(String[] args) {     
		//Map<String, String> map = new HashMap<>();
		Map<String, String> map = new LinkedHashMap<>();
		//添加元素
		map.put("c", "刘洋");
		map.put("a", "火罐灵");
		map.put("b", "许甲楠");
		map.put("e", "肖肃羽");
		
		//遍历
		Set<String> set = map.keySet();
		for (String string : set) {
			System.out.println(string+" ---- "+map.get(string));
		}
	}
}
======================================================================================
 Propreties: 键和值都是 String 类型   
案例：
package cn.baizhi.day17;


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


public class Demo {
	public static void main(String[] args) {     
		Properties properties = new Properties();
		properties.setProperty("s", "asdhjf");
		//properties.setProperty(1, 3);
		String string =  properties.getProperty("s");
		System.out.println(string);
	}
}


=========================================================================================
 TreeMap
 案例：对于 String 类型的键 进行排序
 Map<String, String> map = new TreeMap<>();
		
		//添加元素
		map.put("c", "刘洋");
		map.put("a", "火罐灵");
		map.put("e", "古煜");
		map.put("g", "肖肃羽");
		map.put("b", "许甲楠");
		
		//遍历
		Set<String> set = map.keySet();
		for (String string : set) {
			System.out.println(string+"  "+map.get(string));
		}


案例：对于自定义对象的排序
代码：
package cn.baizhi.day17;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;



public class Demo {
	public static void main(String[] args) {     
		Map<Student, String> map = new TreeMap<>();
		
		//添加元素
		map.put(new Student("刘洋",13 ) , "刘洋");
		map.put(new Student("火罐灵",28 ) , "霍冠霖");
		map.put(new Student("张三",34 ) , "张三");
		map.put(new Student("李四", 67) , "李四");
		
		//遍历
		Set<Student> set = map.keySet();
		for (Student student : set) {
			System.out.println(student+"  "+map.get(student));
		}
		
	}
}

class Student implements Comparable<Student>{
	private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Student() {
		super();
	}
	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 String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Student o) {
		return this.age - o.age;
	}
}




}

class Student implements Comparable<Student>{
	private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Student() {
		super();
	}
	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 String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Student o) {
		return this.age - o.age;
	}
}

炳烛之明科技

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Java开发必备点15_Set,Map集合

Set,Map集合Set集合概述set集合是Collection根接口的子接口特点特点： 1.无序 2.不可索引 3.不可重复结构图如下set集合中的方法只有Collection中的方法方法：- public boolean add(E e)：把给定的对象添加到当前集合中。- public boolean add(Colllection c):将集合c中的元素添加到当前集合中。- public void clear() :清空集合中所有的元素。- public
复制链接

扫一扫