regex和集合(collection)

最新推荐文章于 2022-07-12 00:14:02 发布

qx812560784

最新推荐文章于 2022-07-12 00:14:02 发布

阅读量262

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/qx812560784/article/details/78495500

一.regex

需求:校验一个QQ号码
   定义一个规则:1)由5到10为组成的数字
   2)不能以0开头
   分析:
   1)键盘录入一个QQ号码,使用字符串接收
   2)定义一个校验QQ的功能
   3)在main()中调用返回boolean类型

①

package regex;

import java.util.Scanner;

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 ;
	}
}

②

package regex;

import java.util.Scanner;

public class RegexDemo2 {
	
	public static void main(String[] args) {
		
		//创建键盘了录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入QQ号码: ");
		String QQ = sc.nextLine() ;
		boolean flag = checkQQ(QQ) ;
		System.out.println("flag: "+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}");
	}
}

使用正则表达式校验手机号码:
   规则:
   手机号码:
   13689257284
   13688886666
   13892866555
   18992844422
   13257222222
   ...

1)创建键盘录入对象,录入手机号码
2)定义正则规则:
3)String类的特有功能
public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
4)输出

package regex;

import java.util.Scanner;

public class RegexDemo3 {
	
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收
		System.out.println("请您输入一个手机号码:");
		String phone = sc.nextLine() ;
		
		//定义正则规则
		String regex = "1[38][0-9]{9}" ;
		
		//匹配当前正则表达式是否和录入的手机号符合
		boolean flag = phone.matches(regex) ;
		System.out.println("flag:"+flag);
	}
}

需求:校验邮箱:
   QQ邮箱:
   812560784@qq.com
   qixuan@163.com
   xxxxx@126.com
   zhangsan@westos.com
   lisi@sina.com
   wangwu@istone.com.cn....
分析:1)键盘录入邮箱
   2)定义正则规则
   3)使用String中的特有功能校验
   4)输出即可

package regex;

import java.util.Scanner;

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);
	}
}

String的分割功能:

public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串
返回值类型是一个字符串数组类型

应用场景:
   QQ,搜索好友,相亲网:世纪佳缘...
   女 "18-22"
   String ages = "18-22" ;

 package regex;

import java.util.Scanner;

public class RegexDemo11 {
	
	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("不符合要求");
		}
	}

String类中的替换功能:和正则表达式有关系
public String replaceAll(String regex,String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

package regex;

public class RegexDemo12 {
	
	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);
	}
}

关于模式和匹配器的使用:获取功能
模式和匹配器基本使用顺序

package regex;

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

public class RegexDemo13 {
	
	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);
	}
}

二.集合(Collection)

集合的由来:
我们学习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()

package collection;

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

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);
		
	}
}

集合的高级功能:
   boolean addAll(Collection c):添加一个集合中的所有元素
   boolean removeAll(Collection c):删除一个集合中的所有元素 ; 删除一个算是删除
   boolean containsAll(Collection c):判断一个集合中是否另一个集合;包含所有算是包含

boolean retainAll(Collection c): A集合对B集合取交集,那么交集的元素去A集合里面了,并且返回值boolean表达的意识是A集合中的元素是否发生变化,如果发生变化,就返回true;否则,false

package collection;

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

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);
	}
}

需求:有5个学生,每一个学生有自己的信息(姓名,年龄等等),将5个学生的信息遍历出来!
使用集合的转换功能去遍历学生信息

1)创建集合对象
2)创建5个学生对象
3)使用集合添加5个学生对象
4)将集合转换成数组:Object[] toArray() ;
5)遍历数组

package collection1;

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

public class CollectionTest {
	
	public static void main(String[] args) {
		
		//创建集合对象
		Collection c = new ArrayList() ;
		
		//创建5个学生对象
		Student s1 = new Student("杨晓洲", 19) ;
		Student s2 = new Student("邓聪", 20) ;
		Student s3 = new Student("杨启龙", 21) ;
		Student s4 = new Student("郭子正", 22) ;
		Student s5 = new Student("吴文龙", 20) ;
		
		//给集合中添加元素
		c.add(s1) ;//Object obj = new Student("..") ;
		c.add(s2) ;
		c.add(s3) ;
		c.add(s4) ;
		c.add(s5) ;
		
		//将集合转换成数组
		Object[] objs = c.toArray() ;
		for(int x = 0 ; x < objs.length ; x ++){
//			System.out.println(objs[x]);
			
			//使用get()获取学生姓名和年龄
			//Student类型接收
			Student s = (Student) objs[x] ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}

package collection1;

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;
	}
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	
}

集合的专有遍历方式:使用集合自己本身迭代功能遍历集合中的元素
   Iterator iterator():迭代器
   Iterator:迭代器:接口
   成员方法:Object next()返回迭代的下一个元素:获取功能
   boolean hasNext():判断一个集合中是否有下一个可以迭代的元素:判断功能

需求:使用集合存储字符串类型的元素并遍历

package collection2;


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());
//		System.out.println(it.next());
//		System.out.println(it.next());
//		//java.util.NoSuchElementException:没有这样的元素异常!
//		System.out.println(it.next());
		
		//由于当前集合中的元素获取完了,没有元素,而还要去调用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循环

package collection2;

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

import collection1.Student;

public class CollectionDemo2 {
	
	public static void main(String[] args) {
		//创建一个学生类
		//创建集合对象
		Collection c = new ArrayList() ;
		
		//创建3个学生对象
		Student s1 = new Student("杨晓洲", 20) ;
		Student s2 = new Student("郭子正", 22) ;
		Student s3 = new Student("邓聪", 21
				) ;
		
		//给集合中添加元素
		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());
			
		}
	}
}