java高级特性-集合-正则-泛型

//Java高级特性
//集合：集中后合在一起
//理解：存放不定数量的不定类型的内容可变的容器，且可以根据需要自由提取元素
//集合行为：创建、添加元素、删除元素、修改元素、查看元素、数量统计、排序…
//只能存储引用类型，如果是基本类型的话，则需要包装
Iterable:可迭代
Collection（相当于单一元素对象数组）特点：不唯一（可以存放重复的），无序的
子接口：
List 特点：不唯一，有序（先进先出first in，first out）
类：
【ArrayList】：与vector功能一致，但是ArrayList并发制，线程不安全
vector：线程安全
【LinkedList】：线程不安全
LinkedBlockingQueue链式阻塞单向队列（一头进一头出），线程安全
LinkedBlockingDeque链式阻塞双向队列（两头都可进可出），线程安全
Set 特点：唯一，无序
类：
HashSet
TreeSet
//标准行为：
int size();
boolean isEmpty();
int indexOf(T t);//返回下标
int lastIndexOf(T t);//返回最后一个下标

		增:
		boolean add(T t);
		boolean add(int index,T t);
		boolean add(T[] ts);
		boolean add(int index,T[] ts);
		
		删:
		boolean remove(T t);
		T remove(int index);
		boolean remove(T[] ts);
		void retain(T[] ts);//保留
		
		改：
		boolean set(int index,T t);
		
		查：
		T get(int index);
		boolean contains(T t);
		boolean contains(T[] ts);
		
		迭代器：
		Iterator<T> iterator();
	
	Map：键值对:键唯一，值不唯一，无序
		类：
		【HashMap】：线程不安全
			Hashtable：线程安全（单锁），性能低
			[ConcurrentHashMap]：线程安全（分段锁）
			//解决过度集中
				//扩展因子：>=0.75=>arr.length*2:再哈希
				
		【TreeMap】
		Map<K,V> map = new HashMap<>(int initCapacity);
		
		//Map函数
		int size = map.size();
		boolean empty = map.isEmpty();
		
		boolean has = map.containsKey(K key);//是否包含参数指定的键
		boolean has = map.containsValue(V value);//是否包含参数指定的值
		V value = map.get(K key);				//根据键获取值
		V value = map.put(K key,V value);		//存放键值，若键已存在用参数2对象覆盖并返回原对象
		遍历：
		//for(K k:keys){...} 
		//keys.forEach{e->{...}};
		//Iterator<K> it = key.iterator();while(it.has Next()){K key = it.next();...}
		
		
		//Set<K>keys = next.keySet();				//获取键集合Set<K>
		//Collection<V> values = next.values();		//获取值集合Collection<V>
		//Set<Map.Entry<K,V>> entries = next.entrySet();//获取键值集合Set<Map.Entry<K,V>>遍历键值集合
//集合内的存放结构：数据结构
	Array :数组
		//优势：遍历	劣势：查找，插入，删除
	Linked:链表
		//优势：插入，删除	劣势：遍历，查找
	Hash：哈希表（散列表）
		//优势：遍历，查找，新增，删除
		jdk<=7	数组+链表
		jdk>=8	数组+链表+红黑树
				null(==0)>元素(==1)>链表(>=2)>红黑树(>=8)
				红黑树(>6)>链表(<=6)>元素(==1)>null(==0)
	Tree:红黑（平衡二叉）树
		优势：查找		劣势：遍历，删除，插入

//泛型 类型参数化
类型参数

举例：List xxx =…; 指定xxx集合中只能存放字符串类型，否则编译错误

//json
//{} : 对象
//[] ：数组

		//key:value,key:value,...
		
		{
			stuName:"henry",
			stuAge:18,
			...
		}
	
		{
			stuName:"henry",
			stuAge:18,
			hobbies:["swimming","travelling"],
			address:{
				province:"jiangsu",
				city:"nanjing",
				district:"yuhua",
				detail:"xiaohang road #16"
		}
		},
		...
	{
			stuName:"henry",
			stuAge:18,
			hobbies:["swimming","travelling"],
			address:{
				province:"jiangsu",
				city:"nanjing",
				district:"yuhua",
				detail:"xiaohang road #16"
		}
		}
		...

//正则表达式

		//基本语法
			[^?-??-?] //指定范围的一个符号   //一个数字[0-9] [0-47-9]
											//一个字母[a-z][A-Z]
											//一个汉字[\u4e00-\u9fa5]
			[]			//指定范围				
			^			//非				
			|			//或				一个指定域名(com | cn | org |edu)
			()			//组合
			\d        //<=>[0-9]
			\D			//<=>[^0-9]
			\w 			//[0-9a-zA-Z_]
			\W			//[^0-9a-zA-Z_]
			\s			//\r \n
			\S			//非空符号
			.			//任意符号
	
	{min,max}		//表示前一个符号或一个组合最小重复min次，不超过max次  \d{6,18}
	{FIX}		//\d{6}
	{,MAX}		//最多重复max次
		{MIN,}	//最少重复min次
		?		//{0,1}
		+		//{1,}
		*		//{0,}
		
     	//java 正则表达式
	    java.util.regex.Pattern
		java.util.regex.Matcher
		
		Pattern p=Pattern.compile(String regex);
		String src = ...;
		Matcher m=p.matcher(String src);
		
		//验证
		boolean matched =m.matches();
		
		//查找
		boolean found = m.find([int pos]);
		//替换
		String rtn = m.replaceFirst(String replacement);
		src.replaceFirst(String regex,String replacement);
		String rtn = m.replaceAll(String replacement);
		src.replace
		//分组提取
		//拆分