Java——Map接口，可变参数，collections（集合实现类）

Posted 2020-10-24 想54256

一、Map接口

Map中的集合是双列集合（键值对），Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

• HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

• LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

Map常用方法

1、将键值对存储到集合中

/*
 *  将键值对存储到集合中
 *  V put(K,V) K 作为键的对象, V作为值的对象
 *  存储的是重复的键,将原有的值,覆盖
 *  返回值一般情况下返回null,
 *  存储重复键的时候,返回被覆盖之前的值
 */
public static void function(){
	//创建集合对象,HashMap,存储对象,键是字符串,值是整数
	Map<String, Integer> map = new HashMap<String, Integer>();
	map.put("a", 1);
	map.put("b", 2);
	map.put("c", 3);
	System.out.println(map);
}

2、获取值

/*
 * 通过键对象,获取值对象
 * V get(K)
 * 如果集合中没有这个键,返回null
 */
public static void function_1(){
	//创建集合对象,作为键的对象整数,值的对象存储字符串
	Map<Integer,String> map = new HashMap<Integer, String>();
	map.put(1, "a");
	map.put(2, "b");
	map.put(3, "c");
	System.out.println(map);
	
	String value = map.get(4);
	System.out.println(value);
}

3、移除键值对

/*
 *  移除集合中的键值对,返回被移除之前的值
 *  V remove(K)
 */
public static void function_2(){
	Map<Integer,String> map = new HashMap<Integer, String>();
	map.put(1, "a");
	map.put(2, "b");
	map.put(3, "c");
	System.out.println(map);
	
	String value = map.remove(33);
	System.out.println(value);
	System.out.println(map);
}

4、Map集合遍历——通过值获取键

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

/*
 *  Map集合的遍历
 *    利用键获取值
 *    Map接口中定义方法keySet
 *    所有的键,存储到Set集合
 */
public class MapDemo1 {
	public static void main(String[] args) {
		/*
		 *  1. 调用map集合的方法keySet,所有的键存储到Set集合中
		 *  2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
		 *  3. 调用map集合方法get,通过键获取到值
		 */
		Map<String,Integer> map = new HashMap<String,Integer>();
		map.put("a", 11);
		map.put("b", 12);
		map.put("c", 13);
		map.put("d", 14);
		
		//1. 调用map集合的方法keySet,所有的键存储到Set集合中
		Set<String> set = map.keySet();
		//2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			//it.next返回是Set集合元素,也就是Map中的键
			//3. 调用map集合方法get,通过键获取到值
			String key = it.next();
			Integer value = map.get(key);
			System.out.println(key+"...."+value);
		}
		System.out.println("=======================");
		for(String key : map.keySet()){
			Integer value = map.get(key);
			System.out.println(key+"...."+value);
		}
	}
}

5、Map集合遍历——entrySet方法

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

/*
 *  Map集合获取方式
 *  entrySet方法,键值对映射关系(结婚证)获取
 *  实现步骤:
 *    1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
 *        Set<Entry <K,V> >
 *    2. 迭代Set集合
 *    3. 获取出的Set集合的元素,是映射关系对象
 *    4. 通过映射关系对象方法 getKet, getValue获取键值对
 *    
 *    创建内部类对象 外部类.内部类 = new 
 */
public class MapDemo2 {
	public static void main(String[] args) {
		Map<Integer,String> map = new HashMap<Integer, String>();
		map.put(1, "abc");
		map.put(2, "bcd");
		map.put(3, "cde");
		//1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
		Set<Map.Entry <Integer,String> >  set = map.entrySet();
		//2. 迭代Set集合
		Iterator<Map.Entry <Integer,String> > it = set.iterator();
		while(it.hasNext()){
			//  3. 获取出的Set集合的元素,是映射关系对象
			// it.next 获取的是什么对象,也是Map.Entry对象
			Map.Entry<Integer, String> entry = it.next();
			//4. 通过映射关系对象方法 getKet, getValue获取键值对
			Integer key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key+"...."+value);
		}
		
		System.out.println("=========================");
		for(Map.Entry<Integer, String> entry : map.entrySet()){
			System.out.println(entry.getKey()+"..."+entry.getValue());
		}
	}
}

HashTable实现类

import java.util.Hashtable;
import java.util.Map;

/*
 *  Map接口实现类 Hashtable
 *  底层数据结果哈希表,特点和HashMap是一样的
 *  Hashtable 线程安全集合,运行速度慢
 *  HashMap 线程不安全的集合,运行速度快
 *  
 *  Hashtable命运和Vector是一样的,从JDK1.2开始,被更先进的HashMap取代
 *  
 *  HashMap 允许存储null值,null键
 *  Hashtable 不允许存储null值,null键
 *  
 *  Hashtable他的孩子,子类 Properties 依然活跃在开发舞台
 */
public class HashtableDemo {
	public static void main(String[] args) {
		Map<String,String> map = new Hashtable<String,String>();
		map.put(null, null);
		System.out.println(map);
	}
}

LinkedHashMap实现类

import java.util.LinkedHashMap;

/*
 *  LinkedHashMap继承HashMap
 *  保证迭代的顺序
 */
public class LinkedHashMapDemo {
	public static void main(String[] args) {
		LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
		link.put("1", "a");
		link.put("13", "a");
		link.put("15", "a");
		link.put("17", "a");
		System.out.println(link);
	}
}

二、可变参数

/*
 *  JDK1.5新的特性,方法的可变参数
 *  前提: 方法参数数据类型确定,参数的个数任意
 *  可变参数语法: 数据类型...变量名
 *  可变参数,本质就是一个数组
 */
public class VarArgumentsDemo {
	public static void main(String[] args) {
		//调用一个带有可变参数的方法,传递参数,可以任意
	//	getSum();
		int sum = getSum(5,34,3,56,7,8,0);
		System.out.println(sum);
		
		function(1,2,3);
	}
	/*
	 * 可变参数的注意事项
	 * 1. 一个方法中,可变参数只能有一个
	 * 2. 可变参数,必须写在参数列表的最后一位
	 */
	 public static void function(Object...o){
		 
	 }
	
	/*
	 * 定义方法,计算10个整数和
	 * 方法的可变参数实现
	 */
	public static int getSum(int...a){
		int sum = 0 ;
		for(int i : a){
			sum = sum + i;
		}
		return sum;
	}
}

三、collections——集合实现类

全是List实现类下的

1、排序

/*
 *  Collections.sort静态方法
 *  对于List集合,进行升序排列
 */
public static void function(){
	//创建List集合
	List<String> list = new ArrayList<String>();
	list.add("ewrew");
	list.add("qwesd");
	list.add("Qwesd");
	list.add("bv");
	list.add("wer");
	System.out.println(list);
	//调用集合工具类的方法sort
	Collections.sort(list);
	System.out.println(list);
}

2、二分查找

/*
 * Collections.binarySearch静态方法
 * 对List集合进行二分搜索,方法参数,传递List集合,传递被查找的元素
 */
public static void function_1(){
	List<Integer> list = new ArrayList<Integer>();
	list.add(1);
	list.add(5);
	list.add(8);
	list.add(10);
	list.add(15);
	list.add(20);
	//调用工具类静态方法binarySearch
	int index = Collections.binarySearch(list, 16);
	System.out.println(index);
}

3、随机排序

/*
 * Collections.shuffle方法
 * 对List集合中的元素,进行随机排列
 */
public static void function_2(){
	List<Integer> list = new ArrayList<Integer>();
	list.add(1);
	list.add(5);
	list.add(9);
	list.add(11);
	list.add(8);
	list.add(10);
	list.add(15);
	list.add(20);	
	System.out.println(list);
	
	//调用工具类方法shuffle对集合随机排列
	Collections.shuffle(list);
	System.out.println(list);
}