1.
定义一个类：Order
包含3个属性： 订单号，订单总金额，订单商品项（数组）；
包含一个构造方法，用来给对象的属性一次性赋值；
写一个测试程序：
创建5个order对象，并都要给属性赋值；
然后将5个order对象存入一个数组；
然后对数组中的order对象按订单总金额大小倒序排序；
然后打印整个数组中的5个order对象的属性信息（要求采用重写toString()的方式实现）；
新增需求：
1.求出成交金额最大的那个订单，并打印
2.求出成交金额排在前3的订单，并打印
1.要求必须是5-15位数字
包含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 校验邮箱 [email protected] [email protected] [email protected] [email protected] [email protected] */ 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来获取。$在正则中表示行的结尾，所以出现在正则中不能用来表示组，一般用于替换中。
- 匹配：其实用的就是String类中的matches方法。
String reg = "[1-9][0-9]{4,14}";
boolean b = qq.matches(reg);//将正则和字符串关联对字符串进行匹配。 - 切割：其实用的就是String类中的split方法。
- 替换：其实用的就是String类中的replaceAll();
- 获取：
- 先要将正则表达式编译成正则对象。使用的是Pattern中静态方法 compile(regex);
- 通过Pattern对象获取Matcher对象。
- Pattern用于描述正则表达式，可以对正则表达式进行解析。
- 而将规则操作字符串，需要从新封装到匹配器对象Matcher中。然后使用Matcher对象的方法来操作字符串。
- 如何获取匹配器对象：通过Pattern对象中的matcher方法。该方法可以正则规则和字符串想关联。并返回匹配器对象。
- 使用Matcher对象中的方法即可对字符串进行各种正则操作。
- 四种功能的选择（思路方式）：
- 如果只想知道该字符是否对是错，使用匹配。
- 想要将已有的字符串变成另一个字符串，替换。
- 想要按照自定的方式将字符串变成多个字符串。切割。获取规则以外的子串。
- 想要拿到符合需求的字符串子串，获取。获取符合规则的子串。
练习：
- import java.net.*;
- import java.util.regex.*;
- import java.io.*;
- class RegexTest
- {
- public static void main(String[] args)
- {
- replace();
- checkMail();
- iPSort();
- getWebMail();
- getFileMail();
- }
- /*
- 练习：
- 需求：将下列字符串转成：我要学编程
- "我我...我..我要...要...要要....学学....学学学......编编编...程...程程...."
- 思路：
- 将已有字符串变成另一个字符串。使用替换功能。
- 1、可以先将 . 去掉。
- 2、再将多个重复的内容变成单个内容。
- */
- public static void replace()
- {
- String s="我我...我..我要...要...要要....学学....学学学......编编编...程...程程....";
- System.out.println(s);
- String regex="\\.+";//先将 . 去掉
- s=s.replaceAll(regex,"");//去掉 .
- System.out.println(s);
- regex="(.)\\1+";//将重复的内容变成单个内容
- s=s.replaceAll(regex,"$1");//去重
- System.out.println(s)
- }
- //匹配邮箱
- public static void checkMail()
- {
- String mail="[email protected]";
- String regex="\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}";//较为精确
- //regex="\\w+@\\w+(\\.\\w+)+";//相对不太精确的匹配。
- boolean b=mail.matches(regex);
- System.out.println(b);
- }
- /*
- 需求：
- 将ip地址进行地址段顺序的排序。
- 192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.301
- 思路：
- 还按照字符串自然顺序，只要让他们每一段都是3位即可。
- 1、按照每一段需要的最多的0进行补齐，那么每一段就会至少保证有3位。
- 2、将每一段只保留3位。这样，所有的ip地址都是每一段3位。
- */
- public static void iPSort()
- {
- String ip="192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.301";
- System.out.println(ip);
- String regex="(\\d+)";
- ip=ip.replaceAll(regex,"00$1");//保证每段至少都有三位
- System.out.println(ip);
- regex="0*(\\d{3})";
- ip=ip.replaceAll(regex,"$1");//每段只保留三位
- System.out.println(ip);
- regex=" ";
- String[] arr=ip.split(regex);//按照空格切
- //定义一个TreeSet集合，利用元素自然排序
- TreeSet<String > ts=new TreeSet<String>();
- for (String str : arr )
- {
- ts.add(str);//添加
- }
- regex="0*(\\d)";//把每段前面多余的0替换掉
- for (String s : ts)
- {
- System.out.println(s.replaceAll(regex,"$1"));//把每段前面多余的0替换掉
- }
- }
- /*
- 网络爬虫（蜘蛛）
- 实际上是一个功能，用于搜集网络上的指定信息
- 需求：可用于收集邮箱，qq号等之类的信息。
- 应用：如通过关键字搜索blog，实际就是使用的“蜘蛛”，通过查找关键字获取相关的blog
- */
- //获取网页中mail
- public static void getWebMail()throws Exception
- {
- //封装网页地址
- URL url=new URL("http://tieba.baidu.com/p/1390896758");
- //连接服务器
- URLConnection conn=url.openConnection();
- //带缓冲区的网页读取流
- BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
- String line=null;
- //定义匹配邮件地址的正则表达式
- String regex="\\w+@\\w+(\\.\\w+)+";
- Pattern p=Pattern.compile(regex);//封装正则表达式
- //读取网页数据
- while ((line=br.readLine())!=null)
- {
- //正则关联数据
- Matcher m=p.matcher(line);
- //寻找匹配邮箱
- while (m.find())
- {
- System.out.println(m.group());//输出匹配邮箱
- }
- }
- }
- //获取指定文档中的邮件地址。使用获取功能。Pattern Matcher
- public static void getFileMail()throws Exception
- {
- //将文件封装成对象
- File file=new File("E:\\Java Study\\Practice\\day25\\mail.txt");
- //创建带缓冲区的读取流
- BufferedReader br=new BufferedReader(new FileReader(file));
- String line=null;
- //定义正则表达式
- String regex="\\w+@[a-zA-Z]+(\\.[a-zA-z]+)+";
- //创建Pattern对象，封装正则表达式
- Pattern p=Pattern.compile(regex);
- //读取文件中数据
- while ((line=br.readLine())!=null)
- {
- //关流字符串
- Matcher m=p.matcher(line);
- while (m.find())//寻找匹配的字符串
- {
- System.out.println(m.group());//输出匹配的字符串
- }
- }
- }
- }