java复习第十三天效验QQ,集合框架的用法,泛型,正则的书写和效验

1.定义一个类:Order
    包含3个属性: 订单号,订单总金额,订单商品项(数组);   
包含一个构造方法,用来给对象的属性一次性赋值;
写一个测试程序:
创建5个order对象,并都要给属性赋值;
然后将5个order对象存入一个数组;
然后对数组中的order对象按订单总金额大小倒序排序;
然后打印整个数组中的5个order对象的属性信息(要求采用重写toString()的方式实现);
新增需求:
1.求出成交金额最大的那个订单,并打印
2.求出成交金额排在前3的订单,并打印

3.求出这5个订单的总成交金额

import java.util.Arrays;

public class Order {
	private String id;
	private float total;
	private String[] names;

	public Order() {
		super();
	}

	public Order(String id, float total, String[] names) {
		this.id = id;
		this.total = total;
		this.names = names;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public float getTotal() {
		return total;
	}

	public void setTotal(float total) {
		this.total = total;
	}

	public String[] getNames() {
		return names;
	}

	public void setNames(String[] names) {
		this.names = names;
	}

	@Override
	public String toString() {
		return "Order [id=" + id + ", total=" + total + ", names=" + Arrays.toString(names) + "]";
	}
}
public class OrderTest {
	public static void main(String[] args) {
		// 创建5个order对象,并都要给属性赋值;
		Order o1 = new Order("xxx10001", 1000, new String[] { "方便面", "火腿肠", "微波炉", "不粘锅", "瓷碗" });
		Order o2 = new Order("xxx10002", 8000, new String[] { "苹果8", "蓝牙耳机", "手机套", "自拍杆", "钢化膜" });
		Order o3 = new Order("xxx10003", 200, new String[] { "苹果", "香蕉", "梨", "草莓", "橘子" });
		Order o4 = new Order("xxx10004", 3000, new String[] { "耐克运动鞋", "耐克外套", "耐克运动裤" });
		Order o5 = new Order("xxx10005", 10000, new String[] { "联想电脑", "防辐射眼镜", "固态硬盘", "内存条" });
		// 然后将5个order对象存入一个数组;
		Order[] orders = { o1, o2, o3, o4, o5 };
		// 然后对数组中的order对象按订单总金额大小倒序排序;
		for (int i = 0; i < orders.length - 1; i++) {
			for (int j = i + 1; j < orders.length; j++) {
				// 大的订单就往前放
				if (orders[i].getTotal() < orders[j].getTotal()) {
					Order temp = orders[i];
					orders[i] = orders[j];
					orders[j] = temp;
				}
			}
		}
		// 然后打印整个数组中的5个order对象的属性信息(要求采用重写toString()的方式实现);
		for (int i = 0; i < orders.length; i++) {
			System.out.println(orders[i]);
		}
		System.out.println("------------------------------------------");

		// 新增需求:
		// 1.求出成交金额最大的那个订单,并打印
		System.out.println("1.求出成交金额最大的那个订单,并打印:");
		System.out.println(orders[0]);
		System.out.println("------------------------------------------");
		// 2.求出成交金额排在前3的订单,并打印
		System.out.println("2.求出成交金额排在前3的订单,并打印:");
		for (int i = 0; i < 3; i++) {
			System.out.println(orders[i]);
		}
		System.out.println("------------------------------------------");
		// 3.求出这5个订单的总成交金额
		float sum = 0;
		for (int i = 0; i < orders.length; i++) {
			sum += orders[i].getTotal();
		}
		System.out.println("3.求出这5个订单的总成交金额:");
		System.out.println("sum=" + sum);
	}
}
2.校验QQ号码,用两种方法实现(1)原理(2)正则
1.要求必须是5-15位数字

2.不能以数字0不能开头

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Scanner;

/*
 * 校验QQ号码
		1.要求必须是5-15位数字
		2.不能以数字0不能开头
 */
public class CheckQQDemo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入要注册的QQ号:");
		String qq = sc.nextLine();
		// 调用校验QQ的方法
		boolean b = checkQQ(qq);
		System.out.println(b);
		
	}

	/**
	 * 校验QQ号是否合法
	 * 
	 * @param qq
	 *            要校验的QQ号
	 * @return true表示成功,反之表示失败
	 */
	private static boolean checkQQ(String qq) {
		/*// 1.要求必须是5-15位数字
		if(qq.length()>=5 && qq.length()<=15){
			// 2.不能以数字0不能开头
			if(!qq.startsWith("0")){
				//遍历每一个字符,判断有没有不是数字的
				for(int i=0; i<qq.length(); i++){
					char ch = qq.charAt(i);
					//如果ch不是数字
					if(!Character.isDigit(ch)){
						return false;
					}
				}
				return true;
			}
		}
		
		return false;*/
		//[0-9]{4,14} [0-9],至少4 次,但是不超过 14 次 
		//return qq.matches("[1-9][0-9]{4,14}");
		return qq.matches("[1-9]\\d{4,14}");
	}
}

3.ArrayList和LinkedList

import java.util.Iterator;
import java.util.LinkedList;

/*
 * ArrayList:底层是数组实现,查询和更新比较快,增删比较慢
 * LinkedList:底层是链表实现,查询和更新比较慢,增删比较快
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		// LinkedList类特有功能
		// public void addFirst(E e)将指定元素插入此列表的开头
		// public voidaddLast(E e)将指定元素添加到此列表的结尾
		// public E getFirst()返回此列表的第一个元素
		// public E getLast()返回此列表的最后一个元素
		// public E removeFirst()移除并返回此列表的第一个元素
		// public E removeLast()移除并返回此列表的最后一个元素

		//往ArrayList里面添加自定义对象
		//ArrayList list = new ArrayList();
		//往LinkedList里面添加自定义对象
		LinkedList list = new LinkedList();
		list.add(new Person("张三",18,'男'));
		list.add(new Person("李四",18,'男'));
		list.add(new Person("王五",18,'男'));
		list.add(new Person("赵六",18,'男'));
		Iterator iterator = list.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		System.out.println("------------------------------------");
		for(int i=0; i<list.size(); i++){
			System.out.println(list.get(i));
		}
	}
}

4.Collection的用法

(1)

import java.util.ArrayList;
import java.util.Collection;

/*
 * Collection 层次结构 中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。
 * 一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。
 * JDK 不提供此接口的任何直接 实现:它提供更具体的子接口(如 Set 和 List)实现。此接口通常用来传递 collection,
 * 并在需要最大普遍性的地方操作这些 collection。 
 */
public class CollectionDemo {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		// boolean add(E e)添加一个元素,添加成功返回true
		c.add("张三");
		c.add("李四");
		c.add("王五");
		c.add(120);//自动装箱
		c.add(110);
		c.add(119);
		System.out.println(c);//[张三, 李四, 王五, 120, 110, 119]

		// boolean remove(Object o)删除指定的元素,删除成功返回true
		System.out.println(c.remove(120));//true
		System.out.println(c);//[张三, 李四, 王五, 110, 119]
		
		// void clear()清空集合
		//c.clear();
		//System.out.println(c);//[]
		
		// boolean contains(Object o)判断是否包含指定元素
		System.out.println(c.contains(120));//false
		
		// boolean isEmpty()判断集合是否为空
		System.out.println(c.isEmpty());//false
		
		// int size()返回集合的实际大小
		System.out.println(c.size());//5

	}
}

(2)

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo2 {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add(110);
		c.add(120);
		c.add(119);
		System.out.println("C:"+c);//C:[110, 120, 119]
		Collection c2 = new ArrayList();
		c2.add("张三");
		c2.add("李四");
		c2.add("王五");
		System.out.println("C2:"+c2);//C2:[张三, 李四, 王五]
		
		// boolean addAll(Collection c)将指定 collection 中的所有元素都添加到此 collection 中
		c.addAll(c2);
		System.out.println("C:"+c);//C:[110, 120, 119, 张三, 李四, 王五]
		System.out.println("C2:"+c2);//C2:[张三, 李四, 王五]
		
		// boolean removeAll(Collection c)移除此 collection 中那些也包含在指定 collection 中的所有元素
		c.removeAll(c2);
		System.out.println("C:"+c);//C:[110, 120, 119]
		System.out.println("C2:"+c2);//C2:[张三, 李四, 王五]
		
		// boolean containsAll(Collection c) 如果此 collection 包含指定 collection 中的所有元素,则返回 true
		c.addAll(c2);
		System.out.println("C:"+c);//C:[110, 120, 119, 张三, 李四, 王五]
		c2.add("哈哈");
		System.out.println("C2:"+c2);//C2:[张三, 李四, 王五, 哈哈]
		System.out.println(c.containsAll(c2));//false
		
		// boolean retainAll(Collection c)仅保留此 collection 中那些也包含在指定 collection 的元素
		c.retainAll(c2);
		System.out.println("C:"+c);//C:[张三, 李四, 王五]
		System.out.println("C2:"+c2);//C2:[张三, 李四, 王五, 哈哈]
	}
}

(3)List集合

import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;

 /*
  * List集合特点:可以通过索引操作元素,存入和取出顺序保持一致,可以有重复元素
  */
 public class ListDemo {
 	public static void main(String[] args) {
 		List list = new ArrayList();
 		list.add("张三");
 		list.add("李四");
 		list.add("王五");
 		System.out.println(list);// [张三, 李四, 王五]

 		// void add(int index,E element)往指定索引位置插入元素值
 		list.add(1, "哈哈");
 		System.out.println(list);// [张三, 哈哈, 李四, 王五]

 		// E remove(int index)删除指定索引对应的值,返回被删除的元素值
 		list.add(1);// 自动装箱
 		list.remove(1);// 删除索引1对应的值
 		list.remove((Integer) 1);// 删除Integer对象1
 		System.out.println(list);// [张三, 李四, 王五]

 		// E get(int index)获取索引对应的值
 		System.out.println(list.get(1));// 李四

 		// E set(int index,E element)替换指定索引对应的元素值,返回被替换的值
 		System.out.println(list.set(1, "隔壁老王"));// 李四
 		System.out.println(list);// [张三, 隔壁老王, 王五]
 		System.out.println("-------------------------------------");

 		// ListIterator listIterator()List集合特有的迭代器
 		ListIterator listIterator = list.listIterator();
 		// boolean hasNext() 以正向遍历列表时,如果列表迭代器有多个元素,则返回 true
 		while (listIterator.hasNext()) {
 			// E next() 返回列表中的下一个元素
 			System.out.println(listIterator.next());
 		}
 		System.out.println("-------------------------------------");

 		// boolean hasPrevious() 如果以逆向遍历列表,列表迭代器有多个元素,则返回 true
 		while (listIterator.hasPrevious()) {//必须先正序,然后才能逆序
 			// E previous() 返回列表中的前一个元素
 			System.out.println(listIterator.previous());
 		}
 	}
 }

(4)遍历list集合

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo3 {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("张三");
		c.add("李四");
		c.add("王五");
		System.out.println(c);//[张三, 李四, 王五]
		
		//遍历方式一:将集合转换成数组遍历
		//Object[] toArray()返回包含此 collection 中所有元素的数组 
		Object[] arr = c.toArray();
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i]+" ");//张三 李四 王五 
		}
		System.out.println();
		System.out.println("--------------------------------------");
		
		//遍历方式二:使用迭代器进行遍历
		//Iterator<E> iterator()返回在此 collection 的元素上进行迭代的迭代器
		Iterator iterator = c.iterator();
		//boolean hasNext()如果仍有元素可以迭代,则返回 true。 
		while(iterator.hasNext()){
			//E next()返回迭代的下一个元素。 
			Object obj = iterator.next();
			System.out.println(obj);
			//java.util.ConcurrentModificationException:并发修改异常,使用迭代器进行遍历时,不能直接通过集合的引用修改元素的值
			//如果在使用迭代器进行遍历元素时,如果一定要修改集合里面的元素,那么只能通过迭代器进行修改,不能通过集合引用直接修改
			/*if(obj.equals("张三")){//判断当前集合中有没有“张三”,如果有就删除
				c.remove(obj);
			}*/
		}
	}
}

5.泛型

(1)泛型的起源

/*
 * 	JDK1.5以后出现的机制
	为什么会有泛型呢?
		早期的Object类型可以接收任意的对象类型,但是在实际的使用中,
		会有类型转换的问题。也就存在这隐患,所以Java提供了泛型来解决这个安全问题。
	
	泛型如果没有明确指定,那么就是Object类型
	泛型如果明确指定了,那么就是指定的类型
	
	泛型的特点:
		泛型只能用引用类型,不能用基本数据类型
		提高了安全性,省去了类型强制可能发生的错误
		只存在编译时期,编译成字节码文件之后就会消失
 */
public class GenericDemo {
	public static void main(String[] args) {
		//泛型如果没有明确指定,那么就是Object类型
		//test();
		
		//泛型如果明确指定了,那么就是指定的类型
		test2();
	}

	//泛型如果没有明确指定,那么就是Object类型
	private static void test2() {
		ArrayList<String> list = new ArrayList<String>();//JDK1.7新特性,从左边的泛型能推理出右边的泛型
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("赵六");
		
		String s = list.get(0);
		System.out.println(s);//张三
		
		Iterator<String> iterator = list.iterator();
		while(iterator.hasNext()){
			String v = iterator.next();
			System.out.println(v);
		}
	}
	
	//泛型如果明确指定了,那么就是指定的类型
	private static void test() {
		ArrayList list = new ArrayList();
		list.add(110);
		list.add("120");
		list.add(new Object());
		list.add(new GenericDemo());
		list.add("哈哈");
		
		Object obj = list.get(1);
		int i = (int) obj;
		System.out.println(i);//110
	}
}

(2)将泛型定义在类中

public class GenericClass {
	public static void main(String[] args) {
		MyArrayList<String> list = new MyArrayList<String>();
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("张三");
		list.add("李四");
		list.add("王五");
		System.out.println(list.get(1));// 张三
		System.out.println(list);// [张三, 李四, 王五]
	}
}

/*
 * 泛型类
	把泛型定义在类上:泛型的作用范围是整个类
	格式:public class 类名<泛型类型1,…>
	注意:泛型类型必须是引用类型

 */
class MyArrayList<T> {
	Object[] elementData = new Object[10];

	public boolean add(T e) {
		// 遍历数组,判断当前数组元素是否为null,如果为null就将当前的值添加进去
		for (int i = 0; i < elementData.length; i++) {
			if (elementData[i] == null) {
				elementData[i] = e;
				return true;
			}
		}
		return false;
	}

	public T get(int index) {
		// 判断有没有越界
		if (index < 0 || index > elementData.length - 1) {
			System.out.println("你访问的索引不存在");
			return null;
		}
		return (T) elementData[index];
	}

	@Override
	public String toString() {
		// 将不是null的值拼接完成之后返回
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for (int i = 0; i < elementData.length; i++) {
			if (null != elementData[i]) {
				sb.append(elementData[i] + ",");
			} else {
				break;
			}
		}
		//将多余的","去掉
		//SB中的值:[张三, 李四, 王五,
		String result = sb.toString().substring(0, sb.length()-1)+"]";

		return result;
	}
}

(3)将泛型定义在接口上

public class GenericInterface<E,T> implements Inter<E>{

	@Override
	public void test(E t) {
		
	}

}

/*
 * 泛型接口
	把泛型定义在接口上:泛型可以一直传递下去,作用域整个类
	格式:public  interface 接口名<泛型类型1…>
 */
interface Inter<T>{
	void test(T t);
}

(4)将泛型定义在方法上

public class GenericMethod {
	public static void main(String[] args) {
		Object obj = "哈哈";
		//String s = (String) obj;
		String s = cast(obj);
		System.out.println(s);//哈哈

		obj = 123;//自动装箱
		//Integer i = (Integer) obj;//自动拆箱
		Integer i = cast(obj);
		System.out.println(i);//123
	}
	
	/**
	 * 泛型方法
		把泛型定义在方法上:作用域整个方法
		格式:public <泛型类型> 返回类型 方法名(泛型类型 .)
	 */
	public static <T> T cast(Object obj){
		return (T) obj;
	}
}
6.效验手机号码和效验邮箱
import java.util.Scanner;

/*
 * public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式
 * 	校验手机号码
 * 		18113115466
 * 		13865451102
 * 		15689898989
 * 		14489890890
 * 		17789089009
 * 		13489089089
 * 		18832343433
 * 		16989898989
 * 		13313343243
 * 		15080980890
 * 		13145345435
 * 		13978978989
	校验邮箱
		xzy@qq.com
		989080@qq.com
		2323jjk@sina.com.cn
		jkj32@gmail.cn
		jljl@163.com
 */
public class RegexDemo {
	public static void main(String[] args) {
		checkEmail();
	}

	private static void checkEmail() {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入要校验的邮箱:");
		String email = sc.nextLine();
		String regex = "\\w+@\\w+(\\.\\w{2,3})+";
		System.out.println(email.matches(regex));
	}

	private static void checkPhoneNumber() {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入手机号:");
		String phone = sc.nextLine();
		String regex = "1[3-9][0-9]{9}";
		System.out.println(phone.matches(regex));
	}
}


7.拆分字符串并将字符串倒序输出

import java.util.Arrays;

/*
 * public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串
 */
public class RegexDemo2 {
	public static void main(String[] args) {
		// ii,jj,kk
		String s = "ii,jj,kk";
		String regex = ",";
		String[] arr = s.split(regex);
		System.out.println(Arrays.toString(arr));//[ii, jj, kk]
		
		// ii.jj.kk
		s = "ii.jj.kk";
		regex = "\\.";
		arr = s.split(regex);
		System.out.println(Arrays.toString(arr));//[ii, jj, kk]

		// ii jj kk
		s = "ii jj kk";
		regex = " ";
		arr = s.split(regex);
		System.out.println(Arrays.toString(arr));//[ii, jj, kk]
		
		// 文件路径
		s = "E:\\每日视频\\33期JavaSE视频\\day13\\code";
		regex = "\\\\";
		arr = s.split(regex);
		System.out.println(Arrays.toString(arr));//[E:, 每日视频, 33期JavaSE视频, day13, code]
		
		// 我有如下一个字符串:”19 89 76 3 65”
		s = "19 89 76 3 65";
		//1.分割字符串,将每一个数字拿出来
		regex = " ";
		arr = s.split(regex);
		//2.将字符串数组转换成int类型数组
		//新建一个int数组
		int[] temp = new int[arr.length];
		//将字符串的值转换成int值然后添加进int数组中
		for(int i=0; i<arr.length; i++){
			int v = Integer.parseInt(arr[i]);
			temp[i] = v;
		}
		//3.调用Arrays的排序方法
		Arrays.sort(temp);
		//4.拼接结果
		StringBuilder sb = new StringBuilder();
		for(int i=0; i<temp.length; i++){
			sb.append(temp[i]+" ");
		}
		//5.取出值
		String result = sb.toString().trim();
		// 请写代码实现最终输出结果是:”3 19 65 76 89”
		System.out.println(result);//3 19 65 76 89
	}
}

8.敏感词屏蔽

/*
 * public String replaceAll(String regex,
                         String replacement)使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
 */
public class RegexDemo3 {
	public static void main(String[] args) {
		String s = "现任国家主席是习近平,上一任国家是主席胡锦涛,上上任国家主席是江泽民,第一任国家主席是毛主席,王子";
		// 将敏感词替换成*
		String regex = "(习近平)|(胡锦涛)|(江泽民)|(毛主席)|(王子)";
		String s2 = s.replaceAll(regex, "*");
		System.out.println(s2);
		
		// 论坛中不能出现数字字符,用*替换
		s = "你加我微信78797891,我送你护肤品";
		regex = "(微信)|(\\d)+";
		s2 = s.replaceAll(regex, "*");
		System.out.println(s2);
	}
}

9.截取特定长度的字符

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo4 {
	public static void main(String[] args) {
		/*
		 * Pattern和Matcher类的使用 jin tian yao xia yu,da jia pa bu pa ?huang bu
		 * huang ?are you sure? 获取由三个字符组成的单词
		 */
		
		String regex = "\\b[a-zA-Z]{3}\\b";
		//public static Pattern compile(String regex)将给定的正则表达式编译到模式中
		Pattern p = Pattern.compile(regex);
		String input = "jin tian yao xia yu,da jia pa bu pa ?huang bu huang ?are you sure?";
		//public Matcher matcher(CharSequence input)创建匹配给定输入与此模式的匹配器
		Matcher m = p.matcher(input);
		//开始查找
		//public boolean find()尝试查找与该模式匹配的输入序列的下一个子序列
		while(m.find()){
			//public String group()返回由以前匹配操作所匹配的输入子序列
			System.out.println(m.group());
		}
		//System.out.println(m.group());//No match found:必须先使用find找到对应的字符串,然后使用group取出该字符串
	}

	private static void test() {
		String regex = "a*b";
		//将给定的正则表达式编译到模式中
		Pattern p = Pattern.compile(regex);
		String input = "aaaaab";
		//创建匹配给定输入与此模式的匹配器
		Matcher m = p.matcher(input);
		//matches 方法尝试将整个输入序列与该模式匹配
		boolean b = m.matches();
		System.out.println(b);//true
		System.out.println(input.matches(regex));//true
	}
}

10.常用正则表达书的组成元素

字符 
	x 字符 x 
	\\ 反斜线字符 
	\t 制表符 ('\u0009') 
	\n 新行(换行)符 ('\u000A') 
	\r 回车符 ('\u000D') 
	\f 换页符 ('\u000C') 
字符类 
	[abc] a、b 或 c(简单类) 
	[^abc] 任何字符,除了 a、b 或 c(否定) 
	[a-zA-Z] a 到 z 或 A 到 Z,两头的字母包括在内(范围) 
预定义字符类 
	. 任何字符(与行结束符可能匹配也可能不匹配) 	想单纯的表示一个.,需要用转义\.
	\d 数字:[0-9] 
	\D 非数字: [^0-9] 
	\s 空白字符:[ \t\n\x0B\f\r] 
	\S 非空白字符:[^\s] 
	\w 单词字符:[a-zA-Z_0-9] 
	\W 非单词字符:[^\w] 
边界匹配器 
	^ 行的开头 
	$ 行的结尾 
	\b 单词边界  what are you do?
	\B 非单词边界 
	\A 输入的开头 
	\G 上一个匹配的结尾 
	\Z 输入的结尾,仅用于最后的结束符(如果有的话) 
	\z 输入的结尾 
Greedy 数量词 
	X? X,一次或一次也没有 
	X* X,零次或多次 
	X+ X,一次或多次 
	X{n} X,恰好 n 次 
	X{n,} X,至少 n 次 
	X{n,m} X,至少 n 次,但是不超过 m 次 
	

11.数组和链表的原理对比

12.栈和队列的特点


13.集合的意义


正则的补充内容

一、简述
  • 概念:符合一定规则的表达式,用于操作字符串。
  • 特点:将对字符串操作的代码用一些符号来表示。只要使用了指定符号,就可以调用底层的代码对字符串进行操作。简化了代码的书写。
  • 好处:正则的出现,对字符串的复杂操作变得更为简单。
  • 弊端:符号的出现虽然简化了书写,但是却降低了阅读性。
  • 组:
            用小括号标示,每定义一个小括号,就是一个组,而且有自动编号,从1开始。
            只要使用组,对应的数字就是使用该组的内容。别忘了,数组要加\\。
            (aaa(wwww(ccc))(eee))技巧,从左括号开始数即可。有几个左括号就是几组。
            对于组中所匹配的字符,可以用$n来获取。$在正则中表示行的结尾,所以出现在正则中不能用来表示组,一般用于替换中。
二、常见操作
  1. 匹配:其实用的就是String类中的matches方法。
              String reg = "[1-9][0-9]{4,14}";
              boolean b = qq.matches(reg);//将正则和字符串关联对字符串进行匹配。
  2. 切割:其实用的就是String类中的split方法。
  3. 替换:其实用的就是String类中的replaceAll();
  4. 获取:
    1. 先要将正则表达式编译成正则对象。使用的是Pattern中静态方法 compile(regex);
    2. 通过Pattern对象获取Matcher对象。
      • Pattern用于描述正则表达式,可以对正则表达式进行解析。
      • 而将规则操作字符串,需要从新封装到匹配器对象Matcher中。然后使用Matcher对象的方法来操作字符串。
      • 如何获取匹配器对象:通过Pattern对象中的matcher方法。该方法可以正则规则和字符串想关联。并返回匹配器对象。
    3. 使用Matcher对象中的方法即可对字符串进行各种正则操作。

  • 四种功能的选择(思路方式):
    • 如果只想知道该字符是否对是错,使用匹配。
    • 想要将已有的字符串变成另一个字符串,替换。
    • 想要按照自定的方式将字符串变成多个字符串。切割。获取规则以外的子串。
    • 想要拿到符合需求的字符串子串,获取。获取符合规则的子串。

练习:
[java] view plain copy
  1.     
  2. import java.net.*;    
  3. import java.util.regex.*;    
  4. import java.io.*;    
  5. class RegexTest   
  6. {  
  7.     public static void main(String[] args)   
  8.     {  
  9.         replace();  
  10.         checkMail();  
  11.         iPSort();  
  12.         getWebMail();  
  13.         getFileMail();  
  14.     }  
  15.     /*  
  16.     练习:  
  17.     需求:将下列字符串转成:我要学编程  
  18.     "我我...我..我要...要...要要....学学....学学学......编编编...程...程程...."  
  19.      
  20.     思路:  
  21.     将已有字符串变成另一个字符串。使用替换功能。  
  22.     1、可以先将 . 去掉。  
  23.     2、再将多个重复的内容变成单个内容。   
  24.     */  
  25.     public static void replace()  
  26.     {    
  27.         String s="我我...我..我要...要...要要....学学....学学学......编编编...程...程程....";    
  28.         System.out.println(s);  
  29.           
  30.         String regex="\\.+";//先将 . 去掉  
  31.         s=s.replaceAll(regex,"");//去掉 .   
  32.         System.out.println(s);  
  33.           
  34.         regex="(.)\\1+";//将重复的内容变成单个内容  
  35.         s=s.replaceAll(regex,"$1");//去重  
  36.         System.out.println(s)  
  37.     }  
  38.     //匹配邮箱  
  39.     public static void checkMail()  
  40.     {  
  41.         String mail="123a809bc@sina.com.cn";    
  42.         String regex="\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";//较为精确    
  43.         //regex="\\w+@\\w+(\\.\\w+)+";//相对不太精确的匹配。  
  44.         boolean b=mail.matches(regex);    
  45.         System.out.println(b);    
  46.     }    
  47.     /*  
  48.     需求:  
  49.     将ip地址进行地址段顺序的排序。  
  50.     192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.301  
  51.      
  52.     思路:  
  53.     还按照字符串自然顺序,只要让他们每一段都是3位即可。  
  54.     1、按照每一段需要的最多的0进行补齐,那么每一段就会至少保证有3位。  
  55.     2、将每一段只保留3位。这样,所有的ip地址都是每一段3位。  
  56.     */    
  57.     public static void iPSort()     
  58.     {  
  59.         String ip="192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.301";    
  60.         System.out.println(ip);  
  61.         String regex="(\\d+)";    
  62.           
  63.         ip=ip.replaceAll(regex,"00$1");//保证每段至少都有三位  
  64.         System.out.println(ip);    
  65.           
  66.         regex="0*(\\d{3})";    
  67.         ip=ip.replaceAll(regex,"$1");//每段只保留三位    
  68.         System.out.println(ip);    
  69.           
  70.         regex=" ";    
  71.         String[] arr=ip.split(regex);//按照空格切    
  72.         //定义一个TreeSet集合,利用元素自然排序    
  73.         TreeSet<String > ts=new TreeSet<String>();    
  74.         for (String str : arr )    
  75.         {    
  76.             ts.add(str);//添加    
  77.         }    
  78.           
  79.         regex="0*(\\d)";//把每段前面多余的0替换掉    
  80.         for (String s : ts)    
  81.         {    
  82.             System.out.println(s.replaceAll(regex,"$1"));//把每段前面多余的0替换掉    
  83.         }    
  84.     }    
  85.       
  86.     /*  
  87.     网络爬虫(蜘蛛)  
  88.     实际上是一个功能,用于搜集网络上的指定信息  
  89.     需求:可用于收集邮箱,qq号等之类的信息。  
  90.     应用:如通过关键字搜索blog,实际就是使用的“蜘蛛”,通过查找关键字获取相关的blog  
  91.     */    
  92.     //获取网页中mail    
  93.     public static  void getWebMail()throws Exception    
  94.     {    
  95.         //封装网页地址    
  96.         URL url=new URL("http://tieba.baidu.com/p/1390896758");    
  97.         //连接服务器    
  98.         URLConnection conn=url.openConnection();    
  99.         //带缓冲区的网页读取流    
  100.         BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));    
  101.         String line=null;     
  102.         //定义匹配邮件地址的正则表达式    
  103.         String regex="\\w+@\\w+(\\.\\w+)+";    
  104.         Pattern p=Pattern.compile(regex);//封装正则表达式    
  105.         //读取网页数据    
  106.         while ((line=br.readLine())!=null)    
  107.         {    
  108.             //正则关联数据    
  109.             Matcher m=p.matcher(line);    
  110.             //寻找匹配邮箱    
  111.             while (m.find())    
  112.             {    
  113.                 System.out.println(m.group());//输出匹配邮箱    
  114.             }           
  115.         }       
  116.     }    
  117.       
  118.     //获取指定文档中的邮件地址。使用获取功能。Pattern  Matcher    
  119.     public static void getFileMail()throws Exception    
  120.     {    
  121.         //将文件封装成对象    
  122.         File file=new File("E:\\Java Study\\Practice\\day25\\mail.txt");    
  123.         //创建带缓冲区的读取流    
  124.         BufferedReader br=new BufferedReader(new FileReader(file));    
  125.         String line=null;    
  126.           
  127.         //定义正则表达式    
  128.         String regex="\\w+@[a-zA-Z]+(\\.[a-zA-z]+)+";    
  129.         //创建Pattern对象,封装正则表达式    
  130.         Pattern p=Pattern.compile(regex);    
  131.           
  132.         //读取文件中数据    
  133.         while ((line=br.readLine())!=null)    
  134.         {       
  135.             //关流字符串    
  136.             Matcher m=p.matcher(line);    
  137.             while (m.find())//寻找匹配的字符串    
  138.             {    
  139.                 System.out.println(m.group());//输出匹配的字符串    
  140.             }    
  141.         }    
  142.     }     
  143. }  


阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭