【Map集合、比较器、泛型、colletions、arrays工具类】的学习

Map集合接口

以key-value形式进行数据的存储的集合，底层使用的数组+链表的形式进行数据存储

返回类型	方法	描述
Object	get(Object key)	根据key取得value
Object	put(Obejct k,Object v)	向集合中加入元素
void	clear()	清除Map集合
boolean	isEmpty()	判断集合是否为空
boolean	containsKey(Object object)	判断指定的key是否存在
boolean	containsValue(Object value)	判断指定的value是否存在
Set	keySet()	Map中所有的key的集合
Object	remove(Object key)	根据key删除对应的value
Collection	values()	取出全部的value
int	size()	获得集合的长度

HashTable:之前jdk版本常用的集合对象，线程安全，不允许null的存在

HashMap：1.8以后替代HashTable使用的集合对象，线程不安全，可以存null

properties：对以key-value形式进行数据存储书写的文件进行解析的类

HashMap集合

hashmap的key可以理解为使用的是hashSet，value可以理解为使用的是互相没有关联的List

构造方法摘要
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。

方法摘要
void clear()
从此映射中移除所有映射关系。
Object clone()
返回此 HashMap 实例的浅表副本：并不复制键和值本身。
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 keySet()
返回此映射中所包含的键的 Set 视图。
V put(K key, V value)
在此映射中关联指定值与指定键。
void putAll(Map<? extends K,? extends V> m)
将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
V remove(Object key)
从此映射中移除指定键的映射关系（如果存在）。
int size()
返回此映射中的键-值映射关系数。
Collection values()
返回此映射所包含的值的 Collection 视图。

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

//hashMap
public class HashMapTest {
//底层使用数组+链表形式存储的key-value键值对集合
	public static void main(String[] args) {
		//语法：集合类型<key数据类型，value数据类型> map=new 构造方法();
		HashMap<String,String> map=new HashMap<>();
		
		//put(object,object)
		//添加/修改方法，为了与其他集合add方法区分修改了方法名以及参数
		//hashMapkey使用的hashSet使用hash值进行存储不允许重复数据
		//所以对于hashMap而言如果添加时key相同则将value进行覆盖
		map.put("a","1");
		map.put("a","2");
		String put = map.put("a","3");
		//如果是覆盖则返回被覆盖的数据
		map.put("b","3");
	 
		
		//get(objectKey)
		//获取方法传入key对象返回对应value对象值
	//	System.out.println(map.get("a"));
		
		//remove(objectKey)
		//删除方法通过key删除键值对
		String remove = map.remove("a");
		//返回删除的value数据
		
		//map.remove(key, value)
		//通过key与value进行删除
		//如果不匹配返回false
		boolean remove2 = map.remove("b","3");
		 
		map.put("a","1");map.put("b","2");map.put("c","3");map.put("d","3");map.put("e","3");
		//清空方法 清楚所有键值对
		//map.clear();
		
		//map.containsKey(key)
		//当前map中是否包含指定key的键值对
		//System.out.println(map.containsKey("asd"));
		
		//map.containsValue(value)
		//当前map中是否包含指定value的键值对
		System.out.println(map.containsValue("3"));
		
		//map.keySet();
		//将key以set集合的形式返回
		Set<String> keySet =map.keySet();
		for (String string : keySet) {
			System.out.println(string+"=>"+map.get(string));
		}
		
		//map.clone()
		//克隆复制方法
		//返回一个与克隆对象相同的object对象（不会创建数据保存数据地址）
		//将原数据地址保存至新变量
		//如果克隆的变量出现修改则会变为新的对象
		HashMap<String,String> map2 = (HashMap<String, String>) map.clone();
		map2.put("f","1");map2.put("g","2");map2.put("h","3");
		
		
		//将另一个map集合数据添加至当前集合
		map.putAll(map2);
		//map.values()
		//返回value集合
		Collection<String> values = map.values();
		for (String string : values) {
			System.out.println(string);
		}
		System.out.println(map);
	}
}

比较器

使用工具类可以快速比较两个或多个对象，也可以将多个数据按照规则进行排序

对于比较器实现对象比较有两种形式:

第一种:用要比较的类实现comparable接口,实现compareTo方法

第二种:创建单独比较器类,实现comparator接口,实现compare方法

对于排序的方式不同,具体选择哪种方法实现对象的比较也会有所不同

实现complarable接口实现compareTo方法

在要比较的类中实现，通过对比当前对象与传入对象相应属性进行判断，如果多个属性比较进行多个if判断即可

//实现比较接口实现比较方法输入比较对象
public class Student implements Comparable<Student> {
	private String name;
	private int age;
	private double score;

	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 double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

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

	public Student() {
		super();
	}

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

	@Override
	public int compareTo(Student o) {
		// 返回类型为int类型
		// 将当前对象属性与传入对象属性进行对比
		// 如果当前对象值大于传入对象返回1 否则返回-1 相等返回0
		if (this.age == o.age) {
			if(this.score>o.score){
				return 1;
			}else{
				return -1;
			}
		} else if (this.age > o.age) {
			return 1;
		} else {
			return -1;
		}
	}
}

使用工具类排序方法验证

Student s1 = new Student("张三", 17, 53);
		Student s2 = new Student("李素", 17, 51);
		Student s3 = new Student("二狗", 19, 80);
		Student s4 = new Student("铁柱", 18, 75);
		Student[] arr = { s1, s2, s3, s4 };
		
		//Arrays 数组工具类 提供操作数组相关的方法
		Arrays.sort(arr);//按照自然顺序（默认顺序或实现排序接口的类定义的顺序）进行排序
		for (Student student : arr) {
			System.out.println(student);
		}

实现Comparator接口，实现compare方法

import java.util.Comparator;
//自定义比较器类
//实现自定义比较器接口
public class Compar implements Comparator<Student> {

	@Override
	public int compare(Student o1, Student o2) {
		// 返回类型为int类型
		// 将当前对象属性与传入对象属性进行对比
		// 如果当前对象值大于传入对象返回1 否则返回-1 相等返回0
		if (o1.getAge() == o2.getAge()) {
			if (o1.getScore() > o2.getScore()) {
				return 1;
			} else {
				return -1;
			}
		} else if (o1.getAge() > o2.getAge()) {
			return 1;
		} else {
			return -1;
		}
	}
}

使用工具类排序方法验证

Student s1 = new Student("张三", 17, 53);
		Student s2 = new Student("李素", 17, 51);
		Student s3 = new Student("二狗", 19, 80);
		Student s4 = new Student("铁柱", 18, 75);
		Student[] arr = { s1, s2, s3, s4 };
		Compar c = new Compar();// 创建比较器对象
		// Arrays 数组工具类 提供操作数组相关的方法
		Arrays.sort(arr, c);// 按照指定比较器对象比较方式进行排序
		for (Student student : arr) {
			System.out.println(student);
		}

Arrays工具类

		// Arrays.fill(arr, value);
		// 使用指定数据填充数组
		// Arrays.fill(a, fromIndex, toIndex, val);
		// 使用指定数据填充起始索引值结束索引前一位数组的数据

		// Arrays.sort(a);
		// 使用自然顺序（存储数据实现比较器接口）进行数组数据的排序
		// Arrays.sort(a,compar);
		// 传入排序数组以及比较器对象，使用比较器将数据进行排序

		// Arrays.copyOf(original, newLength)
		// 创建一个指定长度的新数组并将指定数组数据存入

		//Arrays.toString(arr);
		//将数组转换为字符串

Colleations工具类

	// Collections.addAll(c,... elements);
		// 将多个数据添加至指定集合
		// add方法每次只能添加一个数据
		// Collections.addAll可以一次添加多个数据
		Collections.addAll(a1, 5,6, 7,1, 2, 3, 4);
		Collections.addAll(a2, 0,0,0,0,0,0,0,0,0,0,0);
		
		//Collections.copy(a2, a1);
		//将指定集合数据复制至当前集合（当前集合数据数等于或大于指定集合）
		
		//Collections.disjoint(a1, a2);
		//如果两集合中没有重复数据则返回true
		
		//Collections.fill(a2, 1);
		//将集合中所有数据使用指定数据替换
		
		
		//Collections.replaceAll(a1, 23, 10);
		//将指定集合中所有指定数据替换为另一个数据
		
		//Collections.shuffle(a1);
		//随机打乱存储位置
		
		//Collections.swap(a1, 0, 6);
		//交换指定集合两索引位置的数据
		
		//Collections.sort(a1);
		//如果存储数据实现了比较器接口可以直接使用此方法进行排序
		
		//Collections.sort(a1,compar);
		//使用指定比较器进行排序

不确定参数

在书写方法时有时传入参数的个数不确定，使用不确定参数可以完美解决，不确定参数本质是是数组，但是在定义后调用方法可以传入0到无穷个数据

不确定参数要求只能定义在每个方法最后一位，且一个只能的定义一个,在调用时，多个参数使用，分隔如果不想传入参数可以不写

	//不确定参数的语法...
	public static void a(int ... arr){
		//本质是数组  使用...替代[]
		for (int i : arr) {
			System.out.print(i+" ");
		}
	}

		a(1,2,3);
		//不确定参数的方法 调用时可以直接传入数组 也可以将数据使用,分隔进行填入

泛型

广泛的数据类型也称为参数类型（当做参数使用的类型），在方法定义时无法确定传入参数的数据类型时，使用泛型，在对象创建时传入泛型类型，那么所有指定泛型的数据类型都会替换为指定类型

泛型的定义

1、类声明中定义泛型

在类声明时定义泛型，那么在使用类创建对象时必须指定泛型类型，旗下所有使用泛型的位置泛型会自动替换为指定类型

//泛型的定义
//泛型使用<>包裹 由单个大写字母组成
//多个使用，进行分隔

//1声明在类的声明中
public class Genericity<A,B>{
	public void a(A a,B b,Object c){
		A a1=(A)c;
		//1、用于限制方法传入对象的数据类型
		//2、用于指定类型的强制转换
	}
	public static void main(String[] args) {
		//在使用声明了泛型的类创建对象时需要指定泛型的数据类型
		//否则默认视同Object
		Genericity<String,Integer> g=new Genericity<>();
	}
}

2、方法中定义泛型

//2在方法的声明声明泛型
	public <C> C b(C c) {
		//在方法使用时，根据传入参数的数据类型决定泛型的类型
		return c;
	}

	public static void main(String[] args) {
		// 在使用声明了泛型的类创建对象时需要指定泛型的数据类型
		// 否则默认视同Object
		Genericity<String, Integer> g = new Genericity<>();
		Student b = g.b(new Student));
		
	}