java11-泛型Map集合，工具

------- android培训、java培训、期待与您交流！ ----------

泛型

JDK1.5以后出现的新特性，用于解决安全问题，是一个类型安全机制。


好处是将运行时期出现的问题ClassCastException,转移到了编译时期。方便程序员解决问题。让运行时问题减少，安全。避免了强制转换麻烦。


泛型格式：通过<>来定义要操作的引用数据类型。
在集合框架中常见，有<>就要定义泛型。
<>是用来接收类型的，使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。等于对集合中类型固定。
类中引用数据类型不确定时，早期用Object类来扩展，现在使用泛型。


泛型类定义的泛型，在整个类中有效。
对象明确了要操作的具体类型后，要操作类型就固定了。
不同方法要操作不同不确定的类型，可以将泛型定义在方法上。
public <T> void 方法名(T t)


静态方法类型不确定，只能定义在方法上。


集合中泛型类型要相同。


？通配符，也称点位符
泛型能限定范围。
? extends E
上限限定，E以及子类型：用于比较共同属性
? super E
下限限定，E及父类类型：用于调用共有方法




Map集合：
存储元素是键值对，一对一对的存入，而且要保证键的唯一性。

添加
put(K key,V value)
putAll(Map<? extends k,? extends V> m)


删除
clear()
remove(Object key)


判断
containsKey(Object key)
containsValue(Object value)
isEmpty()


获取
get(Object key)
size()
values()


Set<k>keySet()
将Map中所有的键存入到Set集合。因为Set具备迭代器。所以可以以迭代方式取出所有的键，再根据get方法，获取每个键对应的值。
取出原理：将Map集合转成Set集合，Set通过迭代器取出。


Set<Map.Entry<k,v>>entrySet()
将Map集合中的映射关系存入到Set集合中，关系的数据类型就是：Map.Entry

取出关系对象，通过Map.Entry中的getKey和getValue方法获取中的键和值。

Map.Entry
Entry也是一个接口，是Map接口中的一个内部静态接口。

import java.util.*;
class MapDemo2
{
	public static void main(String[] args)
	{
		Map<String,String> map = new HashMap<String,String>();
		map.put("02","zhangsan2");
		map.put("04","zhangsan4");
		map.put("03","zhangsan3");
		map.put("01","zhangsan1");
		//先获取Map集合的所有键的Set集合，keySet();
		Set<String> keySet = map.keySet();
		//使用迭代器取出Set集合中的键
		//对键使用Map集合中的get方法得到对应的值

		for(Iterator<String> it = keySet.iterator();it.hasNext();)
		{
			String key = it.next();
			String value = map.get(key);
			System.out.println("key:"+key+",value:"+value);
		}
		
		//将Map集合中的映射关系取出，存入到Set集合中
		Set<Map.Entry<String,String>> entrySet = map.entrySet();
		//通过Set迭代器取出关系
		//通过getKey和getValue取出对应的键和值
		for(Iterator<Map.Entry<String,String>> it = entrySet.iterator();it.hasNext();)		
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key+":"+value);
		}
	}
}

Map
--Hashtable
底层是哈希表数据结构，不可存入null键null值。集合是线程同步的，JDK1.0效率低。
--HashMap
底层是哈希表数据结构，可以存入null键null值。线程不同步，替代了hashtable。JDK1.2效率高。
--TreeMap
底层是二叉树数据结构。线程不同步，可以给Map集合中的键进行排序。


Set底层使用了Map集合。因此Set和Map很像。

import java.util.*;
class MapDemo
{
	public static void main(String[] args)
	{
		Map<String,String> map = new HashMap<String,String>();
		//添加元素时，出现相同的键，后添加的值会覆盖原有键对应值.
		//并且put方法会返回被覆盖的值。首次返回null
		
		System.out.println("put:"+map.put("01","zhangsan1"));
		map.put("01","wangwu");
		map.put("02","zhangsan2");
		map.put("02","zhangsan2");
		//判断
		System.out.println("containsKey:"+map.containsKey("023"));
		//删除remove
		System.out.println("remove:"+map.remove("02"));
		//获取get
		System.out.println("get:"+map.get("02"));

		//通过get方法的返回值来判断一个键是否存在，通过返回null来判断
		map.put("04",null);
		System.out.println("get:"+map.get("04"));
		
		//获取Map集合中所有的值
		Collection<String> coll = map.values();

		System.out.println(coll);		
		System.out.println(map);
	}
}

Collections
工具类，专对集合进行操作，方法是静态的，不用创建对象。直白类名调用。


sort
排序
public static <T extends Comparable<? super T>> void sort(List<T> list)
根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是可相互比较的
public static <T> void sort(List<T> list,Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较
max
最大值
binarySearch
搜索元素，必须是有序列的集合。
三个方法可以默认自然排序，也可以根据需要指定比较器Comparator。


public static <T> void fill(List<? super T> list,T obj)
使用指定元素替换指定列表中的所有元素。


replaceAll
使用另一个值替换列表中所有指定值


reverse
反转元素


reverseOrder
强行反转比较器，强行反转指定（比较器）


SynList
public static <T> List<T> synchronizedList(List<T> list)
返回指定列表支持的同步（线程安全的）列表。为了保证按顺序访问，必须通过返回的列表完成所有对底层实现列表的访问。


swap
元素换位


public static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。




Arrays:
用于操作数组的工具类。都是静态方法。


asList
将数组变成List集合。
可以使用集合的思想和方法来操作数组中的元素。
由于数组长度是固定的，不可以使用集合的增删方法。会发生异常。


数组中的元素都是对象，变成集合时，数组中的元素就直接转成集合中的元素。
数组中的元素都是基本数据类型，会将该数组作为集合中的元素存在。
就是集合中的元素都是对象，直接转对象。


集合转成数组
Collection接口中的toArray方法。
指定类型的数组长度小于了集合的size时，方法内部会创建一个新的数组。长度为
集合的size.
大于集合的size时，不会创建数组。而使用传递进来的数组。因此创建一个正好的数组 ：数组[集合.size]


数组是固定的，集合变成数组是为了限定对集合的操作，不能进行增删。




增强for循环
格式
for(数据类型 变量名 ：被遍历的集合(Collection）或者数组）
{
获取元素;
}
只能获取集合元素，不能对集合进行其他操作。


迭代器除了遍历，还可以进行remove集合中元素。
在ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
高级for必须有被遍历的目标。
传统for可以定义脚标。

import java.util.*;
class ForEachDemo
{
	public static void main(String[] args)
	{
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		
		hm.put(1,"a");
		hm.put(2,"b");
		hm.put(3,"c");
		//没有迭代器时，要先定义好工具。确定类型
		Set<Integer> keySet = hm.keySet();
		for(Integer i : keySet)
		{
			System.out.println(i+"："+hm.get(i));
		}
		for(Map.Entry<Integer,String> me : hm.entrySet())
		{
			System.out.println(me.getKey()+"--"+me.getValue());
		}
		ArrayList<String> al = new ArrayList<String>();
		al.add("al1");
		al.add("al2");
		al.add("al3");
		for(String s : al)
		{
			System.out.println(s);
		}
		int[] arr = {1,3,6}
		for(int i : arr)
		{
			System.out.println("i:"+i)
		}
	}
}

JDK1.5的新特性


可变参数
就是数据的简写形式，不用每次都手动建立数组对象，只要将操作的元素作为参数传递即可，隐式的将这些参数封装成了数组。
函数的可变参数在使用时，一定要定义在参数列表的最后面。


show(int... arr)
{
System.out.println(arr.length);
}


StaticImport静态导入
当类名重名时，需要指定具体的包名。
当方法重名时，指定方法具备所属的对象或者类。
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员
import static java.long.System.*;//导入的是System类中所有静态成员

-------  android培训 、 java培训 、期待与您交流！ ----------