集合补充

最新推荐文章于 2024-07-14 14:59:27 发布

保佑不出bug

最新推荐文章于 2024-07-14 14:59:27 发布

阅读量1.8k

点赞数

文章标签：列表 hashmap java hashtable

本文链接：https://blog.csdn.net/weixin_44310465/article/details/110881195

版权

一、Collections（掌握）

1.1 定义

操作集合的工具类
提供了增删改查集合的方法
类在java.util包
不能参加实例对象，方法都是静态的

1.2 常用方法

addAll(Collection<? super T> c, T... elements) 
          将所有指定元素添加到指定 collection 中。
emptyList() 
          返回空的列表（不可变的）。
fill(List<? super T> list, T obj) 
          使用指定元素替换指定列表中的所有元素。
max(Collection<? extends T> coll) 
          根据元素的自然顺序，返回给定 collection 的最大元素。
reverse(List<?> list) 
          反转指定列表中元素的顺序。
shuffle(List<?> list) 
          使用默认随机源对指定列表进行置换。
sort(List<T> list, Comparator<? super T> c) 
          根据指定比较器产生的顺序对指定列表进行排序。 
swap(List<?> list, int i, int j) 
          在指定列表的指定位置处交换元素。

案例

package com.qf.colls;

import java.util.ArrayList;
import java.util.Collections;

public class Demo01 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("孙悟空");
		list.add("猪八戒");
		
		Collections.addAll(list, "沙和尚","白龙马","金角大王","银角大王");
		System.out.println(list);
		
		Collections.reverse(list);
		System.out.println(list);
		
		Collections.shuffle(list);
		System.out.println(list);
		
		Collections.sort(list);
		System.out.println(list);
	}
}

二、Set接口（掌握）

2.1 定义

无序、无下标、元素不可重复
一个不包含重复元素的 collection。
更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1和e2，并且最多包含一个 null 元素。
正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

2.2 常用方法

方法摘要 
 boolean add(E e) 
          如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。 
 boolean addAll(Collection<? extends E> c) 
          如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。 
 void clear() 
          移除此 set 中的所有元素（可选操作）。 
 boolean contains(Object o) 
          如果 set 包含指定的元素，则返回 true。 
 boolean containsAll(Collection<?> c) 
          如果此 set 包含指定 collection 的所有元素，则返回 true。 
 boolean equals(Object o) 
          比较指定对象与此 set 的相等性。 
 int hashCode() 
          返回 set 的哈希码值。 
 boolean isEmpty() 
          如果 set 不包含元素，则返回 true。 
 Iterator<E> iterator() 
          返回在此 set 中的元素上进行迭代的迭代器。 
 boolean remove(Object o) 
          如果 set 中存在指定的元素，则将其移除（可选操作）。 
 boolean removeAll(Collection<?> c) 
          移除 set 中那些包含在指定 collection 中的元素（可选操作）。 
 boolean retainAll(Collection<?> c) 
          仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。 
 int size() 
          返回 set 中的元素数（其容量）。 
 Object[] toArray() 
          返回一个包含 set 中所有元素的数组。 
<T> T[] 
 toArray(T[] a) 
          返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

2.3 遍历

因为Set集合元素没有下标，所以无法通过下标获取元素
可以使用foreach和迭代器遍历set集合

三、HashSet（掌握）

3.1 定义

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。
它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
此类允许使用 null 元素。
HashSet可以对存入的元素进行去重的处理，基于hashcode和equals运算的结果

3.2 案例

package com.qf.set;

import java.util.HashSet;

public class Demo02 {
	public static void main(String[] args) {
		HashSet<Stu> set = new HashSet<Stu>();
		set.add(new Stu(11, "张三", 21, "男性"));	
		set.add(new Stu(11, "张三", 21, "男性"));	
		set.add(new Stu(11, "张三", 21, "男性"));	
		set.add(new Stu(11, "张三", 21, "男性"));	
		
		System.out.println(set);
		
		Stu stu01 = new Stu(11, "张三", 21, "男性");
		Stu stu02 = new Stu(21, "张三", 11, "男性");
		System.out.println(stu01.hashCode());
		System.out.println(stu02.hashCode());
	}
}

class Stu{
	private int id;
	private String name;
	private int age;
	private String gender;
	
	public Stu() {
		super();
	}

	public Stu(int id, String name, int age, String gender) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((gender == null) ? 0 : gender.hashCode());
		result = prime * result + id;
		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;
		Stu other = (Stu) obj;
		if (age != other.age)
			return false;
		if (gender == null) {
			if (other.gender != null)
				return false;
		} else if (!gender.equals(other.gender))
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Stu [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
	
}

不同对象hash值相同的情况

package com.qf.set;

import java.util.HashSet;

public class Demo03 {
	public static void main(String[] args) {
		Student stu01 = new Student(11, 22);
		Student stu02 = new Student(22, 11);
		
		System.out.println(stu01.hashCode());
		System.out.println(stu02.hashCode());
		final int prime = 31;
		int result = 1;
		
		HashSet<Integer> sets = new HashSet<Integer>();
		int count = 0;
		
		for (int i = 0; i < 1000; i++) {
			for (int j = 0; j < 1000; j++) {
				if (i != j) {
					result = prime * result + i;
					result = prime * result + j;
					sets.add(result);
					count++;
				}
			}
		}
		System.out.println(sets.size());
		System.out.println(count);
	}
}

class Student{
	int id;
	int age;
	public Student(int id, int age) {
		super();
		this.id = id;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", age=" + age + "]";
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		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 (id != other.id)
			return false;
		return true;
	}
}

3.3 创建对象

构造方法摘要 
HashSet() 
          构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 
HashSet(Collection<? extends E> c) 
          构造一个包含指定 collection 中的元素的新 set。 
HashSet(int initialCapacity) 
          构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。 
HashSet(int initialCapacity, float loadFactor) 
          构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子。

3.4 HashSet常用方法

package com.qf.set;

import java.util.Arrays;
import java.util.HashSet;

public class Demo05 {
	public static void main(String[] args) {
		/**
		 * 增加
		 * 	add
		 * 	addAll
		 * 
		 * 删除
		 * 	remove
		 * 	clear
		 * 	removeAll
		 * 	retainAll
		 * 
		 * 修改
		 * 	暂无
		 * 
		 * 查看
		 * 	contains
		 * 	containsAll
		 * 	hashCode
		 * 	isEmpty
		 * 	size
		 * 	equals
		 * 
		 * 其他
		 * 	toArray
		 * 	iterator
		 */
		HashSet<String> set = new HashSet<String>();
		set.add("张三");
		set.add("李四");
		set.add("王五");
		set.add("赵柳");
		set.add("张三");
		
		System.out.println(set.contains("张三"));
		
		set.remove("张三");
		System.out.println(set);
		
		System.out.println(set.contains("张三"));
		
		Object[] arr = set.toArray();
		System.out.println(Arrays.toString(arr));
		
		System.out.println(arr[0].getClass().getName());
		String name = (String) arr[0];
		System.out.println(name.getClass().getName());
	}
}

3.5 遍历集合

package com.qf.set;

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

public class Demo06 {
	public static void main(String[] args) {
		/**
		 * 因为set集合中的元素没有下标，所以无法通过下标获取这些元素
		 * 使用下标遍历集合的方式就失效了
		 * 可以使用不需要下标的方式来遍历
		 * 	foreach
		 * 	iterator
		 */
		HashSet<String> set = new HashSet<String>();
		set.add("张三");
		set.add("李四");
		set.add("王五");
		set.add("赵柳");
		set.add("张三");
		
		System.out.println("===============foreach================");
		for (String name : set) {
			System.out.println(name);
		}
		
		System.out.println("===============iterator================");
		Iterator<String> its = set.iterator();
		while(its.hasNext()) {
			// String name = its.next();
			System.out.println(its.next());
		}
	}
}

四、TreeSet（掌握）

4.1 定义

基于 TreeMap 的 NavigableSet 实现。
使用元素的自然顺序对元素进行排序，
或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

4.2 创建对象

4.2.1 空参创建

TreeSet() 
          构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。 
TreeSet(Collection<? extends E> c) 
          构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。 
TreeSet(Comparator<? super E> comparator) 
          构造一个新的空 TreeSet，它根据指定比较器进行排序。 
TreeSet(SortedSet<E> s) 
          构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

package com.qf.treeset;

import java.util.TreeSet;

public class Demo01 {
	public static void main(String[] args) {
		TreeSet<String> set = new TreeSet<String>();
		set.add("Lucy");
		set.add("Poly");
		set.add("Mr Wang");
		set.add("Rose");
		set.add("Jack");
		set.add("Jack");
		
		System.out.println(set);
		
		TreeSet<Stu> stus = new TreeSet<Stu>();
		stus.add(new Stu(11, "张三", 21, "男性"));	
		stus.add(new Stu(12, "张三", 21, "男性"));	
		stus.add(new Stu(13, "张三", 21, "男性"));	
		stus.add(new Stu(14, "张三", 21, "男性"));
		
		System.out.println(stus);
	}
}

class Stu{
	private int id;
	private String name;
	private int age;
	private String gender;
	
	public Stu() {
		super();
	}

	public Stu(int id, String name, int age, String gender) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((gender == null) ? 0 : gender.hashCode());
		result = prime * result + id;
		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;
		Stu other = (Stu) obj;
		if (age != other.age)
			return false;
		if (gender == null) {
			if (other.gender != null)
				return false;
		} else if (!gender.equals(other.gender))
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Stu [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
	
}

4.2.2 TreeSet中的对象需要具有可比较性

package com.qf.treeset;

import java.util.TreeSet;

public class Demo02 {
	public static void main(String[] args) {
		TreeSet<Student> stus = new TreeSet<Student>();
		stus.add(new Student(2016020305, "张娜", 23, "女"));
		stus.add(new Student(2016020303, "张娜拉", 23, "女"));
		stus.add(new Student(2016020307, "张娜娜", 23, "女"));
		stus.add(new Student(2016020307, "张拉娜", 23, "女"));
		System.out.println(stus);
	}
}

/**
 * 我们把Set集合的泛型设置成Student	
 * 	但是TreeSet集合中的元素需要具有可比较性
 * 	所以Student实现comparable接口，重写compareTo方法
 * 	在方法中自定义比较的规则
 * @author Dushine2008
 * @version
 * @date 2020年6月10日
 */
class Student implements Comparable<Student>{
	
	private int id;
	private String name;
	private int age;
	private String gender;
	
	public Student() {
		super();
	}

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

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((gender == null) ? 0 : gender.hashCode());
		result = prime * result + id;
		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 (gender == null) {
			if (other.gender != null)
				return false;
		} else if (!gender.equals(other.gender))
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}

	@Override
	public int compareTo(Student s) {
		int ret = this.id - s.id;
		// 年龄是否相同
		if (ret == 0) {
			ret = this.age - s.age;
			// 姓名是否相同
			if (ret == 0) {
				ret = this.name.hashCode() - s.name.hashCode();
			}
		}
		return ret;
	}
	
}

4.2.3 传入比较器

package com.qf.treeset;

import java.util.Comparator;
import java.util.TreeSet;

public class Demo03 {
	public static void main(String[] args) {
		// 在创建TreeSet对象的时候传入Comparator对象,这里采用了匿名对象的方式
		TreeSet<Person> persons = new TreeSet<Person>(new Comparator<Person>() {

			@Override
			public int compare(Person p1, Person p2) {
				int ret = p1.getId() - p2.getId();
				if (ret == 0) {
					ret = p1.getName().hashCode() - p2.getName().hashCode();
				}
				return ret;
			}
		});
		
		persons.add(new Person(2016020305, "张一娜", 23, "女"));
		persons.add(new Person(2016020307, "张二娜", 23, "女"));
		persons.add(new Person(2016020303, "张三娜", 23, "女"));
		persons.add(new Person(2016020302, "张四娜", 23, "女"));
		persons.add(new Person(2016020309, "张五娜", 23, "女"));
		
		System.out.println(persons);
	}
}


class Person{
	private int id;
	private String name;
	private int age;
	private String gender;
	
	public Person() {
		super();
	}

	public Person(int id, String name, int age, String gender) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((gender == null) ? 0 : gender.hashCode());
		result = prime * result + id;
		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;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (gender == null) {
			if (other.gender != null)
				return false;
		} else if (!gender.equals(other.gender))
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

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

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}

package com.qf.treeset;

import java.util.Comparator;
import java.util.TreeSet;

public class Demo04 {
	public static void main(String[] args) {
		// 在创建TreeSet对象的时候传入Comparator对象,这里采用了先创建Comparator对象的方式
		Comparator<People> comparator = new Comparator<People>() {

			@Override
			public int compare(People p1, People p2) {
				int ret = 0;
				ret = p1.getId() - p2.getId();
				return ret == 0 ? p1.getName().hashCode()-p2.getName().hashCode() : ret;
			}
		};
		// 创建TreeSet对象
		TreeSet<People> peoples = new TreeSet<People>(comparator);
		peoples.add(new People(2016020305, "张一娜", 23, "女"));
		peoples.add(new People(2016020307, "张二娜", 23, "女"));
		peoples.add(new People(2016020303, "张三娜", 23, "女"));
		peoples.add(new People(2016020302, "张四娜", 23, "女"));
		peoples.add(new People(2016020309, "张五娜", 23, "女"));
		
		System.out.println(peoples);
	}
}

/**
 * 创建普通的Person对象就可以
 * 在TreeSet的构造方法中传入比较器
 * @author Dushine2008
 * @version
 * @date 2020年6月10日
 */
class People{
	private int id;
	private String name;
	private int age;
	private String gender;
	
	public People() {
		super();
	}

	public People(int id, String name, int age, String gender) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((gender == null) ? 0 : gender.hashCode());
		result = prime * result + id;
		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;
		People other = (People) obj;
		if (age != other.age)
			return false;
		if (gender == null) {
			if (other.gender != null)
				return false;
		} else if (!gender.equals(other.gender))
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

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

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	@Override
	public String toString() {
		return "People [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}

五、LinkedHashSet

5.1 定义

具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。
此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。
注意，插入顺序不受在 set 中重新插入的 元素的影响。

5.2 创建对象

构造方法摘要 
LinkedHashSet() 
          构造一个带默认初始容量 (16) 和加载因子 (0.75) 的新空链接哈希 set。 
LinkedHashSet(Collection<? extends E> c) 
          构造一个与指定 collection 中的元素相同的新链接哈希 set。 
LinkedHashSet(int initialCapacity) 
          构造一个带指定初始容量和默认加载因子 (0.75) 的新空链接哈希 set。 
LinkedHashSet(int initialCapacity, float loadFactor) 
          构造一个带有指定初始容量和加载因子的新空链接哈希 set。

package com.qf.linkedhashset;

import java.util.LinkedHashSet;

public class Demo01 {
	public static void main(String[] args) {
		LinkedHashSet<String> set = new LinkedHashSet<String>();
		
		set.add("Lucy");
		set.add("Jack");
		set.add("Alice");
		set.add("Tom");
		set.add("Jack");
		set.add("Tony");
		
		System.out.println(set);
		
	}
}

5.3 HashSet和LinkedHashSet比较

LinkedHashSet继承自HashSet，自己的方法很少，多数方法和HashSet相同
HashSet是有HashMap实现的，HashSet有数组、链表、hash去重的特点
LinkedHashSet继承了HashSet，自己又实现了链表，所以是一个双重链表结构的set集合

六、Map

6.1 定义

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。
集合中的key是惟一的，每个key能映射一个value
集合中的值不是惟一的，值可以出现多次

七、HashMap（掌握）

7.1 定义

基于哈希表的 Map 接口的实现。
此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。

7.2 创建对象

构造方法摘要 
HashMap() 
          构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 
HashMap(int initialCapacity) 
          构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。 
HashMap(int initialCapacity, float loadFactor) 
          构造一个带指定初始容量和加载因子的空 HashMap。 
HashMap(Map<? extends K,? extends V> m) 
          构造一个映射关系与指定 Map 相同的新 HashMap。

package com.qf.map;

import java.util.HashMap;

public class Demo02 {
	public static void main(String[] args) {
		/**
		 * 	构造方法摘要 
			HashMap() 
			          构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 
			HashMap(int initialCapacity) 
			          构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。 
			HashMap(int initialCapacity, float loadFactor) 
			          构造一个带指定初始容量和加载因子的空 HashMap。 
			HashMap(Map<? extends K,? extends V> m) 
			          构造一个映射关系与指定 Map 相同的新 HashMap。 
		 */
		
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(10010, "中国联合通讯集团");
		map.put(10000, "中国电信集团");
		map.put(10086, "中国移动通讯集团");
		map.put(95595, "中国光大银行");
		
		System.out.println(map);
		
		HashMap<Integer, String> map1 = new HashMap<Integer, String>();
		map1.put(95585, "中华保险");
		map1.put(12315, "消费者权益保护协会");
		map1.put(95597, "华泰证券");
		
		HashMap<Integer, String> map2 = new HashMap<Integer, String>(map);
		System.out.println(map2);
		
	}
}

7.3 常用方法

7.3.1 添加

package com.qf.map;

import java.util.HashMap;

public class Demo03 {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
			 V put(K key, V value) 
			          在此映射中关联指定值与指定键。 
			 void putAll(Map<? extends K,? extends V> m) 
			          将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。 
		 */
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(10010, "中国联合通讯集团");
		map.put(10000, "中国电信集团");
		map.put(10086, "中国移动通讯集团");
		map.put(95595, "中国光大银行");
		
		System.out.println(map);
		
		HashMap<Integer, String> map1 = new HashMap<Integer, String>();
		map1.put(95585, "中华保险");
		map1.put(12315, "消费者权益保护协会");
		map1.put(95597, "华泰证券");
		
		// 把另一个map添加进来
		map.putAll(map1);
		System.out.println(map);
		
		map1.putAll(map1);
		System.out.println(map1);
	}
}

7.3.2 删除

package com.qf.map;

import java.util.HashMap;

public class Demo04 {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
			 void clear() 
			          从此映射中移除所有映射关系。 
			 V remove(Object key) 
			          从此映射中移除指定键的映射关系（如果存在）。 
		 */
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(10010, "中国联合通讯集团");
		map.put(10000, "中国电信集团");
		map.put(10086, "中国移动通讯集团");
		map.put(95595, "中国光大银行");
		System.out.println(map);
		
		HashMap<Integer, String> map1 = new HashMap<Integer, String>();
		map1.put(95585, "中华保险");
		map1.put(12315, "消费者权益保护协会");
		map1.put(95597, "华泰证券");
		System.out.println(map1);
		
		String remove = map.remove(95595);
		System.out.println(remove);
		System.out.println(map);
		
		boolean b = map.remove(10086, "中国移动通讯集团");
		System.out.println(b);
		System.out.println(map);
	}
}

7.3.3 修改

package com.qf.map;

import java.util.HashMap;

public class Demo05 {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
			 V put(K key, V value) 
			          在此映射中关联指定值与指定键。 
			 void putAll(Map<? extends K,? extends V> m) 
			          将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。 
		 */
		
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(10010, "中国联合通讯集团");
		map.put(10000, "中国电信集团");
		map.put(10086, "中国移动通讯集团");
		map.put(95595, "中国光大银行");
		
		System.out.println(map);
		
		HashMap<Integer, String> map1 = new HashMap<Integer, String>();
		map1.put(95585, "中华保险");
		map1.put(12315, "消费者权益保护协会");
		map1.put(95597, "华泰证券");
		map1.put(95595, "中国光大银行集团");
		
		map.putAll(map1);
		System.out.println(map);
	}
}

7.3.4 查询

package com.qf.map;

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

public class Demo06 {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
			 boolean containsKey(Object key) 
			          如果此映射包含对于指定键的映射关系，则返回 true。 
			 boolean containsValue(Object value) 
			          如果此映射将一个或多个键映射到指定值，则返回 true。 
			 Set<Map.Entry<K,V>> entrySet() 
			          返回此映射所包含的映射关系的 Set 视图。 
			 V get(Object key) 
			          返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。 
			 boolean isEmpty() 
			          如果此映射不包含键-值映射关系，则返回 true。 
			 Set<K> keySet() 
			          返回此映射中所包含的键的 Set 视图。 
			 int size() 
			          返回此映射中的键-值映射关系数。 
			 Collection<V> values() 
			          返回此映射所包含的值的 Collection 视图。 
		 */
		
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(10010, "中国联合通讯集团");
		map.put(10000, "中国电信集团");
		map.put(10086, "中国移动通讯集团");
		map.put(95595, "中国光大银行");
		System.out.println(map);
		
		HashMap<Integer, String> map1 = new HashMap<Integer, String>();
		map1.put(95585, "中华保险");
		map1.put(12315, "消费者权益保护协会");
		map1.put(95597, "华泰证券");
		System.out.println(map1);
		
		
		System.out.println(map.containsKey(10010));
		System.out.println(map.containsKey(10011));
		
		System.out.println(map.containsValue("中国电信集团"));
		System.out.println(map.containsValue("中国电信集团有限责任公司"));
		
		System.out.println(map.entrySet());
		
		Set<Entry<Integer,String>> entrys = map.entrySet();
		System.out.println(entrys);
		
		System.out.println(map.get(10010));
		System.out.println(map.get(10011));
		
		System.out.println(map.keySet());
		Set<Integer> keys = map.keySet();
		System.out.println(keys);
		
		Collection<String> values = map.values();
		System.out.println(values);
		
	}
}

八、今日总结

把学习到的集合的所有内容总结到一张表格中–建议使用PPT做表格

保佑不出bug

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合补充

一、Collections（掌握）1.1 定义操作集合的工具类提供了增删改查集合的方法类在java.util包不能参加实例对象，方法都是静态的1.2 常用方法addAll(Collection<? super T> c, T... elements) 将所有指定元素添加到指定 collection 中。emptyList() 返回空的列表（不可变的）。fill(List<? super T> list, T obj)
复制链接

扫一扫