正则表达式：
符号 含义 举例
[] 里面的内容出现一次 [0-9] [a-zA-Z0-9]
() 分组 a(bc)+
^ 取反 [^abc]
&& 交集，不能写单个的& [a-z&&m-p]
| 写在方括号外面表示并集 [a-zA-Z0-9] x|X
范例：
[abc] 只能是a, b, 或c
[^abd 除了a, b, c之外的任何字符
[a-zA-Z] a到zA到Z,包括(范围)
[a-d[m-p]] a到d,或m到p
[a-z&&[def]] a-z和def的交集。为:d,e,f
[a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])
[a-z&&[^m-p]] a到z和除了m到p的交集。(等同于[a-lq-z])
预定义字符(只匹配一个字符)
. 任何字符
\d 一个数字:[0-9]
\D 非数字:[^0-9]
\s 一个空白字符:[\t\n\x0B\f\r]
\S 非空白字符:[^\s]
\w [a-ZA-Z_0-9]英文、数字、下划线
\W [^\w]一个非单词字符
（Java中两个\表示一个\）
// 注意：\ 是转义字符，改变后面那个字符原本的含义
//练习:以字符串的形式打印一个双引号
// " 在Java中表示字符串的开头或者结尾
//此时\表示转义字符,改变了后面那个双引号/符号原本的含义
//把他变成了一个普普通通的双引号/符号而已。
符号 含义 举例
? 0次或1次 \\d?
* 0次或多次 \\d* (abc)*
+ 1次或多次 \\d+ (abc)+
{} 具体次数 a{7} \\d{7,19} 出现7到19次
(?i) 忽略后面字符的大小写 (?i)abc
a((?i)b)c 只忽略b的大小写 a((?i)b)c
爬虫：
Pattern ：表示正则表达式
Matcher ：文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取，在大串中去找符合匹配规则的字串
Pattern 和 Matcher 都在 regex 包下，需要导包 import java.util.regex.Matcher/Pattern
爬虫范例：
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexDemo6
{
public static void main(String[] args)
{
/*有如下文本,请按照要求爬取数据。
Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11,因为这两个是长期支持版本,下一个长期支持版 本是Java17,相信在未来不久Java17也会逐渐登上历史舞台
要求:找出里面所有的JavaXX*/
String str="Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11," + "因为这两个是长期支持版本,下一个长期支持版本是Java17,相信在未来不久Java17也会逐渐登上历史舞台" ;
//Pattern:表示正则表达式
//Matcher:文本匹配器,作用按照正则表达式的规则去读取字符串,从头开始读取。在大串中去找符合匹配规则的子串。
//获取正则表达式的对象，用静态方法compile
Pattern p = Pattern.compile("Java\\d{0,2}");
//获取文本匹配器的对象
//m:文本匹配器的对象
//str:大串
//p:规则
//m要在str中找符合p规则的小串
Matcher m = p.matcher(str);
//拿着文本匹配器从头开始读取,寻找是否有满足规则的子串
//如果没有,方法返回false
//如果有,返回true。在底层记录子串的起始索引和结束索引+1
//0,4
boolean b = m.find();
//方法底层会根据find方法记录的索引进行字符串的截取
//subString(起始索引,结束索引);包头不包尾
//(0,4),但是不包含4索引
//会把截取的小串进行返回。
String s1 = m.group();
System.out.println(s1);
//或者写成：
//1.获取正则表达式的对象
Pattern p = Pattern.compile("Java\\d{0,2}");
//2.获取文本匹配器的对象
//拿着m去读取str,找符合p规则的子串
Matcher m = p.matcher(str);
//3.利用循环获取
while(m. find ())
{
String s = m.group();
System.out.println(s);
}
}
}
//1.定义正则表达式
//?理解为前面的数据Java
//=表示在Java后面要跟随的数据
//但是在获取的时候,只获取前半部分
//需求1:
String regex1 = "((?i)Java)( ?= 8|11|17)";
//需求2:
String regex2 = "((?i)Java)(8|11|17)";
String regex3 = "((?i)Java)( ?: 8|11|17)";
//需求3:
String regex4 = "((?i)Java)( ?! 8|11|17)";
只写+和*表示贪婪匹配
+? 非贪婪匹配
*? 非贪婪匹配
贪婪爬取:在爬取数据的时候尽可能的多获取数据
非贪婪爬取:在爬取数据的时候尽可能的少获取数据
ab+:
贪婪爬取:abbbbbbbbbbbb
非贪婪爬取:ab
Java当中,默认的就是贪婪爬取
如果我们在数量词+*的后面加上问号,那么此时就是非贪婪爬去
集合体系结构：
单列集合：Collection
List系列集合:添加的元素是有序、可重复、有索引
Set系列集合:添加的元素是无序、不重复、无索引
Collection
Collection是单列集合的祖宗接口,它的功能是全部单列集合都可以继承使用的
方法名称 说明
public boolean add(E e) 把给定的对象添加到当前集命中
public void clear() 清空集合中所有的元素
public boolean remove(E e) 把给定的对象在当前集合中删除
public boolean contains(Object obj) 判断当前集合中是否包含给定的对象
public boolean isEmpty() 判断当前集合是否为空
public int size() 返回集合中元素的个数/集合的长度
范例：
注意点:
Collection是一个接口,我们不能直接创建他的对象。所以,现在我们学习他的方法时,只能创建他实现类的对象。
实现类:ArrayList
//目的:为了学习Collection接口里面的方法
//自己在做一些练习的时候,还是按照之前的方式去创建对象。
Collection<String> coll = new ArrayList<>();
//1.添加元素
//细节1:如果我们要往List系列集合中添加数据,那么方法永远返回true,因为List系列的是允许元素重复的。
//细节2:如果我们要往Set系列集合中添加数据,如果当前要添加元素不存在,方法返回true,表示添加成功。
//如果当前要添加的元素已经存在,方法返回false,表示添加失败。
因为Set系列的集合不允许重复。
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
System.out.println(coll); //[ aaa , bbb , ccc ]
//2.清空
coll.clear();
System.out.println(coll); // [ ]
//3.删除
//细节1:因为Collection里面定义的是共性的方法,所以此时不能通过索引进行删除。只能通过元素的对象进行删除。
coll.remove ( "aaa" ) ;
System.out.println(coll); // [ bbb , ccc ]
//细节2:方法会有一个布尔类型的返回值,删除成功返回true,删除失败返回false
//如果要删除的元素不存在,就会删除失败。
System.out.println(coll.remove( o: "aaa")); // true
//4.判断元素是否包含
//细节：底层是依赖equals方法进行判断是否存在的。
//所以，如果集合中储存的是自定义对象，也想通过contains方法来进行判断是否包含，那么在JavaBean中，一定要重写equals方法
//因为contains方法在底层依赖equals方法判断对象是否一致的。
//如果存的是自定义对象,没有重写equals方法,那么默认使用Object类中的equals方法进行判断,而Object类中equals方法,依赖地址值进行判
//需求:如果同姓名和同年龄,就认为是同一个学生。
//所以,需要在自定义的Javabean类中,重写equals方法就可以了。
boolean result = coll.contains("bbb");
System.out.println(result); //true
//注意：Java中已经重写好了关于字符串的equals方法
//5.判断集合是否为空
boolean result2 = coll.isEmpty();
System.out.println(result2);//false
//6.获取集合的长度
coll.add("ddd");
int size = coll.size();
System.out.println(size);//3
Collection的遍历方法
迭代器遍历（迭代器不依赖索引）：
迭代器在Java中的类是Iterator,迭代器是集合专用的遍历方式。
Collection集合获取迭代器
方法名称 说明
Iterator<E> iterator() 返回迭代器对象,默认指向当前集合的0索引
Iterator中的常用方法
方法名称 说明
boolean hasNext() 判断当前位置是否有元素,有元素返回true,没有元素返回false
E next () 获取当前位置的元素，并将迭代器对象移向下一个位置。
范例：
/*迭代器的细节注意点:
1.报错NoSuchElementException
2.迭代器遍历完毕,指针不会复位
3.循环中只能用一次next方法
4.迭代器遍历时,不能用集合的方法进行增加或者删除*/
[ 一眨眼，算不算少年；一辈子，算不算永远 ]
增强for遍历
●增强for的底层就是迭代器,为了简化迭代器的代码书写的。
● 它是JDK5之后出现的,其内部原理就是一个Iterator迭代器
● 所有的单列集合和数组才能用增强for进行遍历。
格式:
for(元素的数据类型 变量名:数组或者集合)
{
...
}
范例：
//1.创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
//2.利用增强for进行遍历
//注意点:
//s其实就是一个第三方变量,在循环的过程中依次表示集合中的每一个数据
for (String s : list)
{
System.out.println(s); //[ zhangsan lisi wangwu ]
}
注意：
//修改增强for中的变量，不会改变集合中原本的数据
for (String s : coll)
{
s = "qqq";
}
System.out.println(coll); // [ zhangsan lisi wangwu ]
Lambda表达式遍历
得益于JDK 8开始的新技术Lambda表达式,提供了一种更简单、更直接的遍历集合的方式。
方法名称 说明
default void forEach(Consumer <? super T> action): 结合lambda遍历集合
范例：
//1.创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
//2.利用匿名内部类的形式
//底层原理:
//其实也会自己遍历集合,依次得到每一个元素
//把得到的每一个元素,传递给下面的accept方法
//s依次表示集合中的每一个数据
coll.forEach(new Consumer<String>()
{
@Override
public void accept(String s)
{
System.out.println(s);
}
}) ;
//lambda表达式
coll.forEach(s -> System.out.println(s));
1. Collection是单列集合的顶层接口,所有方法被List和Set系列集合共享
2. 常见成员方法:
add, clear, remove, contains, isEmpty, size
3. 三种通用的遍历方式:
● 迭代器:在遍历的过程中需要删除元素,请使用迭代器。
● 增强for、Lambda:
仅仅想遍历,那么使用增强for或Lambda表达式。
List集合
List集合的特有方法
● Collection的方法List都继承了
● List集合因为有索引,所以多了很多索引操作的方法。
方法名称 说明
void add(int index, E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素,返回被删除的元素
E set(int index, E element) 修改指定索引处的元素,返回被修改的元素
E get(int,index) 返回指定索引处的元素
List集合遍历方式
List系列集合的五种遍历方式:
1.迭代器
2.列表迭代器
3.增强for
4.Lambda表达式
5.普通for循环
//创建集合并添加元素
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//1.迭代器
Iterator<String> it = list.iterator();
while(it.hasNext())
{
String str = it.next();
System.out.println(str);
}
//2.增强for
//下面的变量s,其实就是一个第三方的变量而已。
//在循环的过程中,依次表示集合中的每一个元素
增强for循环格式：
for（元素数据类型 变量名: 数组或者collection集合）
{
.......
}
for (String s : list)
{
System.out.println(s);
}
//3.Lambda表达式
//forEach方法的底层其实就是一个循环遍历,依次得到集合中的每一个元素
//并把每一个元素传递给下面的accept方法
//accept方法的形参s,依次表示集合中的每一个元素
list.forEach(s->System.out.println(s) );
//4.普通for循环
//size方法跟get方法还有循环结合的方式,利用索引获取到集合中的每一个元素
for (int i = 0; i < list.size(); i++)
{
//i:依次表示集合中的每一个索引
String s = list.get(i);
System.out.println(s);
}
// 5.列表迭代器
//获取一个列表迭代器的对象,里面的指针默认也是指向0索引的
//额外添加了一个方法:在遍历的过程中,可以添加元素
ListIterator<String> it = list.listIterator();
while(it.hasNext())
{
String str = it.next();
if("bbb".equals(str))
{
//qqq
it.add("qqq");
}
}
System.out.println(list);
五种遍历方式对比
迭代器遍历——在遍历的过程中需要删除元素,请使用迭代器。
列表迭代器——在遍历的过程中需要添加元素,请使用列表迭代器。
增强for遍历——仅仅想遍历,那么使用增强for或Lambda表达式。
Lambda表达式——仅仅想遍历,那么使用增强for或Lambda表达式。
普通for——如果遍历的时候想操作索引,可以用普通for。
1597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
