java-正则表达式-集合-泛型

正则表达式

正则表达式到底是什么东西？
在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。
http://tool.oschina.net/regex/ ：正则表达式在线验证

1.正则表达式基本语法

一，两个特殊的符号'^'和'$'。他们的作用是分别指出一个字符串的开始和结束。

"^The"：表示所有以"The"开始的字符串（"There"，"The cat"等）；
"of despair$"：表示所以以"of despair"结尾的字符串；
"^abc$"：表示开始和结尾都是"abc"的字符串——只有"abc"自己了；
"notice"：表示任何包含"notice"的字符串。

二， '*'，'+'和'?' 这三个符号，表示一个或多个字符重复出现的次数。
它们分别表示“没有或更多”，“一次或更多”还有“没有或一次”。
在这里插入图片描述

"ab*"：表示一个字符串有一个a后面跟着零个或若干个b。（"a", "ab", "abbb",……）；
"ab+"：表示一个字符串有一个a后面跟着至少一个b或者更多；
"ab?"：表示一个字符串有一个a后面跟着零个或者一个b；
"a?b+$"：表示在字符串的末尾有零个或一个a跟着一个或几个b。//你也可以使用范围，用大括号括起，用以表示重复次数的范围。
"ab{2}"：表示一个字符串有一个a跟着2个b（"abb"）；
"ab{2,}"：表示一个字符串有一个a跟着至少2个b；
"ab{3,5}"：表示一个字符串有一个a跟着3到5个b。//还有一个'|'，表示“或”操作：
"hi|hello"：表示一个字符串里有"hi"或者"hello"；
"(b|cd)ef"：表示"bef"或"cdef"；
"(a|b)*c"：表示一串"a""b"混合的字符串后面跟一个"c"；

请注意，你必须指定范围的下限（如：“{0,2}“而不是”{,2}”）。还有，你可能注意到了，'‘，’+‘和’?'相当于"{0,}“，”{1,}“和”{0,1}"。*
三，方括号表示某些字符允许在一个字符串中的某一特定位置出现：

"[ab]"：表示一个字符串有一个"a"或"b"（相当于"a|b"）；
"[a-d]"：表示一个字符串包含小写的'a'到'd'中的一个（相当于"a|b|c|d"或者"[abcd]"）；
"^[a-zA-Z]"：表示一个以字母开头的字符串；
"[0-9]%"：表示一个百分号前有一位的数字；
",[a-zA-Z0-9]$"：表示一个字符串以一个逗号后面跟着一个字母或数字结束。你也可以在方括号里用'^'表示不希望出现的字符，
'^'应在方括号里的第一位。（如："%[^a-zA-Z]%"表示两个百分号中不应该出现字母）。
如果表示特殊字符本身，你必须在"^.$()|*+?{\"这些字符前加上转移字符'\'。

四，'.'可以替代任意的一个字符：

"a.[0-9]"：表示一个字符串有一个"a"后面跟着一个任意字符和一个数字；
"^.{3}$"：表示有任意三个字符的字符串（长度为3个的字符）；

五、常用的一些表达式的简写：
在这里插入图片描述

2.java中怎么使用正则表达式：

1、匹配验证-验证Email是否正确

	public static void main(String[] args) {// 要验证的字符串String str="service@xsoftlab.net";//邮箱验证规则,以数字字母开头，下划线String regEx ="^[a-zA-Z0-9]+([._-]*|[a-zA-Z0-9]*)*@[a-zA-Z0-9]+([-.]*|[a-zA-Z0-9]*)*\\.[a-zA-Z0-9]{2,4}$";//编译正则表达式Pattern pattern=Pattern.compile(regEx);// 忽略大小写的写法// Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);Matcher matcher = pattern.matcher(str);// 字符串是否与正则表达式相匹配boolean rs=matcher.matches();System.out.println(rs);}

集合

集合的由来
通常，我们的程序需要根据程序运行时才知道创建多少个对象。但若非程序运行，程序开发阶段，我们根本不知道到底需要多少个数量的对象，甚至不知道它的准确类型。为了满足这些常规的编程需要，我们要求能在任何时候，任何地点创建任意数量的对象，而这些对象用什么来容纳呢？首先我们前面讲解了数组，但是数组一方面只能存放同一类型的数据，另一方面其长度是固定的，显然不满足前面的需求，所以集合便应运而生了！
集合是什么？
Java集合类存放于 java.util 包中，是一个用来存放对象的容器。
①、集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入的，Java中每一种基本类型都有对应的引用类型。
②、集合存放的是多个对象的引用，对象本身还是放在堆内存中。
③、集合可以存放不同类型,但我们常用类型来限制，类型参数化，即泛型，不限数量的数据类型。
Java 集合框架图
在这里插入图片描述
从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

①Iterator:迭代器

它是Java集合的顶层接口（不包括 map 系列的集合，Map接口是 map 系列集合的顶层接口）

Object next()：返回迭代器刚越过的元素的引用，返回值是 Object，需要强制转换成自己需要的类型
boolean hasNext()：判断容器内是否还有可供访问的元素
void remove()：删除迭代器刚越过的元素
所以除了 map 系列的集合，我们都能通过迭代器来对集合中的元素进行遍历。

注意：我们可以在源码中追溯到集合的顶层接口，比如 Collection 接口，可以看到它继承的是类 Iterable
在这里插入图片描述
那这就得说明一下 Iterator 和 Iterable 的区别：
Iterable ：存在于 java.lang 包中。我们可以看到，里面封装了 Iterator 接口。所以只要实现了只要实现了Iterable接口的类，就可以使用Iterator迭代器了。
Iterator ：存在于 java.util 包中。核心的方法next(),hasnext(),remove()。
这里我们引用一个Iterator 的实现类 ArrayList 来看一下迭代器的使用：

public class CollctionTest {public static void main(String[] args) {Collection collection=new ArrayList();collection.add("张三");collection.add("熊少文");collection.add("黄少华");Iterator iterator=collection.iterator();while(iterator.hasNext()) {String str =(String)iterator.next();System.out.println(str);}}}
----------------------------
张三
熊少文
黄少华

②Collection:List 接口和 Set 接口的父接口

在这里插入图片描述
看一下上面迭代器中用了Collection 集合的使用例子：
我们这里将 ArrayList集合作为 Collection 的实现类，它有如下方法
1.boolean isEmpty(); 判断集合是否为空
2.boolean remove(Object obj)
3.boolean removeAll(Collection c);
4.boolean contains(Object obj)
5.add(Object obj)

public class CollctionTest {public static void main(String[] args) {Collection collection=new ArrayList();collection.add("张三");collection.add("熊少文");collection.add("黄少华");collection.remove("张三");System.out.println("张三是否存在:"+collection.contains("张三"));Iterator iterator=collection.iterator();//while遍历while(iterator.hasNext()) {String str =(String)iterator.next();System.out.println(str);}System.out.println();//for遍历for(Object obj:collection) {System.out.println(obj.toString());}}}
---------------------------------------------------------------
张三是否存在:false
熊少文
黄少华熊少文
黄少华

③List :有序，可以重复的集合。

在这里插入图片描述
List 接口的三个典型实现：
　 ①、List list1 = new ArrayList();
　　　　底层数据结构是数组，查询快，增删慢; 线程不安全，效率高,最常用的List接口实现。
　 ②、List list2 = new Vector();
　　　　底层数据结构是数组，查询快，增删慢; 线程安全，效率低,几乎已经淘汰了这个集合
　 ③、List list3 = new LinkedList();
　　　　底层数据结构是链表，查询慢，增删快; 线程不安全，效率高
List 接口遍历还可以使用普通 for 循环进行遍历，指定位置添加元素，替换元素等等。
List常用的方法：除了上面的5个，还有如下
① list.add(2, Object obj);在指定地方添加元素，2是索引，obj是要插入的值
② list.set(2, Object obj); 在指定地方替换元素，2是索引，obj是要替换原目标的值
③ list.indexOf(Object obj); 获得指定对象的索引

		//List接口应用List list=new ArrayList();list.add(1);list.add(2);list.add(3);list.add(4);list.add(5);list.set(1,10);   //集合中第一个元素值换成10了System.out.println("10这个值的元素，是第"+list.indexOf(10)+"个元素");}
--------------------------------------------------------------------
10这个值的元素，是第1个元素

④Set：典型实现 HashSet()是一个无序，不可重复的

1、Set hashSet = new HashSet();
　　①、HashSet:不能保证元素的顺序；不可重复；不是线程安全的；集合元素可以为 NULL;
　　②、其底层其实是一个数组，存在的意义是加快查询速度。我们知道在一般的数组中，元素在数组中的索引位置是随机的，元素的取值和元素的位置之间不存在确定的关系，因此，在数组中查找特定的值时，需要把查找值和一系列的元素进行比较，此时的查询效率依赖于查找过程中比较的次数。而 HashSet 集合底层数组的索引和值有一个确定的关系：index=hash(value),那么只需要调用这个公式，就能快速的找到元素或者索引。
　　③、对于 HashSet: 如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

当向HashSet集合中存入一个元素时，HashSet会先调用该对象的hashCode（）方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置
　　　1、如果 hashCode 值和现存的对象的都不同，直接把该元素存储到 hashCode() 指定的位置
　　2、如果 hashCode 值和现存的对象中某一个对象的相同，那么会继续判断该元素和集合对象的 equals() 作比较
　　　　　　　2.1、hashCode 相同，equals 为 true，则视为同一个对象，不保存在 hashSet（）中
　　　　　　　2.2、hashCode 相同，equals 为 false，则存储在之前对象同槽位的链表上，这非常麻烦，我们应该约束这种情况，即保证：如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。（着也是前面强调重写equals方法一定要重写hashCode方法的原因）
注意： 每一个存储到哈希表中的对象，都得提供 hashCode() 和 equals() 方法的实现，用来判断是否是同一个对象
　　　对于 HashSet 集合，我们要保证如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。
2、Set linkSet = new LinkedHashSet();

3、Set treeSet = new TreeSet();
TreeSet:有序；不可重复，底层使用红黑树算法，擅长于范围查询。

如果使用 TreeSet() 无参数的构造器创建一个 TreeSet 对象, 则要求放入其中的元素的类必须实现 Comparable 接口，所以, 在其中不能放入 null 元素
必须放入同样类的对象.(默认会进行排序) 否则可能会发生类型转换异常.我们可以使用泛型来进行限制
Set treeSet = new TreeSet();
treeSet.add(1); //添加一个 Integer 类型的数据
treeSet.add(“a”); //添加一个 String 类型的数据
System.out.println(treeSet); //会报类型转换异常的错误

⑤Map：key 不允许重复，value 可以

严格来说 Map 并不是一个集合，而是两个集合之间的映射关系。
这两个集合每一条数据通过映射关系，我们可以看成是一条数据。即 Entry(key,value）。Map 可以看成是由多个 Entry 组成。
因为 Map 集合即没有实现于 Collection 接口，也没有实现 Iterable 接口，所以不能对 Map 集合进行 foreach 遍历。
Map 的常用方法：

public class MapTest {public static void main(String[] args) {Map hashmap = new HashMap();//addhashmap.put("key1", "value1");hashmap.put("key2", "value2");hashmap.put("key3", "value3");hashmap.put("key4", "value4");hashmap.put("key5", "value5");hashmap.put("key6", "value6");//deletehashmap.remove("key5");//get valueSystem.out.println(hashmap.get("key1"));//通过添加，改变值hashmap.put("key2", "value22");//通过 map.values() 方法得到 Map 中的 value 集合Collection values=hashmap.values();for(Object obj:values) {System.out.println(obj);}//通过keySet（）拿到键集合,整合get方法又可拿到键值Set keyset= hashmap.keySet();for(Object obj:keyset) {System.out.println("key: "+obj+"  "+"value:"+" "+hashmap.get(obj));}//Entry关系映射类，通过它可以拿到，键值Set<Map.Entry<String,String>> entryset = hashmap.entrySet();for(Map.Entry<String,String> entry:entryset) {System.out.println("key:"+entry.getKey()+"  "+"value:"+entry.getValue());}}}
-------------------------------------------------------------------------------
value1
value1
value22
value6
value3
value4
key: key1  value: value1
key: key2  value: value22
key: key6  value: value6
key: key3  value: value3
key: key4  value: value4
key:key1  value:value1
key:key2  value:value22
key:key6  value:value6
key:key3  value:value3
key:key4  value:value4

Map 和 Set 集合的关系
1、都有几个类型的集合。HashMap 和 HashSet ，都采哈希表算法；TreeMap 和 TreeSet 都采用红-黑树算法；LinkedHashMap 和 LinkedHashSet 都采用哈希表算法和红-黑树算法。
2、分析 Set 的底层源码，我们可以看到，Set 集合就是由 Map 集合的 Key 组成。

泛型

概述

         泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。
什么是泛型？为什么要使用泛型？
      泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
      顾名思义，就是将原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），
然后在使用/调用时传入具体的类型（类型实参）。
      泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参的类型，从而限制类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

举例说明

/** 集合不像数组那样，只能放一种数据类型，所以我们这里这样测试* 1.先不类型参数化，不限制类型，我即往集合中加了对象，也加入基本数据类型*    当我们遍历所有元素时，编译不会报错，但运行时会报错，类型转换异常*/
public class ListShuoMingTest {public static void main(String[] args) {List list=new ArrayList();list.add("abc");list.add(100);list.add("熊少文");for(int i=0;i<list.size();i++) {String string=(String)list.get(i);System.out.println(string);}}}
------------------------------------------------------------------------------------
abc
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to.....

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。
我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

List<String> arrayList = new ArrayList<String>();

arrayList.add(100); 在编译阶段，编译器就会报错

public class ListShuoMingTest {public static void main(String[] args) {/*List list=new ArrayList();list.add("abc");list.add(100);list.add("熊少文");for(int i=0;i<list.size();i++) {String string=(String)list.get(i);System.out.println(string);}*///加了类型限制，泛型类List<String> list=new ArrayList<String>();list.add("abc");//list.add(100);           //编译就会出错list.add("熊少文");for(int i=0;i<list.size();i++) {String string=(String)list.get(i);System.out.println(string);}}}
------------------------------------------------------------------------
abc
熊少文