Java正则表达式&集合

女爷i 2022-06-06 10:09 189阅读 0赞

## 一.正则表达式 ##

正则表达式常用的语法:
    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 			单词边界 :
    				hello;world:haha:xixi
    E:Greedy 数量词
    	X? 			X，一次或一次也没有 
    	X*			X，零次或多次
    	X+ 			X，一次或多次 
    	X{n}	                X，恰好 n 次 
    	X{n,}		        X，至少 n 次
    	X{n,m}	 		X，至少 n 次，但是不超过 m 次 	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 			单词边界 :
    				hello;world:haha:xixi
    E:Greedy 数量词
    	X? 			X，一次或一次也没有 
    	X*			X，零次或多次
    	X+ 			X，一次或多次 
    	X{n}	                X，恰好 n 次 
    	X{n,}		        X，至少 n 次
    	X{n,m}	 		X，至少 n 次，但是不超过 m 次

正则表达式的校验功能：（校验QQ号码）

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

分割功能：

package org.westos_13_正则表达式;
    
    import java.util.Scanner;
    
    /**
     *  public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串
     * 		返回值类型是一个字符串数组类型
     * */
    public class RegexDemo1 {
    	public static void main(String[] args) {
    		String ages = "18-24" ;
    		//定义正则规则
    		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("对不起，你们不合适....");
    		}
    	}
    }

public class RegexDemo2 {
    	
    	public static void main(String[] args) {
    		
    		//定义个字符串
    		String str1 = "aa,bb,cc" ;
    		//使用分割功能
    		String[] strArray1 = str1.split(",") ;
    		//遍历字符串数组
    		for(int x = 0 ; x < strArray1.length; x ++){
    			System.out.println(strArray1[x]);
    		}
    		
    		System.out.println("------------------");
    		
    		//字符串:
    		String str2 = "aa       bb                    cc" ;
    		//使用切割功能:
    		String[] strArray2 = str2.split(" +") ;
    		for(int x = 0 ; x <strArray2.length ; x++){
    			System.out.println(strArray2[x]);
    		}
    		
    		System.out.println("--------------------");
    		
    		String str3 = "aa.bb.cc" ;
    		//分割功能
    		String[] strArray3 = str3.split("\\.") ;
    		for(int x =0 ; x<strArray3.length ; x ++){
    			System.out.println(strArray3[x]);
    		}
    		
    		//硬盘上的路径表现形式:用两个反斜线代表一个反斜线
    		//E:\\JavaSE\\JavaCode\\day13
    		String str4 = "E:\\JavaSE\\JavaCode\\day13" ;
    		//使用分割功能
    		String[] strArray4 = str4.split("\\\\") ;
    		for(int x = 0 ; x <strArray4.length ; x ++){
    			System.out.println(strArray4[x]);
    		}
    	}
    }

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

import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    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);
    	}
    }

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

练习：

/**
     * 我有如下一个字符串:"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)输出字符串
     * @author Apple
     */
    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);
    	}
    }

## **二. 集合**  ##

集合的由来:

java语言是一种面向对象语言,面向对象语言对事物的描述是通过对象体现出来的,那么存储很多个对象,就需要使用容器变量进行存储  
  目前:学习过哪些容器变量呢?  
   数组, StringBuffer/StringBuilder,对于数组来说,数组的长度是固定的,不符合实际需求(长度不可变);对于StringBuffer来说始终在内存中返回

的是字符串类型,也不满足元素类型变化的要求;所以,Java就提供了一个技术:集合!

**集合的框架：**

集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。

接口：即表示集合的抽象数据类型。接口提供了让我们对集合中所表示的内容进行单独操作的可能。  
           实现：也就是集合框架中接口的具体实现。实际它们就是那些可复用的数据结构。  
           算法：在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法，例如查找、排序等。这些算法通常是多态的，因为相同的方法可以在同一个接口被多个类实现时有不同的表现。

集合继承框架（图片来自百度）

![Center][]

**面试题:**  
   集合和数组的区别?  
   1)长度的区别:  
  数组:长度是固定的;  
   集合:长度是可变的  
  2)存储数据类型的区别:  
  数组:可以存储引用类型,可以存储基本数据类型  
   集合:只能存储引用类型  
   3)存储元素的区别  
   数组:在同一个数组中,只能存储同一种数据类型的元素;  
  集合:可以 存储多种数据类型的元素;

**Collection**: 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。  
 一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现

所有通用的 Collection 实现类（通常通过它的一个子接口间接实现 Collection）应该提供两个“标准”构造方法：一个是 void（无参数）构造方法，用于创建空 collection；另一个是带有Collection 类型单参数的构造方法，用于创建一个具有与其参数相同元素新的 collection。

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()方法可以获取集合长度

创建Collcetion集合对象：

Collection c = new Collection() ;（错误的）JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现

Collection c = new ArrayList() ;

**功能：**

import java.util.ArrayList;
    import java.util.Collection;
    
    public class CollectionDemo {
    	public static void main(String[] args) {
    		//创建对象
    		Collection c = new ArrayList();
    		System.out.println(c); //[]  底层重写了toString();
    		
    		//boolean add(Object e):给集合中添加指定的元素
    
    		c.add("hello") ;
    		c.add("world") ;
    		c.add("Java") ;
    		c.add("宫本");
    		System.out.println(c);  //[hello, world, Java, 宫本]
    
    		//c.clear() ;//暴力删除（不建议使用）
    		//boolean remove(Object o):删除一个集合中的指定元素
    		System.out.println("remove:"+c.remove("宫本")) ;//remove:true
    		System.out.println(c);//[hello, world, Java]
    		
    		System.out.println("remove:"+c.remove("love"));//remove:false没有删除的元素返回false
    		
    		//boolean contains(Object o):判断一个集合中是否包含指定的单个元素
    		System.out.println("contains:"+c.contains("宫本"));//contains:false  前面削了宫本，没了
    		System.out.println("contains:"+c.contains("Java"));//contains:true
    		
    		//boolean isEmpty():判断集合是否为空,如果为空,则返回true
    		System.out.println("isEmpty:"+c.isEmpty());
    		
    		//int size():获取集合中的元素数
    		System.out.println("集合中的元素数："+c.size());//集合中的元素数：3
    
    
    	}
    }

**高级功能：**

package org.westos_13_集合;
    /**
     *集合的高级功能:
     * 	boolean addAll(Collection c):添加一个集合中的所有元素
     * 	boolean removeAll(Collection c):删除一个集合中的所有元素   思考:删除所有算是删除还是删除一个算是删除? 删除一个算是删除
     * 	boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有
     *  boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
     * 
     * */
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class CollectionDemo1 {
    	public static void main(String[] args) {
    		
    		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));//addAll：true
    		System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3, abc4, abc5, abc6, abc7]
    		System.out.println("c2:"+c2);//c2:[abc5, abc6, abc7]
    		
    		//boolean removeAll(Collection c):删除一个集合中的所有元素  
    		//System.out.println("removeAll："+c1.removeAll(c2));//removeAll：true
    		
    		//boolean containsAll(Collection c):判断一个集合中是否另一个集合
    		
    		System.out.println("containsAll:"+c1.containsAll(c2));//包含所有算是包含
    		
    		//boolean retainAll(Collection c):A集合给B集合做交集
    		System.out.println("retianAll:"+c1.retainAll(c2));//retianAll:true
    		System.out.println("c1:"+c1);
    		System.out.println("c2:"+c2);
    	}
    }

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

import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     * Object[] toArray():将集合转换成数组
     * 需求:给集合中添加String类型的元素,遍历集合
     * */
    public class CollectionDemo2 {
    	public static void main(String[] args) {
    		
    		Collection c = new ArrayList();
    		c.add("要是能重来") ;
    		c.add("我要选李白") ;
    		c.add("宫本武藏") ;
    		c.add("小短腿") ;
    		
    		//将集合转换成数组
    		Object[] obj = c.toArray();
    		//遍历
    		for(int x =0;x<obj.length;x++) {
    			System.out.println(obj[x]);
    			/*需求:获取集合中元素的同时,获取集合中每一个元素的字符串长度
    			要获取长度，就需要使用length(),该方法属于String类的特有功能*/
    			String s = (String) obj[x];//向下转型
    			System.out.println(s+"----"+s.length());
    		}
    		
    	}
    }

集合的专有遍历方式:使用集合自己本身迭代功能遍历集合中的元素

Iterator iterator():迭代器

迭代器是接口不能是类的原因：每一个集合都有自己的特点，而且各自都有自己的遍历方式  
                   而这么多集合类的方法需要被声明出来，所以将Iterator定义为一个接口  
  成员方法:Object next()返回迭代的下一个元素:获取功能（通过内部类获取）  
    boolean hasNext():判断一个集合中是否有下一个可以迭代的元素:判断功能

package org.westos_13_集合迭代器;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    
    public class IteratorDemo1 {
    	public static void main(String[] args) {
    		//创建集合对象
    		Collection c = new ArrayList();
    		
    		//添加元素
    		c.add("hello");
    		c.add("world");
    		c.add("javase");
    		
    		//迭代器
    		Iterator it = c.iterator();//底层使用ArrayList中的匿名内部类的形式:接口多态的形式
    		/*Object next = it.next();//返回的是Object类
    		System.out.println(next);*/
    		/*当集合中的元素获取完了,再去调用next()方法,那么就出现java.util.NoSuchElementException:没有这样的元素异常!
    		加上一个判断就可以防止出现异常!*/
    		
    		//boolean hasNext():判断一个集合中是否有下一个可以迭代的元素:判断功能
    		//因为不知道当前集合的元素个数，所以用while循环
    		while(it.hasNext()) {
    			//System.out.println(it.next());
    			
    			String s = (String)it.next();
    			System.out.println(s+"---"+s.length());
    		}
    		
    	}
    }

练习：

package org.westos_13_集合练习;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     *  需求:有5个学生,每一个学生有自己的信息(姓名,年龄等等),将5个学生的信息遍历出来!
     *  使用集合的转换功能去遍历学生信息
     *  
     *  1)创建集合对象
     *  2)创建5个学生对象
     *  3)使用集合添加5个学生对象
     *  4)将集合转换成数组:Object[] toArray() ;
     *  5)遍历数组
     * 
     * */
    public class CollectionTset {
    	public static void main(String[] args) {
    		// 创建集合对象
    		Collection c = new ArrayList();
    		//创建5个学生对象
    		Student s1 = new Student("虞姬", 185) ;
    		Student s2 = new Student("鲁班七号", 152) ;
    		Student s3 = new Student("李白", 180) ;
    		Student s4 = new Student("宫本", 178) ;
    		Student s5 = new Student("太乙", 150) ;
    		//给集合中添加元素
    		c.add(s1) ;
    		c.add(s2) ;
    		c.add(s3) ;
    		c.add(s4) ;
    		c.add(s5) ;
    		//将集合转换成数组
    		Object[] objs = c.toArray();
    		//遍历
    		for(int x=0;x<objs.length;x++) {
    			
    			Student s = (Student) objs[x];
    			System.out.println(s.getName()+"---"+s.getHeight());
    		}
    		
    	}
    }

## **List集合：** ##

package org.westos_13_List;
    
    import java.util.Iterator;
    import java.util.List;
    import java.util.ArrayList;
    
    /**
     * 用List集合存储字符串类型的元素,并遍历:迭代器遍历
     *
     **/
    
    public class ListDemo1 {
    	public static void main(String[] args) {
    		
    		List list = new ArrayList();
    		//添加元素
    		list.add("hello");
    		list.add("world");
    		list.add("world");//可以重复
    		list.add("Java");
    		
    		Iterator it =list.iterator();
    		//遍历
    		while(it.hasNext()) {
    			String s = (String)it.next();
    			System.out.println(s);
    		}
    	}
    }

List集合的特有功能:  
  添加功能:  
  void add(int index, Object element)在列表的指定位置插入指定元素  
  删除功能:  
  Object remove(int index)移除列表中指定位置的元素,返回被删除的元素  
  获取功能:  
  ListIterator listIterator():列表迭代器:List集合的专有遍历方式  
  Object get(int index)返回列表中指定位置的元素。  
  替换  
  set(int index,Object element)用指定元素替换列表中指定位置的元素

package org.westos_13_List;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ListDemo2 {
    	public static void main(String[] args) {
    		
    		List list = new ArrayList();
    		//添加
    		list.add("hello") ;
    		list.add("world") ;
    		list.add("java") ;
    		
    		//void add(int index, Object element)在列表的指定位置插入指定元素,在指定位置前面插入一个新的元素
    		list.add(2, "javase") ;
    		System.out.println(list);
    		
    		//Object remove(int index)移除列表中指定位置的元素,返回被删除的元素
    		/*list.remove(2);
    		System.out.println(list);*/
    		
    		// set(int index,Object element)用指定元素替换列表中指定位置的元素
    		System.out.println("set："+list.set(1, "EDG"));//set：world,返回被替换的元素
    
    	}
    }

练习:

package org.westos_13_List;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.ListIterator;
    
    /**
     * 
     * 问题?
     * 		我有一个集合，如下，请问，我想判断里面有没有"world"这个元素，
     * 			如果有，我就添加一个"javaee"元素，请写代码实现
     * 	并发(同一个时间点),并行(同一个时间段)
     *  java.util.ConcurrentModificationException:并发修改异常:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
     *	原因:当前我们用迭代器去遍历元素,使用集合添加的元素,对于迭代器不知道集合添加了这个元素,所以会发生这个异常
     *	描述:使用迭代器去遍历集合,是不能直接集合添加元素!
     *	解决方案:
     *			1)使用迭代器遍历集合,使用迭代器添加元素
     *			2)使用集合遍历,使用集合添加元素
     * */
    public class ListTest {
    	private static Object s;
    
    	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();
    			if("world".equals(s)) {
    				list.add("Javaee");
    			}
    		}*/  //这种方法会导致并发异常
    		/*方案1:使用List集合中的专有遍历方式:列表迭代器有添加功能:add(Object obj)
    		将指定的元素插入到列表中(指定元素后面插入),使用迭代器添加元素*/
    		//Iterator it = list.iterator() ; 该迭代器中没有添加功能
    		/*ListIterator it = list.listIterator();
    		while (it.hasNext()) {
    			String s = (String) it.next();
    			if ("world".equals(s))
    				
    			{
    				it.add("Javaee");
    			}
    		}
    		System.out.println("list:"+list);*///list:[Hello, world, Javaee, Java]
    		// 方案2:使用集合遍历(普通for循环size()和get()相结合),使用集合添加元素
    		for (int x = 0; x < list.size(); x++) {
    			String s = (String) list.get(x);
    			if ("world".equals(s)) {
    				list.add("Javaee");
    			}
    		}
    		System.out.println("list:" + list);//list:[Hello, world, Java, Javaee]
    	}
    }

[Center]: /images/20220606/fa5c98b6df7f4f95b9483297d9323eef.png