Day15，16笔记--集合

最新推荐文章于 2024-10-05 22:51:28 发布

supzyh

最新推荐文章于 2024-10-05 22:51:28 发布

阅读量97

点赞数

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/supzyh/article/details/130019303

版权

Java学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

JavaSE基础

文章目录

JavaSE基础

一、Collection

1.1 概述

Collection 层次结构 中的根接口。
Collection 表示一组对象，这些对象也称为 collection 的元素【集合中只能存储引用类型】。
一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。
JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。
此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

1.2 Collection体系

增删改查

package com.javastudy;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class TestCollect {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
		 * 增
			 boolean add(E e) 
			          确保此 collection 包含指定的元素（可选操作）。 
			 boolean addAll(Collection<? extends E> c) 
			          将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。 
		 
		 * 删
			 boolean remove(Object o) 
			          从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。 
			 boolean removeAll(Collection<?> c) 
			          移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。 
			 void clear() 
			          移除此 collection 中的所有元素（可选操作）。 
		
		 * 改
		 
		 * 查
			 int size() 
			          返回此 collection 中的元素数。 
			 boolean isEmpty() 
			          如果此 collection 不包含元素，则返回 true。 
			 boolean contains(Object o) 
			          如果此 collection 包含指定的元素，则返回 true。 
			 boolean containsAll(Collection<?> c) 
			          如果此 collection 包含指定 collection 中的所有元素，则返回 true。 
			 boolean retainAll(Collection<?> c) 
			          仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。 
		 */
		/**
		 * 	创建集合对象
		 * 		多态方式创建对象：
		 * 			声明的容器对象类型是接口，实际创建的对象类型是实现类
		 * 		声明了容器对象中的元素类型是String【泛型】
		 */
		
		Collection<String> sup = new ArrayList<String>();
		
		//添加数据
		sup.add("Spider-Man");
		sup.add("Iron Man");
		sup.add("Captain America");
		
		
		//输出
		System.out.println(sup.toString());
		
		
		Collection<String> other = new ArrayList<String>();
		other.add("Black Widow");
		other.add("Hulk");
		other.add("Black Panther");
		other.add("Deadpool");
		other.add("Hawkeye");
		other.add("Thor");
		
		other.addAll(sup);
		System.out.println(other.toString());
		
		// 删除数据,有布尔类型的返回值,表示删除是否成功
		other.remove("Hulk");
		System.out.println(other);
		
		// 移除两个集合中交集部分
		other.removeAll(sup);
		System.out.println(other);
		
		System.out.println("集合中元素的数量:" + other.size());
		// 清空集合
		// other.clear();
		
		
		// 集合中是否包含指定元素
		System.out.println(other.contains("Thor"));

		
		// 是否完全包含另一个集合中的数据
		other.addAll(sup);
		System.out.println(other.containsAll(sup));

		
		// 在c集合中留下两个集合中交集部分内容
		sup.retainAll(other);
		System.out.println(sup);
		
		
	
	}

}

遍历集合【重点】【掌握】

	
		/**
		 * 遍历
		 * 	foreach
		 * 	iterator
		 */

		
		/**
		 * 	foreach
			for(数据类型 变量名 : 容器对象){
			}
			
			容器对象:
				数组、集合
			数据类型：
				容器中元素的类型
			变量名字：
				临时变量名字，用来存储容器中的每一个元素
		 */
		
		for (String supers : other) {
			System.out.print(supers+"  ");
		}
		
		/**
		 *	迭代器
		 *		先使用获取迭代器对象：
		 *			调用集合的iterator()方法
		 *		使用循环从迭代器中获取每一个元素
		 *			使用while循环
		 */
		Iterator<String> it = other.iterator();
		String name = null;
		System.out.println();
		
		// 不断地判定是否有下一个数据
		while (it.hasNext()) {
			// 获取下一个对象,顺便把游标向下移动			
			name = it.next();	
			System.out.println(name);
		}

二、List

2.1 概述

有序地Collection
- 元素有索引
- 元素能重复
每个元素的插入位置进行精确地控制。
以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
List 接口在中的方法超过了 Collection接口中指定的约定。
- 包含Collection中继承的方法 + List接口中独有的方法

2.2 实现类

ArrayList【重点】

基于数组实现的

LinkedList

基于链表实现的
查询数据速度慢，增删数据速度快

Vector

基于数组 && 线程安全的
Vector 是同步的。

三、ArrayList

3.1 概述

List 接口的大小可变数组的实现。
- ArrayList容量可变，长度可变
- 基于数组实现
提供一些方法来操作内部用来存储列表的数组的大小。
- ensureCapacity
- trimToSize
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。
它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。
在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList
实例的容量。这可以减少递增式再分配的数量。

3.2 创建对象

package com.javastudy;

import java.util.ArrayList;
import java.util.List;

public class TestArrayList {
	public static void main(String[] args) {
		/**
		 * 构造方法摘要 
			ArrayList() 
			          构造一个初始容量为 10 的空列表。 
			ArrayList(int initialCapacity) 
			          构造一个具有指定初始容量的空列表。 
			ArrayList(Collection<? extends E> c) 
			          构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。 
		 */
		
		//  构造一个初始容量为 10 的空列表。 默认为10
		ArrayList<String> list01 = new ArrayList<String>();
		//  构造一个具有指定初始容量的空列表。 
		ArrayList<String> list02 = new ArrayList<String>(1024);
		list02.add("Hello");
		list02.add("World");
		System.out.println(list02);
		// 基于其他集合创建List集合对象,包含其他集合中的数据
		ArrayList<String> list03 = new ArrayList<String>(list02);
		System.out.println(list03+"list03");
        	}
		
}

3.3 常用方法

增删

	
		/**
		方法摘要 
		增
		 boolean add(E e) 
		          将指定的元素添加到此列表的尾部。 
		 void add(int index, E element) 
		          将指定的元素插入此列表中的指定位置。 
		 boolean addAll(Collection<? extends E> c) 
		          按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。 
		 boolean addAll(int index, Collection<? extends E> c) 
		          从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。 
		
		删
		 E remove(int index) 
		          移除此列表中指定位置上的元素。 
		 boolean remove(Object o) 
		          移除此列表中首次出现的指定元素（如果存在）。 
		 void clear() 
		          移除此列表中的所有元素。 
		 removeAll
		 	移除两个集合中重复的内容
	 */
		// 创建集合
		ArrayList<String> list04 = new ArrayList<String>();
		
		// 添加数据
		list04.add("Peppa");
		list04.add("Danny");
		list04.add("Pedro");
		list04.add("Suzy");
		System.out.println(list04);
		
		// 在指定位置插入数据
		list04.add(2, "Zoe");
		list04.add(2, "Wendy");
		list04.add(5, "Zoe");
		System.out.println(list04);
		
		// 通过索引移除数据,返回被移除的数据
		String name = list04.remove(0);
		System.out.println(name);
		System.out.println(list04);
		
		// 移除指定的对象,返回移除是否成功
		//默认删除第一个
		boolean result = list04.remove("Zoe");
		System.out.println(result);
		System.out.println(list04);
		
		// 创建集合,存储整数
		ArrayList<Integer> list05 = new ArrayList<Integer>();
		// 添加数据
		list05.add(1);                                                                                              
		list05.add(2);
		list05.add(3);
		list05.add(4);
		list05.add(5);
		
		// 输出
		System.out.println(list05);
		//index
		list05.remove(2);
		//数值
		Integer i = 2;
		list05.remove(i);
		System.out.println(list05);

改查

		                                                        
	
		
		/**
		 *	改
			 E set(int index, E element) 
			          用指定的元素替代此列表中指定位置上的元素。 
			 void ensureCapacity(int minCapacity) 
			          如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 
			 void trimToSize() 
			          将此 ArrayList 实例的容量调整为列表的当前大小。 
			
			查
			 int size() 
			          返回此列表中的元素数。 
			 E get(int index) 
			          返回此列表中指定位置上的元素。 
			 boolean contains(Object o) 
			          如果此列表中包含指定的元素，则返回 true。 
			 containsAll
			 	是否包含另一个集合中的所有内容
			 int indexOf(Object o) 
			          返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。 
			 int lastIndexOf(Object o) 
			          返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。 
			 retainAll
			 	保留两个集合中的交集部分内容
			 subList
			 	截取集合中的区间数据
			
			其他
			 iterator
			 listIterator
			 Object[] toArray() 
			          按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。  
		 */
	
		
		// 修改指定位置的元素
		list04.set(2, "Peggy");
		System.out.println(list04);
		
		// 元素的数量
		System.out.println(list04.size());
		
		// 获取指定索引位置的对象
		System.out.println(list04.get(0));
		System.out.println(list04.get(1));
		System.out.println(list04.get(2));
		System.out.println(list04.get(3));
		
		// 指定对象在集合中第一次出现的索引,如果对象不存在返回-1
		System.out.println(list04.indexOf("Wendy"));
		System.out.println(list04.indexOf("Molly"));
		
		// 截取指定区间的数据,得到一个新的集合
		List<String> subList = list04.subList(2, 4);
		System.out.println(subList);

3.4 遍历集合【重点】【掌握】

package com.javastudy;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class TestErgodic {
	public static void main(String[] args) {
		ArrayList<String> list =new ArrayList();
		list.add("Peppa");
		list.add("Danny");
		list.add("Pedro");
		list.add("Emily");
		list.add("Freddy");
		list.add("Molly");
		
		for(int i = 0 ; i < list.size(); i++) {
			System.out.print(list.get(i)+" ");
		}
		System.out.println();
		System.out.println("=====for====");
		
		int index=0;
		while(index < list.size()) {
			System.out.print(list.get(index)+ "+");
			index++;
		}
		System.out.println();
		System.out.println("=====while====");
		
		int index01=0;
		do {
			System.out.print(list.get(index01)+ "-");
			index01++;
		}while(index01 < list.size());
		System.out.println();
		System.out.println("=====do - while====");
		
		
		for(String list01 : list) {
			System.out.print(list01+"*");
		}
		System.out.println();
		System.out.println("=====foreach====");
		
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			System.out.print(it.next()+"&");
		}
		System.out.println();
		System.out.println("=====Iterator====");
		
		ListIterator<String> lit = list.listIterator();
		while (lit.hasNext()) {
			String name = lit.next();
			System.out.print(name+"%");
		}
		System.out.println();
		System.out.println("=====ListIterator====");
		
		//倒叙
		while (lit.hasPrevious()) {
			String name = lit.previous();
			System.out.print(name+"$");
		}
		
	}

}

3.5 比较ArrayList和LinkedList的性能

增加
查询

package com.javastudy;

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

public class TestEfficiency {
	public static void main(String[] args) {
		ArrayList<String> arrlist = new ArrayList();
		LinkedList<String> linkedlist = new LinkedList();
		long start01 = System.currentTimeMillis();
		add(arrlist);
		long end01 = System.currentTimeMillis();
		System.out.println("ArrayList增加使用时间"+(end01 - start01));
		
		long start02 = System.currentTimeMillis();
		add(linkedlist);
		long end02 = System.currentTimeMillis();
		System.out.println("LinkedList增加使用时间"+(end02 - start02));
		
		long start03 = System.currentTimeMillis();
		check(arrlist);
		long end03 = System.currentTimeMillis();
		System.out.println("ArrayList查询使用时间"+(end03 - start03));
		
		long start04 = System.currentTimeMillis();
		check(linkedlist);
		long end04 = System.currentTimeMillis();
		System.out.println("LinkedList查询使用时间"+(end04 - start04));
		
	}
	private static void add(List<String> list) {
		for(int i = 0 ; i <= 100000 ; i++) {
			list.add(0, Math.random()+" ");
		}
	}
	private static void check(List<String> list) {
		for(int i = 0 ; i <= 1000 ; i++) {
			list.get(list.size()/2);
		}
	}
	
}

四、泛型

4.1 概述

参数化数据类型
- 在创建对象的时候指定类中属性的数据类型
- 动态设置，扩展性增强
放入数据的时候就检查数据的类型

4.2 自定义泛型类

public class Student<T, G> {
	String name;
	int age;
	T stuId;
	G gender;
}

五、Set接口

5.1 概述

Set 接口是 Collection 的子接口， set 接口没有提供额外的方法。
Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个
Set 集合中，则添加操作失败。
Set 判断两个对象是否相同不是使用 == 运算符，而是根据equals()方法。

5.2 实现类

HashSet

LinkedHashSet

SortedSet -> TreeSet

六、Set

6.1 HashSet概述

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。
此实现不是同步的。

6.2 HashSet创造对象

package com.javastudy;

import java.util.HashSet;

public class TestHashSet {
	public static void main(String[] args) {
		
		/**
		 * 构造方法摘要 
			HashSet() 
			          构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 

			HashSet(int initialCapacity) 
			          构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。 
			          
			HashSet(int initialCapacity, float loadFactor) 
			          构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子。 
		 */
		
		//  构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 
		
		HashSet<String> hash= new HashSet();
		
		// 添加数据
		
		// 无序
		hash.add("Luffy");
		hash.add("Zoro");
		hash.add("Sanji");
		hash.add("Shanks");
		System.out.println(hash);
		
		// 不重复
		hash.add("Shanks");
		hash.add("Robin");
		System.out.println(hash);
		
		for (String name : hash) {
			System.out.println(name);
		}
	}
}

6.3 HashSet的无序不重复

package com.shine.set;

import java.util.HashSet;

public class Demo02 {
	public static void main(String[] args) {
		// 创建集合
		HashSet<String> set = new HashSet<String>();
		
		// 添加数据
		
		// 无序
		set.add("吕布");
		set.add("马超");
		set.add("赵云");
		set.add("张飞");
		System.out.println(set);
		
		// 不重复
		set.add("赵云");
		set.add("张飞");
		System.out.println(set);
	}
}

package com.javastudy;

import java.util.HashSet;

public class TestHashSet02 {
	public static void main(String[] args) {
		// 创建集合
		HashSet<Role> role = new HashSet<Role>();
		role.add(new Role("Luffy",22));
		role.add(new Role("Zoro",23));
		role.add(new Role("Sanji",21));

		System.out.println(role);
		role.add(new Role("Hancock",21));
		
		
	}

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

6.4、LinkedHashSet概述

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

6.5、LinkedHashSet存取有序

package com.javastudy;

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

public class TestLinkedHashSet {
	public static void main(String[] args) {
	LinkedHashSet<String> hash= new LinkedHashSet();
	
		// 添加数据
		
		// 无序
		hash.add("Luffy");
		hash.add("Zoro");
		hash.add("Sanji");
		hash.add("Shanks");
		System.out.println(hash);
		
		// 不重复
		hash.add("Shanks");
		hash.add("Robin");
		System.out.println(hash);
		
		for (String name : hash) {
			System.out.println(name);
		}
	}

}

七、TreeSet【重点】

7.1 概述

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

7.2 创建对象

package com.shine.treeset;

import java.util.TreeSet;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 * 构造方法摘要 
			TreeSet() 
			          构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。 
			TreeSet(Comparator<? super E> comparator) 
			          构造一个新的空 TreeSet，它根据指定比较器进行排序。 
		 */
		//  构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。 
		TreeSet<Integer> set01 = new TreeSet<Integer>();
		
		set01.add(22);
		set01.add(12);
		set01.add(22);
		set01.add(32);
		System.out.println(set01);
	}
}

7.3 自然顺序【内置类型】

按照元素的自然顺序排序

package com.shine.treeset;

import java.util.TreeSet;

public class Demo02 {
	public static void main(String[] args) {
		TreeSet<Integer> set01 = new TreeSet<Integer>();
		// 不重复 && 可排序
		set01.add(22);
		set01.add(12);
		set01.add(22);
		set01.add(32);
		System.out.println(set01);
		
		// 创建集合存储字符串
		TreeSet<String> set02 = new TreeSet<String>();
		set02.add("Tony");
		set02.add("Tom");
		set02.add("Jerry");
		set02.add("Jack");
		set02.add("Lucy");
		System.out.println(set02);
	}
}

7.4 自然顺序【自定义类型】

自定义的类型存入TreeSet集合之前需要实现一个接口Comparable
- 重写compareTo方法，在方法中自定义比较的规则

package com.javastudy;

import java.util.TreeSet;

public class TestTreeSet {
	public static void main(String[] args) {
		
		// 创建集合
		TreeSet<Role01> tree = new TreeSet<Role01>();
		tree.add(new Role01("Luffy",22));
		tree.add(new Role01("Zoro",23));
//		tree.add(new Role01("Sanji",21));

		System.out.println(tree);
//		tree.add(new Role01("Hancock",21));
		
	}

}
class Role01 implements Comparable<Role01>{
	String name;
	int age;
	public Role01(String name, int age) {
		super();
		this.name = name;
		this.age = age;		
	}
	@Override
	public String toString() {
		return "Role [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Role01 r) {
		// 先使用年龄比较
		int result = this.age - r.age;
		
		// 如果result==0,年龄是相同的,再使用name属性比较
		if (result == 0) {
			// 下面的compareTo方法是字符串比较的方法
			result = this.name.compareTo(r.name);
		}
		return result;
	}
	
	
}

7.5 Comparator

package com.javastudy;

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

public class TestTreeSet02 {
	public static void main(String[] args) {
		Comparator<Role02> comparator = new Comparator<Role02>() {
			@Override
			public int compare(Role02 p1, Role02 p2) {
				// 先使用年龄比较
				int result = p1.age - p2.age;
				
				// 如果result==0,年龄是相同的,再使用name属性比较
				if (result == 0) {
					// 下面的compareTo方法是字符串比较的方法
					result = p1.name.compareTo(p2.name);
				}
				return result;
			}
		};
		
		// 创建集合
		TreeSet<Role02> tree = new TreeSet<Role02>(comparator);
		tree.add(new Role02("Luffy",22));
		tree.add(new Role02("Zoro",23));
		tree.add(new Role02("Sanji",21));

		System.out.println(tree);
		tree.add(new Role02("Hancock",21));
	}

}
class Role02 {
	String name;
	int age;
	public Role02(String name, int age) {
		this.name = name;
		this.age = age;		
	}
	@Override
	public String toString() {
		return "Role [name=" + name + ", age=" + age + "]";
	}

}

八、Collections

8.1 概述

操作集合的一个工具
提供的方法
- 查询最值
- 排序
- 翻转
- 填充
- 交换
- 轮转
- 替换
- … …

8.2 常用方法

package com.javastudy;

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

public class TestCollections {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
			static <T> boolean addAll(Collection<? super T> c, T... elements) 
			          将所有指定元素添加到指定 collection 中。 
			static <T extends Comparable<? super T>> void sort(List<T> list) 
			          根据元素的自然顺序 对指定列表按升序进行排序。 
			static void swap(List<?> list, int i, int j) 
			          在指定列表的指定位置处交换元素。 
			static void shuffle(List<?> list) 
			          使用默认随机源对指定列表进行置换。 
			static <T> T max(Collection<? extends T> coll) 
			          根返回给定 collection 的最大元素。 
			static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 
			          根据元素的自然顺序 返回给定 collection 的最小元素。 
			static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
			          使用另一个值替换列表中出现的所有某一指定值。 
			static void reverse(List<?> list) 
			          反转指定列表中元素的顺序。 
			static void rotate(List<?> list, int distance) 
			          根据指定的距离轮换指定列表中的元素。 
			static <T> void fill(List<? super T> list, T obj) 
			          使用指定元素替换指定列表中的所有元素。 
		 */
		// 创建集合
		ArrayList<Integer> list = new ArrayList<Integer>();
		
		// 添加数据
		list.add(11);
		list.add(12);
		list.add(15);
		list.add(10);
		System.out.println(list);
		
		// 批量添加数据
		Collections.addAll(list, 13,26,81);
		System.out.println(list);
		
		// 集合排序
		Collections.sort(list);
		System.out.println(list);
		
		// 交换指定位置的元素
		Collections.swap(list, 3, 5);
		System.out.println(list);
		
		// 随机分布
		Collections.shuffle(list);
		System.out.println(list);
		
		// 最值
		System.out.println(Collections.max(list));
		System.out.println(Collections.min(list));
		
		// 替换
		Collections.replaceAll(list, 13, 24);
		System.out.println(list);
		
		// 集合排序
		Collections.sort(list);
		System.out.println(list);
		
		
		// 翻转
		Collections.reverse(list);
		System.out.println(list);
		
		// 轮转
		Collections.rotate(list, 3);
		System.out.println(list);
		
		
		// 填充
		Collections.fill(list,111);
		System.out.println(list);
	}

}

九、Map接口

9.1 概述

双列集合：一列key，一列value
将键映射到值的对象。
- 一个映射不能包含重复的键；【键不能重复】
- 每个键最多只能映射到一个值【值可以重复】

9.2 实现类

HashMap

LinkedHashMap

HashTable ->Properties

TreeMap

9.3 常用方法

package com.javastudy;

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

public class TestMap {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
		 * 增
			 V put(K key, V value) 
			          将指定的值与此映射中的指定键关联（可选操作）。 
			 void putAll(Map<? extends K,? extends V> m) 
			          从指定映射中将所有映射关系复制到此映射中（可选操作）。 
		 
		 * 删
			 V remove(Object key) 
			          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 
			 void clear() 
			          从此映射中移除所有映射关系（可选操作）。 
		 
		 * 改
			 V put(K key, V value) 
			          将指定的值与此映射中的指定键关联（可选操作）。 
			 void putAll(Map<? extends K,? extends V> m) 
			          从指定映射中将所有映射关系复制到此映射中（可选操作）。 
		 
		 * 查
			 int size() 
			          返回此映射中的键-值映射关系数。 
			 V get(Object key) 
			          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 
			 boolean containsKey(Object key) 
			          如果此映射包含指定键的映射关系，则返回 true。 
			 boolean containsValue(Object value) 
			          如果此映射将一个或多个键映射到指定值，则返回 true。 
		 
			 Set<K> keySet() 
			          返回此映射中包含的键的 Set 视图。 
			 Collection<V> values() 
			          返回此映射中包含的值的 Collection 视图。 
			 Set<Map.Entry<K,V>> entrySet() 
			          返回此映射中包含的映射关系的 Set 视图。 
		 */
		// 创建Map的实现类对象:动态方式创建
				Map<String, Integer> map = new HashMap<String, Integer>();
				
				// 添加映射
				map.put("Luffy", 1);
				map.put("Zoro", 2);
				map.put("Nami", 3);
				map.put("Sanji", 4);
				map.put("Usopp", 5);
				map.put("FRANKY", 6);
				
				System.out.println(map);
				
				// 修改数据
				map.put("Luffy",7);
				System.out.println(map);
				
				// 通过key删除映射
				Integer remove = map.remove("Nami");
				System.out.println(remove);
				System.out.println(map);
				
				// 映射的个数
				System.out.println(map.size());
				
				// 通过key查询对应的value
				System.out.println(map.get("FRANKY"));
				
				// 是否包含指定的键或者值
				System.out.println(map.containsKey("Luffy"));
				System.out.println(map.containsKey("Nami"));
				
				System.out.println(map.containsValue(1));
				System.out.println(map.containsValue(10));
				
				// 获取所有的key
				Set<String> keys = map.keySet();
				System.out.println(keys);
				
				// 获取所有的值
				Collection<Integer> values = map.values();
				System.out.println(values);
				
				// 获取所有的键值映射
				Set<Entry<String, Integer>> entrySet = map.entrySet();
				System.out.println(entrySet);
	}

}

9.4 遍历Map集合【重点】

package com.javastudy;

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

public class TestMap02 {
	public static void main(String[] args) {
		/**
		 *	遍历Map集合
		 *		通过Key遍历
		 *			获取所有的Key，遍历key，获取每一个key对应的value
		 *		通过entry遍历
		 */
		
		// 创建Map的实现类对象:动态方式创建
		Map<String, Integer> map = new HashMap<String, Integer>();
		
		// 添加映射
		map.put("Luffy", 11);
		map.put("Zoro", 22);
		map.put("Nami", 31);
		map.put("Sanji", 24);
		map.put("Usopp", 54);
		map.put("FRANKY", 86);
		
		Set<String> key = map.keySet();
	
		System.out.println("==============key + foreach===============");
		for(String keys : key) {
			System.out.print(map.get(keys)+ "  ");
		}
		System.out.println();
		
		System.out.println("==============key + iterator===============");
		// 获取key集合的迭代器
		Iterator<String> itKey = key.iterator();
			while(itKey.hasNext()) {
				System.out.print(map.get(itKey.next())+ "  ");
			}
			
			System.out.println();
			
			// 获取map集合的映射关系集
		Set<Entry<String , Integer>> entrySet=  map.entrySet();
		
		
		System.out.println("==============entry + foreach===============");
		for(Entry<String ,Integer> entry: entrySet) {
			System.out.print(entry.getKey() +  "  "+entry.getValue()+ "  ");
		}
		
		System.out.println();
		
		System.out.println("==============entry + iterator===============");
		Iterator<Entry<String ,Integer>> itEntry = entrySet.iterator();
		while(itEntry.hasNext()) {
			Entry<String ,Integer > entry = itEntry.next();
			System.out.print(entry.getKey()+ "  "+entry.getValue()+ "  ");
		}
		
		
		System.out.println();
		Iterator<Entry<String, Integer>> entryIt = entrySet.iterator();
		while(entryIt.hasNext()) {
			Entry<String, Integer> entry = entryIt.next();
			System.out.print(entry.getKey() + "  " + entry.getValue()+ "  ");
		}
	}

}

十、HashMap

10.1 概述

基于哈希表的 Map 接口的实现类。
除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。
HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。
- 容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。【数组的长度】
- 加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。【数据量和容量的比例】
当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作【扩容】
- 从而哈希表将具有大约两倍的桶数。

10.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`。

10.3 常用方法

参考Map集合中的方法【方法基本相同】

十一、HashTable

11.1 概述

此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
除了同步和不允许使用 null 之外，Hashtable 类与HashMap 大致相同。

11.2 子类Properties

hashTableDe一个子类，表示一个持久的属性集
项目开发常用

package com.shine.properties;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class Demo01 {
	public static void main(String[] args) throws FileNotFoundException, IOException {
		// 创建属性集
		Properties properties = new Properties();
		System.out.println(properties);
		
		// properties.setProperty("username", "zhangsan");
		// properties.setProperty("password", "sanzhang");
		
		// 加载外部配置文件
		properties.load(new FileInputStream("user.properties"));
		
		System.out.println(properties);
		
		// 读取属性集中的数据
		System.out.println(properties.getProperty("username"));
		System.out.println(properties.getProperty("password"));
	}
}