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 可以

1. 严格来说 Map 并不是一个集合，而是两个集合之间 的映射关系。
2. 这两个集合每一条数据通过映射关系，我们可以看成是一条数据。即 Entry(key,value）。Map 可以看成是由多个 Entry 组成。
3. 因为 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
熊少文