正则表达式-Collection-List

一.正则表达式

1.字符类型：

X	任意的字符
\\	反斜线字符，在代码中写正则表达式，"\"---->"\\"表示
\t	制表符（'\u0009'）
\n	新行（换行）符（‘\u00A’）
\r	回车符（'\u0001'）

2.字符类

[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围） :当前字母大小均可

3.预定义字符类

.	任何字符,邮箱里面:如果本身就是.,那么在写正在表达式的时候,\.将当前.转义
\d	数字：[0-9],\d在正则表达式应用的时候:[0-9]--->\\d
\w	单词字符：[a-zA-Z_0-9]:简单一些字符串,单词字符(规则:数字或者字母)

4.边界匹配器

^	行的开头
$	行的结尾
\b	单词边界 :

5.Greedy 数量词

X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，但是不超过 m 次

练习：需求:校验一个QQ号码，规则：1）由6到10为组成的数字  2）不能以0开头

手机号码：以177开头的十一位手机号

package day_13_11_7.regex;

import java.util.Scanner;

/**
 * 需求:校验一个QQ号码和手机号码
 * 		QQ定义一个规则:1)由6到10为组成的数字
 * 				  2)不能以0开头
 * 		手机号规则：以177开头的十一位手机号	
 * 	分析:
 * 		1)键盘录入一个QQ号码,使用字符串接收
 * 		2)定义一个校验QQ的功能
 * 		3)在main()中调用返回boolean类型
 */
public class RegexDemo1 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入并接收数据
		System.out.println("请输入一个QQ号码：");
		String QQ = sc.nextLine();
		System.out.println("请输入一个手机号码：");
		String num = sc.nextLine();
		
		boolean flag = checkQQ(QQ);
		System.out.println("flag = "+flag);
		boolean flag1 = checkQQ(num);
		System.out.println("flag1 = "+flag);
	}
	
	public static boolean checkQQ(String qq){
		//定义正则规则
		//String regex = "[1-9][0-9]{5,9}";
		String regex = "[1-9]\\d{5,9}";
		return qq.matches(regex);
	}
	public static boolean checkNum(String num){
		//定义正则规则
		String regex = "177\\d{9}";
		return num.matches(regex);
		
	}
}

练习：校验一个5-10位的QQ邮箱号码：形如12345678@qq.com

package day_13_11_7.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 s = sc.nextLine();
		System.out.println("请输入一个163邮箱号：");
		String s1 = sc.nextLine();
		
		
		//校验邮箱号码
		//boolean flag = checkEmail(s);
		//System.out.println("flag = "+flag);
		boolean flag1 = checkEmail(s1);
		System.out.println("flag1 = "+flag1);
		
	}
	public static boolean checkEmail(String s1){
		//定义正则规则
		//String regex = "[1-9][0-9]{4,9}+@qq\\.com";
		//return s.matches(regex);
		
		String regex1 = "[a-zA-Z_0-9]+@163\\.com";
		return s1.matches(regex1);
		
	}
}

6.String的分割功能

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

package day_13_11_7.regex;

import java.util.Scanner;

public class RegexDemo3 {
	public static void main(String[] args) {
		
		//定义一个字符串
		String prices = "380-450";
		
		//定义正则规则
		String regex = "-";
		
		//public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串,返回值类型是一个字符串数组类型
		String[] strArray = prices.split(regex);
		
		//如何得到当前字符数组中的元素(转换int类型的数据)
		int startPrice = Integer.parseInt(strArray[0]);
		int endPrice = Integer.parseInt(strArray[1]);
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入并接收数据
		System.out.println("请输入一个价格：");
		int price = sc.nextInt();
		
		//判断是否符合查找需求
		if(price>=startPrice&&price<=endPrice){
			System.out.println("在价格区间380-450中");
		}else{
			System.out.println("不符合需求");
		}	
	}
}

练习：关于分割功能

package day_13_11_7.regex;
/**
 * 分割功能的应用
 * */
public class RegexTest {
	public static void main(String[] args) {
		// 定义一个字符串
		String str1 = "aa,ss,dd,ff,gg";
		
		//使用分割功能
		String[] strArray1 = str1.split(",");
		
		//遍历得到字符串数组
		for(int i = 0;i<strArray1.length;i++){
			System.out.println(strArray1[i]+" ");
		}
		System.out.println("-------------");
		
		//定义一个字符串
		String str2 = "aa  22     dd";
		String[] strArray2 = str2.split(" +");
		for(int i=0;i<strArray2.length;i++){
			System.out.println(strArray2[i]);
		}
		System.out.println("-------------");
		
		//定义一个字符串
		String str3 = "aa.bb.cc";
		String[] strArray3 = str3.split("\\.");
		for(int i=0;i<strArray3.length;i++){
			System.out.println(strArray3[i]);
		}
	}
}

7.String 类中的替换功能：和正则表达式有关系

public String replaceAll(String regex,String replacement )

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

	public static void main(String[] args) {
		// 定义一个字符串
		String str = "if you want to  travel you must have enough money";
		
		//让当前字符串的空格不显示出来
		//定义当前大串中空格的正则规则
		String regex = " +";
		String s = "*";
		
		//public String replaceAll(String regex,String replacement)
		String result = str.replaceAll(regex, s);
		System.out.println("result:"+result);
	}
}

8.关于模式和匹配器的使用：

1)获取模式对象Pattern（通过正则规则）:public static Pattern compile(String regex)将给定的正则表达式编译成一个模式对象

2)获取匹配器对象：Matcher

3)通过matches()方法返回一个结果:public boolean matches():判断当前用户录入的字符串是否和当前的正则规则匹配

package day_13_11_7.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexDemo5 {

	public static void main(String[] args) {
		//1)获取模式对象(通过正则规则)
		Pattern p = Pattern.compile("a*b");
		//2)通过模式获取匹配器对象,(一个字符串类型的数据)
		Matcher m = p.matcher("aaaaaaaaab");
		//3)调用Match(匹配器)中的：public boolean matches():判断当前用户录入的字符串是否和当前的正则规则匹配
		boolean flag = m.matches();
		System.out.println("flag:"+flag);
		
		System.out.println("----------------------------");
	
	
		//上述写法非常麻烦，可以用以下方式代替
	
		//定义一个正则规则
		String regex = "a*b";
		//指定某一个字符串
		String str = "aaaaaaaaab";
	
		//调用public boolean matches()方法
		boolean flag2 = str.matches(regex);
		System.out.println("flag2:"+flag2);
	}
}

练习：有如下字符串："91 27 46 38 50"；请写代码实现最终输出结果是："27 38 46 50 91"

package day_13_11_7.regex;

import java.util.Arrays;

public class RegexTest2 {
	public static void main(String[] args) {
		// 定义一个字符串
		String str = "91 27 46 38 50";
		//定义一个正则规则
		String regex = " ";
		
		//使用分割功能
		String[] strArray = str.split(regex);
		for(int i=0;i<strArray.length;i++){
			System.out.print(strArray[i]+" ");
		}
		System.out.println();
		
	    //定义一个int类型的数组，动态初始化
		int [] arr = new int [strArray.length];
		
		//遍历int类型的数组,并给其赋值
		for(int i=0;i<arr.length;i++){
			arr[i] = Integer.parseInt(strArray[i]);
		}
		
		//使用Arrays数组工具类进行排序
		Arrays.sort(arr);
		
		//将整形数组转换成字符串
		StringBuilder sb = new StringBuilder(); 
		//遍历int型数组，进行字符串拼接
		for(int i=0;i<arr.length;i++){
			//使用追加功能
			sb.append(arr[i]).append(" ");
		}
		
		//将字符串缓冲区转换成String类型并去除两端的空格
		String result = sb.toString().trim();
		System.out.println("result:"+result);
	}
}

二.集合（Collection）

1.由来：我们学习java的语言,是一种面向对象语言,面向对象语言对事物的描述是通过对象体现出来的,那么存储很多个学生,就需要使用容器变量进行存储。

目前:学习过哪些容器变量呢?

数组,StringBuffer/StringBuilder,对于数组来说,数组的长度是固定的,不符合实际需求(长度不可变);对于StringBuffer来说始终在内存中返回的是字符串类型,也不满足元素类型变化的要求;所以,Java就提供了一个技术:集合!

2.面试题：集合和数组的区别?

1)长度的区别:数组:长度是固定的;   集合:长度是可变的

2)存储数据类型的区别:数组:可以存储引用类型,可以存储基本数据类型集合:只能存储引用类型

3)存储元素的区别： 数组:在同一个数组中,只能存储同一种数据类型的元素;举例 数组:杯子:只能装水

集合:可以 存储多种数据类型的元素;举例:集合:杯子:装水,其他饮料...

3.概念：集合是可以存储多种类型的元素,但是,需求如果变化,针对集合来说,Java提供了很多集合类,每一种集合类的数据结构不一样,所以,将他们之间的共性内容抽取出来,就行成了一个集合的继承体系图!

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

4.Collection的一些功能

1)添加功能:

boolean add(Object e):给集合中添加指定的元素

  boolean addAll(Collection c):添加一个集合中的所有元素

2)删除功能:

void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)

boolean remove(Object o):删除一个集合中的指定元素

boolean removeAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?

3)判断功能:

boolean contains(Object o):判断一个集合中是否包含指定的单个元素

boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有.

boolean isEmpty():判断集合是否为空,如果为空,则返回true

4)交集功能:

boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?

5)获取功能;

int size():获取集合中的元素数

Iterator<E> iterator():迭代器

6)转换功能:

Object[] toArray():将集合转换成数组

注意：

数组中有没有length(),String类中有没有length(),集合中有没有length()?

数组:length属性 String:length() 集合中:size()

package day_13_11_7.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;
    		}
		 */
		System.out.println(flag);//true
		
		c.add("hello");
		c.add("every");
		c.add("one");
		System.out.println(c);//[hello, hello, every, one]
		
		//void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)
		//c.clear();
		//System.out.println(c);//[]
		
		//boolean remove(Object o):删除一个集合中的指定元素
		System.out.println("remove:"+c.remove("hello"));
		System.out.println(c);
		
		//boolean contains(Object o):判断一个集合中是否包含指定的单个元素
		System.out.println("contains:"+c.contains("hello"));
		
		//boolean isEmpty():判断集合是否为空,如果为空,则返回true
		System.out.println("isEmpty:"+c.isEmpty());
		
		//int size():获取集合中的元素数
		System.out.println("size:"+c.size());
	}

}

package day_13_11_7.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.add("a");
		c1.add("b");
		c1.add("c");
		
		c2.add("c");
		c2.add("d");
		c2.add("e");
		c2.add("f");
		
		//boolean addAll(Collection c):添加一个集合中的所有元素
		//System.out.println("addAll:"+c1.addAll(c2));
		//System.out.println(c1);	//[a, b, c, c, d, e, f]
		
		//boolean removeAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?
		//删除一个算是删除
		//System.out.println("removeAll:"+c1.removeAll(c2));
		//System.out.println(c1);//[a, b]
		//System.out.println(c2);//[c, d, e, f]
		
		//boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有
		System.out.println("containsAll:"+c1.containsAll(c2));//false,包含所有算是包含
		System.out.println(c1);//[a, b, c]
		System.out.println(c2);//[c, d, e, f]
		
		//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);//[c]
		System.out.println(c2);//[c, d, e, f]
	}
}

5.将集合转换成数组：Object[] toArray():将集合转换成数组

练习：给集合中添加String类型的元素，遍历集合

package day_13_11_7.collection;

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

/**
 * Object[] toArray():将集合转换成数组
 * 
 * 需求:给集合中添加String类型的元素,遍历集合
 */
public class CollectionDemo3 {

	public static void main(String[] args) {
		// 创建Collection集合对象
		Collection c = new ArrayList();
		
		//给集合中添加元素
		c.add("you");
		c.add("want");
		c.add("you");
		c.add("do");
		
		//将集合转换成数组
		Object[] objs = c.toArray();
		
		//遍历对象数组
		for(int i=0;i<objs.length;i++){
			//System.out.println(objs[i]);
			//需求:获取集合中元素的同时获取每个元素的长度
			//System.out.println(objs[i]+"------"+objs[i].length());//对象数组中没有定义length()方法
			//要获取字符串的长度：需要使用length(),该方法属于String类的特有功能
			String s = (String)objs[i];//向下转型
			System.out.println(s+"------"+s.length());
		}
		
	}
}

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

package day_13_11_7.collection;

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

/**
 *  需求:有5个学生,每一个学生有自己的信息(姓名,年龄等等),将5个学生的信息遍历出来!
 *  使用集合的转换功能去遍历学生信息
 *  1)创建集合对象
 *  2)创建5个学生对象
 *  3)使用集合添加5个学生对象
 *  4)将集合转换成数组:Object[] toArray() ;
 *  5)遍历数组
 */
public class CollectionTest {

	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();
		
		Student s1 = new Student("zhang",13);
		Student s2 = new Student("li",14);
		Student s3 = new Student("luo",15);
		Student s4 = new Student("han",16);
		Student s5 = new Student("zhao",17);
		
		//使用集合添加五个学生对象
		c.add(s1);
		c.add(s2);
		c.add(s3);
		c.add(s4);
		c.add(s5);
		
		//将集合转换成数组
		Object[] objs = c.toArray();
		//循环遍历数组
		for(int i=0;i<objs.length;i++){
			//System.out.println(objs[i].toString());
			Student s = (Student)objs[i];
			System.out.println(s.getName()+"----"+s.getAge());
		}
	}
}

package day_13_11_7.collection;

public class Student {
	private String name;
	private int age;
	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	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 + "]";
	}	
}

6.集合的专有遍历方式;使用集合本身迭代功能遍历集合中的元素

Iterator iterrator():迭代器，Iterator是个接口

创建对象：Iterator it = c.iterator();

成员方法：Object next()返回迭代的下一个元素：获取功能

boolean hasNext():判断一个集合中是否有下一个可以迭代的元素：判断功能

package day_13_11_7.collection1;

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();
		
		//向集合中添加字符串
		c.add("you");
		c.add("want");
		c.add("you");
		c.add("do");
		
		//获取迭代器对象
		Iterator it = c.iterator();//底层使用ArrayList中的匿名内部类的形式:接口多态的形式
		//获取元素
		//Object obj = it.next();
		//System.out.println(it.next());
		//System.out.println(it.next());
		//System.out.println(it.next());
		//System.out.println(it.next());
		//System.out.println(it.next());//java.util.NoSuchElementException:没有这样的元素异常!
		
		//改进方法：获取下一个元素之前加上判断，防止异常出现
		while(it.hasNext()){
			//System.out.println(it.next()); //获取字符串的内容
			//获取字符串的同时获取字符串长度，需将当前输出强制转换成String类型
			String s = (String)it.next();//向下转型
			System.out.println(s+"----"+s.length());
			
		}		
	}
}

练习：使用存储自定义对象并遍历

1)toArray():将集合转换成数组

2)集合专有遍历方式:迭代器遍历

package day_13_11_7.collection1;

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

public class CollectionTest {

	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();
		
		//创建3个学生对象
		Student s1 = new Student("zhang",13);
		Student s2 = new Student("wang",14);
		Student s3 = new Student("zhao",15);
		
		//给集合添加元素
		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());	
		}		
	}
}

package day_13_11_7.collection1;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	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;
	}	
}

练习：对象类数组

package day_13_11_7.collection;

import day_13_11_7.collection1.Student;

/**
 * 对象数组:可以存储对象的数组
 * 
 * 需求:有3个学生,每一个学生有自己的信息(姓名,年龄等等),将3个学生的信息遍历出来!
 * 
 * 		分析:A:定义一个学生类:
 * 			提供两个成员 变量
 * 			String name,int age
 * 			提供无参/有参的构造方法
 * 			提供set/get()方法
 * 		    B:定义一个学生数组(对象数组)
 * 		    C:创建3个学生对象
 * 		    D:赋值,将3个学生对象放到学生数组中
 * 	            E:遍历数组
 * 	            F:输出
 */
public class ObjectArrayDemo {

	public static void main(String[] args) {
		// 定义一个学生数组：格式:数据类型[] 数组名称 = new 数据类型[数组长度] ;
		Student [] students = new Student[5];
		//创建3个学生对象
		Student s1 = new Student("zhang",13);
		Student s2 = new Student("wang",14);
		Student s3 = new Student("zhao",15);
		
		//赋值
		students[0] = s1;
		students[1] = s2;
		students[2] = s3;
		
		//遍历学生数组
		for(int x = 0 ; x <students.length ; x ++){
		        //System.out.println(students[x]);
			//通过底层原码重写toString()得到的每个对象的成员变量的信息	
			Student s = students[x] ;
			System.out.println(s.getName()+"----"+s.getAge());
		}
	}

}

三.List集合

1.List集合是一个有序的集合（存储元素和取出元素一致），该集合中的元素可以重复

package day_13_11_7.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 用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);
		}
	}
}

2.List集合的特有功能：

1)添加功能:void add(int index, Object element)在列表的指定位置插入指定元素

2)删除功能:Object remove(int index)移除列表中指定位置的元素,返回被删除的元素

3)获取功能:

ListIterator listIterator():列表迭代器:List集合的专有遍历方式

Object get(int index)返回列表中指定位置的元素。

4)替换:set(int index,Object element)用指定元素替换列表中指定位置的元素

package day_13_11_7.list;

import java.util.ArrayList;
import java.util.List;
public class ListDemo2 {

	public static void main(String[] args) {
		// 创建List集合对象
		List list = new ArrayList();
		
		//给集合添加元素
		list.add("hello");
		list.add("world");
		list.add("world");
		list.add("Java");
		
		/*//1.添加功能:void add(int index, Object element)在列表的指定位置插入指定元素
		list.add(0, "hi");
		System.out.println(list);//[hi, hello, world, world, Java]
*/		
		/*//2.Object remove(int index)移除列表中指定位置的元素,返回被删除的元素
		 list.remove(0);
		 System.out.println(list);//[world, world, Java]
*/	
		
		/* //3. set(int index,Object element)用指定元素替换列表中指定位置的元素
		list.set(3, "JavaWeb");
		System.out.println(list);*/
		
		
		//4.Object get(int index)返回列表中指定位置的元素
		System.out.println("get:"+list.get(1)) ;//get:world
		//System.out.println("get:"+list.get(11)) ;//java.lang.IndexOutOfBoundsException		
		System.out.println(list);
	}
}

package day_13_11_7.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo3 {
	/**
	 *List集合的遍历方式
	 *		1)toArray()
	 *		2)Collection集合中的Iterator iterator();
	 */
	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") ;
		
		//普通for循环遍历list集合，使用size()和get()相结合
		for(int i=0;i<list.size();i++){
			//Object object = list.get(i);
			//需求：获取字符串内容同时，获取字符串长度
			String s = (String)list.get(i);
			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());
		}
	}
}

3.List集合的列表迭代器:ListIterator listIterator()

列表迭代器接口中有以下几个方法：

1)boolean hasNext():判断是否有下一个可以迭代的元素(正向遍历)

2)Object next():如果有可以遍历的元素,就获取这个元素

3)boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)

4)Object  previous():如果有上一个可以迭代的元素,就获取上一个元素

注意：要使用逆向遍历,前提必须有正向遍历存在,直接使用逆向遍历,没有意义!

package day_13_11_7.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListDemo4 {
	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("-----------------------");
		
		while(it.hasPrevious()){
			String s = (String)it.previous() ;
			System.out.println(s);
		}
	}
}

package day_13_11_7.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 {
	public static void main(String[] args) {
		//创建List集合对象
		List list = new ArrayList() ;
		
		//给集合中添加元素
		list.add("hello") ;
		list.add("world") ;
		//list.add("world") ;
		list.add("java") ;
		
		/*//获取迭代器
		Iterator it = list.iterator();//该迭代器中没有添加功能,List集合中的专有遍历方式:列表迭代器有添加功能:add(Object obj)
		//循环遍历
		while(it.hasNext()){
			String s = (String)it.next();
			//判断
			if("world".equals(s)){
				//添加元素
				list.add("javaee"); //java.util.ConcurrentModificationException
			}
		}*/
		
		
		/*//方法1:使用迭代器遍历集合,使用迭代器添加元素
		//将指定的元素插入到列表中(指定元素后面插入)
		ListIterator it = list.listIterator();
		
		//循环遍历
		while(it.hasNext()){
			String s = (String)it.next();
			//判断
			if("world".equals(s)){
				//添加元素
				it.add("javaee"); //java.util.ConcurrentModificationException
			}
		}*/
		
		//方案2：使用集合遍历(普通for循环size()和get()相结合),使用集合添加元素
		for(int i=0;i<list.size();i++){
			String s = (String)list.get(i);
			//判断
			if("world".equals(s)){
				//集合添加
				list.add("javaee") ;//在末尾添加元素
			}
		}
		
		//输出集合
		System.out.println("list:"+list);
		
	}	
}