1 正则表达式常用的语法:
A:字符
x 字符 x :任意的字符
\\ 反斜线字符 在代码中书写正则表达式:\------>用两个\\代表一个反斜线
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A') IO流中要写入换行符号:windows "\r\n"
\r 回车符 ('\u000D')
B:字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） :当前字母大小均可
C:预定义字符类
. 任何字符 邮箱里面:如果本身就是.,那么在写正在表达式的时候,\.将当前.转义
\d 数字：[0-9] \d在正则表达式应用的时候:[0-9]--->\\d
\w 单词字符：[a-zA-Z_0-9]:简单一些字符串,单词字符(规则:数字或者字母)
javascript:[a-zA-Z0-9]
D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界 :
E:Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
2
import java.util.Scanner;
需求:校验一个QQ号码
定义一个规则:1)由5到10为组成的数字
2)不能以0开头
1)键盘录入一个QQ号码,使用字符串接收
2)定义一个校验QQ的功能
3)在main()中调用返回boolean类型
public class RegexDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入并接收数据
System.out.println("请您输入一个QQ号码:");
String QQ = sc.nextLine() ;
//写一个校验QQ的功能
boolean flag = checkQQ(QQ) ;
System.out.println("flag:"+flag);
}
两个明确:
明确返回值类型:boolean类型
参数类型:String 输入的qq号码
public static boolean checkQQ(String qq){
//假设定义个标记
boolean flag = true ;
//需要判断:qq:长度5-10
if(qq.length()>=5 && qq.length()<=10){
//符合这个规则
//符合第一个规则还要符合不能以0开头
if(!qq.startsWith("0")){
//符合这个规则
//这些QQ号码必须还数字的
//可以先将qq,转换成字符数字
char[] chs = qq.toCharArray() ;
//遍历字符数组,获取每一个字符
for(int x = 0 ; x < chs.length ; x ++){
char ch = chs[x] ;
//获取到每一个字符,判断该字符是否是数字
if(!Character.isDigit(ch)){
flag = false ;
break ;
}
}
}else{
flag = false ;
}
}else{
flag = false ;
}
return flag ;
}
}
public static boolean checkQQ(String qq){
//定义正则规则
String regex = "[1-9][0-9]{4,9}" ;
//public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
boolean flag = qq.matches(regex) ;
return flag ;
//直接返回
return qq.matches("[1-9]\\d{4,9}");
}
3 String类的特有功能
public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
练习:检验邮箱:
分析: 1)键盘录入邮箱
2)定义正则规则
3)使用String中的特有功能校验
4)输出即可
public class RegexTest {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入并接收
System.out.println("请您输入一个邮箱:");
String email = sc.nextLine() ;
//定义正则规则:本身就是.-->\.--->\\.
String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z]{2,3})+" ;
String regex = "\\w+@\\w{2,6}(\\.[a-zA-Z]{2,3})+" ;
//校验
boolean flag = email.matches(regex) ;
System.out.println("flag:"+flag);
}
}
4 String的分割功能:
public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串
返回值类型是一个字符串数组类型
public class RegexDemo {
public static void main(String[] args) {
//定义一个字符串
String ages = "18-24" ;
//定义正则规则
String regex = "-" ;
//public String[] split(String regex)
String[] strArray = ages.split(regex) ;
//如何得到当前字符数组中的元素(转换int类型的数据)
int startAge = Integer.parseInt(strArray[0]) ;
int endAge = Integer.parseInt(strArray[1]) ;
//键盘录入一个年龄,属于int类型的数据
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入并接收数据
System.out.println("请您输入一个年龄:");
int age = sc.nextInt() ;
//判断是否符我们要找的一类人
if(age>=startAge && age<=endAge){
System.out.println("这就是我想要的...");
}else{
System.out.println("不是我们要找的...");
}
}
}
5 String类中的替换功能:和正则表达式有关系
public String replaceAll(String regex,String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
public class RegexDemo3 {
public static void main(String[] args) {
//定义一个字符串:
String str = "helloword123JavaSE45678Javaweb" ;
//需求:让当前这个字符串中的数字不显示出来
//定义当前大串中数字定义正则规则
// String regex = "[0-9]+" ;
String regex = "\\d+" ;
String s = "*" ;
//public String replaceAll(String regex,String replacement)
String result = str.replaceAll(regex, s) ;
System.out.println("result:"+result);
}
}
6 关于模式和匹配器的使用:获取功能
模式和匹配器基本使用顺序
public class RegexDemo4 {
public static void main(String[] args) {
//public static Pattern compile(String regex)将给定的正则表达式编译成一个模式对象
//1)获取模式对象(通过正则规则)
Pattern p = Pattern.compile("a*b") ;
//2)通过模式获取匹配器对象,(将一个字符串类型的数据)
Matcher m = p.matcher("aaaaaab") ;
//3)调用Match(匹配器类)中的:public boolean matches():判断当前用户录入的字符串是否和当前的正则规则匹配
boolean flag = m.matches() ;
System.out.println("flag:"+flag);
System.out.println("----------------------------");
//上述写法非常麻烦,要获取模式对象Pattern还要获取匹配器对象:Matcher,然后通过matches()方法返回一个结果
//以后可以使用下面这种格式
//定义一个正则规则
String regex = "a*b" ;
//指定某一个字符串
String str = "aaaaaaab" ;
//使用String类的功能
//使用当前给定的字符串调用public boolean matchers(String regex)
boolean flag2 = str.matches(regex) ;
System.out.println("flag2: "+flag2);
}
课堂练习:
有如下一个字符串:"91 27 46 38 50"
请写代码实现最终输出结果是："27 38 46 50 91"
1)定义这个字符串
2)使用分割功能分割成一个字符串数组
3)如何得到一个int类型数组:动态初始化定义int数组 int[] arr = new int[字符串数数组.length] ;
4)遍历int数组
获取每一个元素:arr[x] = Integer.parseInt(字符串数组对象[x])
5)排序:Arrays数组工具类型快速排序:sort(arr)
6)再去遍历int类型数组获取每一个元素,用字符串缓冲区来进行拼接
7)输出字符串
public class RegexTest {
public static void main(String[] args) {
//定义一个字符串
String str = "91 27 46 38 50" ;
//使用分割功能
String[] strArray = str.split(" ") ;
//定义一个int类型的数组,动态初始化
int[] arr = new int[strArray.length] ;
//遍历int类型的数组
for(int x = 0 ; x < arr.length ; x ++){
arr[x] = Integer.parseInt(strArray[x]) ;
}
//使用Arrays数组工具类型进行操作
Arrays.sort(arr) ;
//创建StringBuilder缓冲区对象
StringBuilder sb = new StringBuilder() ;
//再去遍历int类型的数组,目的使用为了拼接
for(int x = 0 ; x < arr.length ; x ++){
//使用追加功能
sb.append(arr[x]).append(" ") ;
}
//要将字符串缓冲转换成String类型,并且去除两端空格
String result = sb.toString().trim() ;
System.out.println("result:"+result);
}
}
二 集合
1 集合的由来:
我们学习java的语言,是一种面向对象语言,面向对象语言对事物的描述是通过对象体现出来的,那么存储很多个学生,就需要使用容器变量进行存储
目前:学习过哪些容器变量呢?
数组,StringBuffer/StringBuilder,对于数组来说,数组的长度是固定的,不符合实际需求(长度不可变);对于StringBuffer来说始终在内存中返回的是字符串类型,也不满足元素类型变化的要求;所以,Java就提供了一个技术:集合
面试题:
集合和数组的区别?
1)长度的区别:
数组:长度是固定的;
集合:长度是可变的
2)存储数据类型的区别:
数组:可以存储引用类型,可以存储基本数据类型
集合:只能存储引用类型
3)存储元素的区别
数组:在同一个数组中,只能存储同一种数据类型的元素;举例 数组:杯子:只能装水
集合:可以 存储多种数据类型的元素; 举例:集合:杯子:装水,其他饮料...
集合是可以存储多种类型的元素,但是,需求如果变化,针对集合来说,Java提供了很多集合类,每一种集合类的数据结构不一样,所以,将他们之间的共性内容抽取出来,就行了
数据结构:存储数据的方式
Collection: 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现
Collection的一些功能
添加功能:
boolean add(Object e):给集合中添加指定的元素
boolean addAll(Collection c):添加一个集合中的所有元素
删除功能:
void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)
boolean remove(Object o):删除一个集合中的指定元素
boolean removeAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?
判断功能:
boolean contains(Object o):判断一个集合中是否包含指定的单个元素
boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有.
boolean isEmpty():判断集合是否为空,如果为空,则返回true
交集功能:
boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
获取功能;
int size():获取集合中的元素数
Iterator<E> iterator():迭代器
转换功能:
Object[] toArray():将集合转换成数组
面试题:
数组中有没有length(),String类中有没有length(),集合中有没有length()?
数组:length属性
String:length()
集合中:size()
public class CollectionDemo {
public static void main(String[] args) {
//创建一个Collection集合对象
// Collection c = new Collection() ;//JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现
Collection c = new ArrayList() ;
// System.out.println(c);//[] 底层重写了toString()
//添加功能:
//boolean add(Object e):给集合中添加指定的元素
// boolean flag = c.add("hello") ;
/**
通过查看集合的add()方法,只要给集合中添加元素,永远返回true
public boolean add(E e) {
//省略代码
return true;
}
*/
c.add("hello") ;
c.add("world") ;
c.add("Java") ;
//void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)
// c.clear() ;
//boolean remove(Object o):删除一个集合中的指定元素
// System.out.println("remove:"+c.remove("hello")) ;
// System.out.println("remove:"+c.remove("javaweb")) ;
//boolean contains(Object o):判断一个集合中是否包含指定的单个元素
System.out.println("contains:"+c.contains("world"));
// System.out.println("contains:"+c.contains("android"));
// boolean isEmpty():判断集合是否为空,如果为空,则返回true
// System.out.println("isEmpty:"+c.isEmpty());
//int size():获取集合中的元素数
System.out.println("size:"+c.size());
System.out.println("c:"+c);
}
}
2
集合的高级功能:
boolean addAll(Collection c):添加一个集合中的所有元素
boolean removeAll(Collection c):删除一个算是删除
boolean containsAll(Collection c):一个集合中是否另一个集合 包含所有
boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
public class CollectionDemo2 {
public static void main(String[] args) {
//创建两个Collection集合对象
Collection c1 = new ArrayList() ;
Collection c2 = new ArrayList() ;
//分别给c1,c2集合添加元素
c1.add("abc1") ;
c1.add("abc2") ;
c1.add("abc3") ;
c1.add("abc4") ;
/*c2.add("abc1") ;
c2.add("abc2") ;
c2.add("abc3") ;*/
c2.add("abc4") ;
// c2.add("abc5") ;
// c2.add("abc6") ;
// c2.add("abc7") ;
//boolean addAll(Collection c):添加一个集合中的所有元素
// System.out.println("addAll:"+c1.addAll(c2));
//boolean removeAll(Collection c)
//删除一个算是删除
// System.out.println("removeAll:"+c1.removeAll(c2));
// boolean containsAll(Collection c):
// System.out.println("containsAll:"+c1.containsAll(c2));//包含所有算是包含
//boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
A集合对B集合取交集,那么交集的元素去A集合里面了,并且返回值boolean表达的意识是A集合中的元素是否发生变化,如果发生变化,就返回true;否则,false
System.out.println("retianAll:"+c1.retainAll(c2));
//输出每个集合中的元素
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
}
}
3
Object[] toArray():将集合转换成数组
需求:给集合中添加String类型的元素,遍历集合
public class CollectionDemo3 {
public static void main(String[] args) {
//创建Collection集合对象
Collection c = new ArrayList() ;
//给集合中添加元素
c.add("LPL") ;//c.add(Object obj)=====>Object obj = new String("LPL") ;//向上转型了
c.add("LOL") ;
c.add("LCK") ;
c.add("LCS") ;
//集合中有元素了,将集合转换数组
Object[] objs = c.toArray() ;
//遍历对象数组
for(int x = 0 ; x < objs.length ; x ++){
// System.out.println(objs[x]);
//需求:获取集合中元素的同时,获取集合中每一个元素的字符串长度
// System.out.println(objs[x]+"---"+objs[x].length());
//要获取字符串长度:需要使用length(),该方法属于String类的特有功能
String s = (String) objs[x] ;//向下转型
System.out.println(s+"----"+s.length());
}
}
}
4
集合的专有遍历方式:使用集合自己本身迭代功能遍历集合中的元素
Iterator iterator():迭代器
Iterator:迭代器:接口
成员方法:Object next()返回迭代的下一个元素:获取功能
boolean hasNext():判断一个集合中是否有下一个可以迭代的元素:判断功能
需求:使用集合存储字符串类型的元素并遍历
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList() ;//ArrayList是List集合的子实现类(存储和取出一致的)
//给集合中添加元素
c.add("hello") ;
c.add("world") ;
c.add("java") ;
c.add("java") ;
c.add("java") ;
c.add("java") ;
//获取迭代器对象
//Iterator iterator():迭代器
Iterator it = c.iterator() ;//底层使用ArrayList中的匿名内部类的形式:接口多态的形式
//获取元素:Object next() ;
/*Object obj = it.next() ;
System.out.println(obj);*/
// System.out.println(it.next());
// //java.util.NoSuchElementException:没有这样的元素异常!
//由于当前集合中的元素获取完了,没有元素,而还要去调用next()方法,那么就出现问题,
//假设,给当前加上一个判断就可以防止出现异常!
//判断
/* if(it.hasNext()){
//有,就获取需要被遍历的元素
System.out.println(it.next());
}
if(it.hasNext()){
//有,获取
System.out.println(it.next());
}
if(it.hasNext()){
System.out.println(it.next());
}
if(it.hasNext()){
System.out.println(it.next());
}*/
//上述代码重复度高,由于集合中的元素不固定的,所有使用while循环去改进
while(it.hasNext()){
// System.out.println(it.next());//获取字符串的内容
//获取字符串的同时,还要获取字符串长度
//Object obj = it.next() ;
//向下转型
String s = (String)it.next() ;
System.out.println(s+"----"+s.length());
}
}
}
练习:
使用存储自定义对象并遍历
1)toArray():将集合转换成数组
2)集合专有遍历方式:迭代器遍历
注意:存储自定义对象使用迭代器遍历,it.next()不要使用多次,否则会出现异常
使用迭代器遍历,使用的是while循环,可以是for循环吗?可以,但是还是while循环
public class CollectionTest {
public static void main(String[] args) {
//创建一个学生类
//创建集合对象
Collection c = new ArrayList() ;
//创建3个学生对象
Student s1 = new Student("张三", 26) ;
Student s2 = new Student("李四", 22) ;
Student s3 = new Student("往往与", 28) ;
//给集合中添加元素
c.add(s1) ;
c.add(s2) ;
c.add(s3) ;
//获取迭代器对象
Iterator it = c.iterator() ;
//遍历
while(it.hasNext()){
Student s = (Student)it.next() ;
System.out.println(s.getName()+"---"+s.getAge());
//java.util.NoSuchElementException
// System.out.println(((Student)it.next()).getName()+"----"+((Student)it.next()).getAge());
}
System.out.println("----------------------------");
for(Iterator it2 = c.iterator();it2.hasNext();){
Student s = (Student) it2.next() ;
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
//创建一个Student类
public class Student {
//两个成员变量
private String name ;
private int age ;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
5 List集合
用List集合存储字符串类型的元素,并遍历:迭代器遍历
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//获取迭代器
Iterator it = list.iterator() ;
while(it.hasNext()){
String s = (String)it.next() ;
System.out.println(s);
}
}
}
List集合是一个有序的集合(存储元素和取出元素是一致的!)
该集合中的元素是可以重复的
List集合的特有功能:
添加功能:
void add(int index, Object element)在列表的指定位置插入指定元素
删除功能:
Object remove(int index)移除列表中指定位置的元素,返回被删除的元素
获取功能:
ListIterator listIterator():列表迭代器:List集合的专有遍历方式
Object get(int index)返回列表中指定位置的元素。
替换
set(int index,Object element)用指定元素替换列表中指定位置的元素
public class ListDemo {
public static void main(String[] args) {
//创建List集合对象
List list = new ArrayList() ;
//添加一些元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//void add(int index, Object element)在列表的指定位置插入指定元素,在指定位置前面插入一个新的元素
// list.add(1, "javaweb") ;
//Object remove(int index)移除列表中指定位置的元素,返回被删除的元素
//IndexOutOfBoundsException:角标越界了
// System.out.println("remove:"+list.remove(3));
// System.out.println("remove:"+list.remove(2));
// set(int index,Object element)用指定元素替换列表中指定位置的元素
// System.out.println("set:"+list.set(1, "JavaEE")) ;
System.out.println("get:"+list.get(1)) ;
// System.out.println("get:"+list.get(11)) ;
System.out.println("list"+list);
}
}
List集合的遍历方式
1)toArray()
2)Collection集合中的Iterator iterator();
public class ListDemo2 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//添加元素
list.add("hello") ;
list.add("java") ;
list.add("hello") ;
list.add("javaweb") ;
list.add("hello") ;
list.add("python") ;
//获取集合中的元素
/* System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));
System.out.println(list.get(3));
System.out.println(list.get(4));
System.out.println(list.get(5));*/
//使用普通for的方法去遍历list集合,使用size()和get()相结合
for(int x = 0 ; x < list.size(); x ++){
// Object object = list.get(x) ;
//需求:获取字符串内容同时,获取字符串长度
String s = (String)list.get(x) ;
System.out.println(s+"----"+s.length());
}
System.out.println("-------------------------");
//获取迭代器对象
Iterator it = list.iterator() ;
while(it.hasNext()){
String s = (String) it.next() ;
System.out.println(s+"----"+s.length());
}
}
}
List集合的列表迭代器
ListIterator listIterator()
列表迭代器接口中有以下几个方法:
boolean hasNext():判断是否有下一个可以迭代的元素(正向遍历)
Object next():如果有可以遍历的元素,就获取这个元素
boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)
Object previous():如果有上一个可以迭代的元素,就获取上一个元素
注意:要使用逆向遍历,前提必须有正向遍历存在,直接使用逆向遍历,没有意义!
public class ListDemo3 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//给集合中添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//获取列表迭代器
ListIterator it = list.listIterator() ;
while(it.hasNext()){
String s = (String)it.next();
System.out.println(s);
}
System.out.println("-----------------------");
//boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)
//Object previous():如果有上一个可以迭代的元素,就获取上一个元素
while(it.hasPrevious()){
String s = (String)it.previous() ;
System.out.println(s);
}
}
}
2062
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
