Java学习总结（五）——（常用类，正则表达式，集合(List，Set) 迭代器）

一．常用类
1.Math类(属于lang包中)：
（1）Math 类提供了一序列基本数学运算和几何函数的方法。
（2）Math类是final类（不能继承），并且它的所有成员变量和成员方法都是静态的（可以用类名直接调用）。
（3）Math类中常用方法：
*静态常量：Math.PI（圆周率）
*静态方法：
·double pow (double a, double b)：计算a的b次方
·double sqrt (double a) ：计算给定值的平方根
·double abs(double a):计算a的绝对值
·double ceil (double a)：返回大于等于 a的最小整数的double值（向上取整）
·double floor (double a) ：返回小于等于 a的最大整数的double值（向下取整）
·int max(int a, int b)： 取a,b中最大值
·int min(int a,int b):取a,b中最小值
·int round(float a)：a的的四舍五入值
·double random()：取一个0（包含）到1（不包含）的伪随机数
·double cbrt(double a):取a的立方根
·double log10(double a):a以十为低的对数
例（以上面方法举例）：
package commom; import java.util.Scanner; public class MathDemo {public static void main(String[] args) {System.out.println("所求4的5次方是："+Math.pow(4, 5));System.out.println("输入数向上取整得："+Math.ceil(9.9));System.out.println("输入数的绝对值是："+Math.abs(-56.0));System.out.println("输入数的立方根是:"+Math.cbrt(8));System.out.println("输入数向下取整得:"+Math.floor(9.9));System.out.println("输入数的平方根是:"+Math.sqrt(9));System.out.println("输入数以十为底的对数是:"+Math.log10(68));System.out.println("输入数中的最大值:"+Math.max(23, 45));System.out.println("输入数中 的最小值："+Math.min(23, 54));System.out.println("得到一个0（包含）到1（不包含)的浮点数:"+Math.random());int y=(int)(Math.random()*16)+3;System.out.println("得到一个3（包含）到18（包含）的随机整数："+y);System.out.println("输入数的四舍五入的结果是："+Math.round(78.499));System.out.println("输入数的四舍五入的结果是："+Math.round(67.50111));Scanner scan=new Scanner(System.in);System.out.print("请输入圆的半径：");int r=scan.nextInt();System.out.println("所输入半径的圆的面积是："+Math.PI*Math.pow(r, 2));System.out.println("所输入半径的圆的周长是："+Math.PI*r*2);scan.close();}}运行结果为：
所求4的5次方是：1024.0输入数向上取整得：10.0输入数的绝对值是：56.0输入数的立方根是:2.0输入数向下取整得:9.0输入数的平方根是:3.0输入数以十为底的对数是:1.8325089127062364输入数中的最大值:45输入数中 的最小值：23得到一个0（包含）到1（不包含)的浮点数:0.9779898472549314得到一个3（包含）到18（包含）的随机整数：17输入数的四舍五入的结果是：78输入数的四舍五入的结果是：68请输入圆的半径：12所输入半径的圆的面积是：452.3893421169302所输入半径的圆的周长是：75.39822368615503*注意（绿色标记部分）
2.Random类（util）：
(1)Random类的对象可以生成“伪随机数”。
(2)常用方法：
*public int nextInt(int bound)
返回从0(包含)到bound(不包含)的一个“伪随机” 整数值。
*public boolean nextBoolean()
返回一个“伪随机”的boolean值
例（以上述为例）：
package commom; import java.util.Random; public class RandomDemo {public static void main(String[] args) {Random ran=new Random();double x=ran.nextDouble();int y=ran.nextInt(10)+3;System.out.println("输出0(包含)到1（不包含）的浮点型随机数:"+x);System.out.println("输出3（包含）到12（包含）的随机数："+y);System.out.println("输出随机布尔型："+ran.nextBoolean());}}结果为：
输出0(包含)到1（不包含）的浮点型随机数:0.18420773180887395输出3（包含）到12（包含）的随机数：7输出随机布尔型：false
3.System类：
（1）成员变量
System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
成员方法*数组拷贝：void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)例（以上述成员方法与 成员变量为例）：package commom; public class SystemDemo { public static void main(String[] args) {System.out.println("正常输出~~");System.err.println("错误输出~~");System.out.println("数组 复制得：");int[] a={1,32,4,5,5,6,2,3,3};int[] b={12,34,5,4,6,6,87,4,34};System.arraycopy(a, 2, b, 3, 4);for(int x:b){System.out.print(x+" ");}}}结果为：错误输出~~正常输出~~数组 复制得：12 34 5 4 5 5 6 4 34 （3）exit()方法public static void exit(int status)该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。（4）gc()方法public static void gc()该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。垃圾回收时，会先调用finalize()方法，释放非java资源例（以exit()方法与gc()方法为例）：SumNumber类：package commom; public class SumNumber {@Overrideprotected void finalize() throws Throwable {int x=5;int y=7;System.out.print("垃圾回收前进行的计算：积是 "+(x*y));}}测试Finalize类：package commom; public class FinalizeDemo { public static void main(String[] args){SumNumber sum=new SumNumber();sum=null;System.gc();while(true){int i=1;i++;System.out.println(i);System.gc();System.exit(0);}}}结果为：测试exit(0)方法：2垃圾回收前进行的计算：积是 35分析：有结果可知在垃圾回收前运行了finalize方法中的内容，主方法中的while本是死循环因为System.exit(0)停止了虚拟机的运行导致while运行了一次就结束了*补充（计算时间方法）：currentTimeMillis方法public static long currentTimeMillis()以毫秒为单位返回从1970年1月1日午夜到当前时间的毫秒数例（currentTimeMillis方法）：package commom; import java.util.*; public class CurrentTimeMillsDemo {public static void main(String[] args) {long startTime=System.currentTimeMillis();ArrayList<String> list=new ArrayList<String>();Collections.addAll(list, "中国","美国","法国","英国","意大利");System.out.println("遍厉list集合为：");for(String str:list){System.out.print(str+" ");}System.out.println();long endTime=System.currentTimeMillis();System.out.println("遍厉集合所用时间"+(endTime-startTime)+"毫秒");} }运行结果为：遍厉list集合为：中国 美国 法国 英国 意大利 遍厉集合所用时间2毫秒
Runtime类：（1）作用：使应用程序与其运行的环境相关联（2）通过使用getRuntime()静态方法获得实例。（3）常用方法：*exec(String command)在单独的进程中执行指定的字符串命令，该方法 返 回Process对象，使用Process对象的destroy()方法可以杀掉进程*totalMemory()当前虚拟机的总内存（取决于系统运行环境）*maxMemory()JVM试图使用的最大内存（最大潜力）*freeMemory()当前JVM的空闲内存例（以上述方法为例）：package commom; import java.io.IOException;import java.util.Scanner; public class RuntimeDemo {public static void main(String[] args) {Runtime run=Runtime.getRuntime();run.gc();//显式请求垃圾回收System.out.println("当前JVM的空闲内存："+run.freeMemory()+"字节");System.out.println("当前JVM试图使用的最大内存："+run.maxMemory()+"字节");System.out.println("当前 JVM的总内存（取决于系统环境）："+run.totalMemory()+" 字节");try {run.exec("notepad");run.exec("calc");Process hanoi=run.exec("C:\\Users\\Administrator\\Desktop\\XHZ for Hanoi");Scanner scan=new Scanner(System.in);System.out.print("请输入是否关闭汉罗塔：y/n:");String chioce=scan.next();if("y".equals(chioce)){hanoi.destroy();}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}} }运行结果：当前JVM的内存总量是：56623104字节JVM试图使用的最大内存量：827850752当前JVM的空闲内存量：55496872请输入是否关闭汉罗塔：y/n:y5.Date（util包）类与SimpleDateFormat(text包)类：（1）Date类：表示时间与日期，提供当前具体时间，提供操作日期和时间各组成部分的方法（2）SimpleDateFormat类：用于定制时间日期格式例（以当前时间为例）:package commom; import java.text.SimpleDateFormat;import java.util.Date; public class SimpleDateFormatDemo {public static void main(String[] args) {Date date=new Date();System.out.println(date);SimpleDateFormat stf=new SimpleDateFormat("yyyy-mm-dd hh:mm:ss.SSS");System.out.println("当前日历是:");System.out.println(stf.format(date)); } }运行结果为：Tue Jan 02 15:18:57 GMT+08:00 2018当前日历是:2018-18-02 03:18:57.3976.Calender类（util包中，为抽象类）：（1）用于设置和获取日期/时间数据的特定部分（2）Calendar类提供一些方法和静态字段来操作日历*int get(int field)返回日历中给定字段的值*int set()可以用于调整日历 *MONTH指示月*DAY_OF_MONTH当前月中的哪一天*WEEK_OF_MONTH当前月中哪一周*DAY_OF_YEAR当前年的哪一天..........诸如上述格式方法多样例（上述方法）：import java.util.Calendar; public class CalenderDemo { public static void main(String[] args) {Calendar cal=Calendar.getInstance();System.out.println("当前日期的月份:"+cal.get(Calendar.MONTH)+1);System.out.println("当前月的第多少天："+cal.get((Calendar.DAY_OF_MONTH)));System.out.println("当前星期的第几天："+cal.get(Calendar.DAY_OF_WEEK));System.out.println("当前月的第几周："+cal.get(Calendar.WEEK_OF_MONTH));cal.set(1998, 02,14);System.out.println("当前日期的月份:"+cal.get(Calendar.MONTH)+1);System.out.println("当前月的第多少天："+cal.get((Calendar.DAY_OF_MONTH)));System.out.println("当前星期的第几"+cal.get(Calendar.DAY_OF_WEEK));System.out.println("当前月的第几周："+cal.get(Calendar.WEEK_OF_MONTH));} }运行结果：当前日期的月份:01当前月的第多少天：2当前星期的第几天：3当前月的第几周：1当前日期的月份:21当前月的第多少天：14当前星期的第几天：7当前月的第几周：2
正则表达式1.正则表达式(regex)是使用字符串来描述、匹配一系列符合某个句法规则的字符串2.用途：匹配、切割、替换、获取字符串3.正则表达式由一些普通字符和一些元字符组成。4.常见元字符

^	匹配输入字符串的起始位置
$	匹配输入字符串的结束位置
\d	匹配一个数字字符,等价于[0~9]
\D	匹配一个非数字字符，等价于[^0~9]
\s	匹配任何空白字符，包括空格，制表符，换页符等符号[\n\t\f\r]
\S	匹配任何非空白字符等价于[^\n\t\f\r]
\w	匹配包括下划线的任何单个字符等价于[A-Za-z0-9]
\W	匹配包括下划线的任何非单个字符等价于[^A-Za-z0-9]
.	匹配除了“\n\r”的任何单个字符
{n}	n是一个非负整数，匹配确定n次
{n,}	n是一个非负整数，至少匹配n次
{n,m}	m,n均是非负整数，其中n<=m，最少匹配n次，最多匹配m次
*	匹配前面子表达式零次或多次（大于等于0次）
?	匹配前面的子表达式零次或一次，也可用于取消贪婪模式
+	匹配前面的子表达式一次货多次

*[....]表示:[字符集] ”\”的含义：1. 反斜线后面可以加特定字符，组成所谓的“转义字符”。eg: \n \t 2. 用于取消元字符的意义，使元字符变为普通字符。eg: “\\” 代表”\”。3. 用于组成正则表达式中的元字符。 eg: “\d” 在正则表达式中代表“匹配一个数字字符”。
Pattern类与Matcher类：（1） Pattern类与Matcher类都在java.util.regex包 中定义。（2） Pattern类的对象代表正则表达式编译之后的对象；Matcher类主要用 于执行验证。（3）Pattern类的主要方法： public static Pattern compile(String regex); public Matcher matcher(CharSequence input) Matcher类的主要方法： public boolean matches();（以上述元字符，Pattern类与Matcher类为例）：7.String类对正则表达式的支持（1）public boolean matches(String regex) 判断字符串是否与给定的正则表达式匹配。 （2）public String replaceAll(String regex,String replacement) 字符串替换
public String[] split(String regex) 字符串拆分
补充：&正则表达式中的问号?有两种作用：·第一种作用：重复前面表达式0次或1次。·第二种作用：在表示次数的元字符后加上?代表取消默认的贪婪匹配模 式，变为“非贪婪匹配模式”。 例1（中国的邮政编码都是6位验证）package regexDemo; import java.util.Scanner;import java.util.regex.*;public class PostcodeRegex {public static void main(String[] args) {Scanner scan=new Scanner(System.in);System.out.println("请输入邮编:");String postcode=scan.next();String regex="\\d{6}";Pattern pat=Pattern.compile(regex);Matcher mat=pat.matcher(postcode);if(mat.matches()){ //System类中是否匹配方法System.out.println("邮编正确！");}else{System.out.println("邮编错误！");}} }运行结果为:请输入邮编:724407邮编正确！例2（手机号码都是11位，并且第1位都是1）package regexDemo; import java.util.Scanner;import java.util.regex.*; public class PhoneNumRegex { public static void main(String[] args) {Scanner scan=new Scanner(System.in);System.out.println("请输入手机号码：");String phoneNum=scan.next();String regex="1\\d{10}";Pattern pat=Pattern.compile(regex);Matcher mat=pat.matcher(phoneNum);if(mat.matches()){System.out.println("手机号码格式正确！");}else{System.out.println("手机号码格式错误！");}} }运行结果为:请输入手机号码：13467005453手机号码格式正确！例3（Email验证）：package regexDemo;import java.util.Scanner;import java.util.regex.*;public class EmailRegex {public static void main(String[] args) {Scanner scan=new Scanner(System.in);System.out.println("请输入email号：");String email=scan.next();String regex="\\w+@\\w+\\.\\w+\\.?\\w+";Pattern pat=Pattern.compile(regex);Matcher mat=pat.matcher(email);if(mat.matches()){System.out.println("email格式正确！");}else{System.out.println("email格式错误！");} } } 请输入email号：139537423@qq.comemail格式正确！例4（替换）：package regexDemo; public class ReplaceDemo { public static void main(String[] args) {String str="judf...dgud...uuif...hdjfhf";System.out.println(str.replaceAll("\\.+","")); } }运行结果为：Judfdguduuifhdjfhf*补充：
find()方法移动指针，group()方法分组
\\1引用前面第一个分组
在正则表达式中\num代表“反向引用”第num个分组的内容例5（拆分我爱中华haha123中国万岁haha46456干点啥感觉haha79567";中的haha数字分组）:package regexDemo; import java.util.regex.*; public class SpiltDemo {public static void main(String[] args) {String str="我爱中华haha123中国万岁haha46456干点啥感觉haha79567";String regex="(haha\\d+)";Pattern pat=Pattern.compile(regex);Matcher mat=pat.matcher(str);int i=0;while(mat.find()){i++;System.out.println(“第”+i+”组为：”mat.group(1));}} }运行结果为：第1组为：haha123第2组为：haha46456第3组为：haha79567例6（在正则表达式中，\num代表“反向引用”第num个分组中的内容）package regexDemo; import java.util.regex.*; public class BackRegex { public static void main(String[] args) {String str="fjkdshahaguidsghthtiusfyuyusfgireregdgtdr";String regex="([A-Za-z]{2})\\1";Pattern pat=Pattern.compile(regex);Matcher mat=pat.matcher(str);int i=0;while(mat.find()){i++;System.out.println("第"+i+"组"+mat.group(0));}} }运行结果为：第1组haha第2组htht第3组yuyu第4组rere例7（贪婪模式及非贪婪模式）：package regexDemo; public class abbbDemo { public static void main(String[] args) {String str="xyyyyyyyyyyyyyy";System.out.println("贪婪模式： "+str.replaceAll("xy+", "*"));System.out.println("非贪婪模式： "+str.replaceAll("xy+?", "*"));} }运行结果：贪婪模式： *非贪婪模式： *yyyyyyyyyyyyy
枚举类型（引用类型中的一类）1. 枚举类型使用一组常量值来表示特定的数据集合，该集合中数据的数目确定（通常较少），且这些数据只能取预先定义的值。2. Java枚举类型均自动继承java.lang.Enum类（该类继承了Object类）。3.声明枚举类型：[public] enum 枚举类型名称{ 枚举对象1,枚举对象2,…,枚举对象n ;} eg: public enum Color{ RED,GREEN,BLUE;}4.获取枚举对象的两种方法：*方法一：取得单个枚举对象 枚举.对象名 *方法二：取得全部枚举对象 枚举.values() 注意：枚举.values()返回的是一个对象数组， 可以通过遍历该对象数 组获取所有枚举对象。例(写一个枚举并获取其对象)：package enumdemo; public class TsetEnumcountry { public static void main(String[] args) {EnumCountry country=EnumCountry.CHINA;EnumCountry country1=EnumCountry.FRANCH;System.out.println("枚举EnumCountry中一个元素为:"+country);System.out.println("枚举EnumCountry中一个元素为:"+country1);for(EnumCountry country2:EnumCountry.values()){System.out.println("遍厉枚举中的所有元素为:"+country2+" ");} } }运行结果为:枚举EnumCountry中一个元素为:CHINA枚举EnumCountry中一个元素为:FRANCH遍厉枚举中的所有元素为:CHINA 遍厉枚举中的所有元素为:FRANCH 遍厉枚举中的所有元素为:AMERICAN 遍厉枚举中的所有元素为:JAPAN 例2（根据id找性别）：学生枚举：package enumdemo; public enum Student {MALE("张三",1),FEMALE("李四",2);private String name;private int id;private Student() {}public static Student findById(int id){for(Student stu:Student.values()){if(stu.id==id){return stu;}}return null;} private Student(String name, int id) {this.name = name;this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;} }测试枚举类：package enumdemo; import java.util.Scanner; public class TestDemo { public static void main(String[] args) {Scanner scan=new Scanner(System.in);System.out.print("请输入id:");int id=scan.nextInt();Student stu=Student.findById(id);System.out.println("根据id找到的性别:"+stu); } }运行结果为：请输入id:1根据id找到的性别:MALE
集合的概念与框架的的结构
集合与数组的对比：*数组：长度固定，遍历速度快可以存储基本类型和引用类型*集合：如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象——可以使用Java集合框架
集合的概念：·Java API所提供的一系列类的实例，可以用于动态存放多个 对象。·Java集合框架提供了一套性能优良、使用方便的接口和类， 它们位于java.util包中·特点：长度不固定，只能存储引用类型对象
集合的框架：（图一）

Collecton

List

Set

ArrayList

LinkedList

HashSet

TreeSet

Collections其中图一中Collection,List,Set都是接口，其他都是集合实现类，Map集合以后学后再说*其中Collections类中提供了集合进行拍序，遍厉等各种算法，算是集合的工具类Collection接口中定义了一些集合的常用方法

方法	说明
int size()	返回此collection中的元素数
Boolean isEmpty()	判断此collection中是否包含元素
boolean contains(Object obj)	判断此collection是否包含指定的元素。
boolean add(Object element);	向此collection中添加元素
boolean remove(Object element);	从此collection中移除指定的元素。
void clear();	移除些collection中所有的元素。
Iterator iterator();	返回在此collection的元素上进行迭代的迭代器
Object[] toArray();	把此collection转成数组。

5.Collection接口－定义了存取对象的方法。两个常用的子接口：*List接口：存放的元素有序且允许有重复的集合接口。*Set接口：存放的元素不包含重复元素的集合接口。本节暂不举例等实现类学习之后举例List集合及其实现类
List接口是Collection接口的子接口
实现List接口的集合类中的元素是有序的，且允许重复。
List集合中的元素都对应一个整数型的序号记载其在集合中的位置，可以根据序号存取集合中的元素。
JDK API中常用的List集合类常用的有：
ArrayList集合
LinkedList集合
List集合中的常用方法（List接口比Collection接口中新增的几个实用方法）：（1）public Object get(int index);返回列表中的元素数（2）public Object add(int index, Object element);在列表的指定位置插入指定元素.将当前处于该位置的元素（如果有的话） 和所有后续元素向右移动（3）public Object set(int index, Object element) ;用指定元素替换列表中指定位置的元素（4）public Object remove(int index);移除列表中指定位置的元素（5）public ListIterator listIterator()返回此列表元素的列表迭代器
List接口实现类（ArrayList）:
ArrayList是使用数组集合实现List
优点：对于使用引索取出元素有较好的效率，它使用索引快速定位对象
缺点：元素做删除或插入速度较慢，因为它使用了数组需要移动后面的元素以调整索引例（ArrayList使用）：package ListDemo; import java.util.ArrayList;import java.util.Scanner; public class ArrayListDemo { public static void main(String[] args) {Scanner scan=new Scanner(System.in);System.out.print("请输入要获取的元素的索引：");int i=scan.nextInt();ArrayList<String> list=new ArrayList<>();list.add("中国");list.add("法国");list.add("英国");list.add("美国");list.add("意大利");System.out.println("输入 缩引位置的元素是："+list.get(1));System.out.println("______**____________");System.out.println("使用增强for循环遍厉集合中的元素：");for(String str:list){System.out.print(str+" ");}System.out.println();System.out.println("_______*******______");System.out.println("起始集合的长度："+list.size());list.remove(2);System.out.println("现在集合的长度为："+list.size());System.out.println("缩引位置替换后集合遍厉：");list.set(2, "China");for(String str:list){System.out.print(str+" ");}System.out.println("________*******_________"); System.out.println("集合中包含“意大利”吗"+list.contains("意大利")); System.out.println("______**for循环遍厉集合**__________"); for(int j=0;j<=list.size();j++){ System.out.print(list.get(j)+" "); } scan.close();} }运行结果为:请输入要获取的元素的索引：1输入 缩引位置的元素是：法国______**____________使用增强for循环遍厉集合中的元素：中国 法国 英国 美国 意大利 _______*******______起始集合的长度：5现在集合的长度为：4缩引位置替换后集合遍厉：中国 法国 China 意大利 ________*******_________集合中包含“意大利”吗true______**for循环遍厉集合**__________中国 法国 China 意大利
LinkedList实现类：（1）LinkedList是使用双向链表实现的集合。（2）LinkedList新增了一些插入、删除的方法。（3）优点：频繁的插入或删除元素有较好的效率（4）缺点：查询元素时，效率低，因为要从第一个元素查找。例（LinkedList的使用）：package ListDemo; import java.util.LinkedList; public class LinkedListDemo { public static void main(String[] args) {LinkedList<String> list=new LinkedList<String>();list.push("中国");list.push("法国");list.push("英国");list.push("美国");System.out.println("模拟栈数据结构：");System.out.println(list.remove());System.out.println(list.remove());System.out.println(list.remove());System.out.println(list.remove());list.add("中国");list.add("法国");list.add("英国");list.add("美国");System.out.println("模拟队列数据结构：");System.out.println(list.pop());System.out.println(list.pop());System.out.println(list.pop());System.out.println(list.pop()); } }运行结果为：模拟栈数据结构：美国英国法国中国模拟队列数据结构：中国法国英国美国8.Collections类：（1）工具类，类中都是静态方法，可以用类名直接调用（2）主要方法：*Collections.addAll():添加元素*shuffle():打乱元素*revese():反转元素例（以上述方法为例）：package collectionsdemo; import java.util.ArrayList;import java.util.Collections; public class CollectionsDemo { public static void main(String[] args) {ArrayList<String> list=new ArrayList<>();Collections.addAll(list, "中国","法国","美国","英国");Collections.shuffle(list);System.out.println("反转之后集合遍厉：");showList(list);Collections.reverse(list);System.out.println("打乱之后集合遍厉：");showList(list); }public static void showList(ArrayList<String> list){for(String str:list){System.out.print(str+" ");}System.out.println();} }运行结果为：反转之后集合遍厉：英国 美国 法国 中国 打乱之后集合遍厉：中国 法国 美国 英国
ArrayList与LinkedList分别在何时使用：（1）ArrayList：遍历元素和随机访问元素的效率比较高，插入、删除等操作频繁时性能低下（2）LinkedList:插入、删除元素时效率较高,查找、遍历效率较低六．迭代器的使用1.Iterator是专门的迭代输出接口。所谓的迭代输出就是将元素进行判断，判断是否有内容，如果有内容则把内容取出。2.Iterator对象称作迭代器，用以方便的实现对集合内元素的遍历操作。3.所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了Iterator接口的对象。Iterator it = coll.iterator();while(it.hasNext()){ it.next();}4.Iterator接口中定义了如下方法（迭代器的使用方法）：（1）boolean hasNext(); //判断游标右边是否有元素（2）Object next(); //返回游标右边的元素并将游标移动到下一个位置游标 例（以上述方法为例）：package iteratordemo; import java.util.*; public class IteratorDemo { public static void main(String[] args) {ArrayList<String> list=new ArrayList<>();Collections.addAll(list, "中国","法国","英国","美国");Iterator<String> iter=list.iterator();while(iter.hasNext()){System.out.print(iter.next()+" ");} } }运行结果为：中国 法国 英国 美国七．Set集合接口实现类1.Set接口没有提供Collection接口额外的方法，但实现Set接口的集合类中的元素是不可重复的。2.JDK API中所提供的Set集合类常用的有：（1）HashSet：散列存放（2）TreeSet：有序存放（3）LinkedHashSet3.HashCode集合实现类：（1）根据每个对象的哈希码值(调用hashCode()获得)用固定的算法算出它的存储索引，把对象存放在一个叫散列表的相应位置(表元)中：（2）如果对应的位置没有其它元素，就只需要直接存入。（3）如果该位置有元素了，会将新对象跟该位置的所有对象进行比较(调用e quals())，以查看是否已经存在了：还不存在就存放，已经存在就不存储。4.HashSet的使用技巧及特点（1）HashSet不保存元素的加入顺序。（2）HashSet接口存、取、删对象都有很高的效率。（3）对于要存放到HashSet集合中的对象，对应的类可以重写 hashCode(Object obj)方法和equals()以实现对象相等规则的编写。例1（HashSet为例）：package hashsetdemo; import java.util.HashSet; public class HashSetDemo { public static void main(String[] args) {HashSet<String> set=new HashSet<>();set.add("中国");set.add("美国");set.add("法国");set.add("英国");set.add("意大利");for(String str:set){System.out.print(str+" ");}System.out.println();} }运行结果为:美国 法国 意大利 中国 英国 由此可见HashSet 集合中并没有保存放入顺序例2（重写equals方法及HashCode去重）：Student类：package hashsetdemo; public class Student {private String name;private int age;private String sex;public Student() {super();}public Student(String name, int age, String sex) {super();this.name = name;this.age = age;this.sex = sex;} @Overridepublic int hashCode() {return age*2;}@Overridepublic boolean equals(Object obj) {if (this == obj){return true;}else if(obj == null){return false;}else if(!(obj instanceof Student)){return false;}Student stu=(Student)obj;if(this.name!=null && this.name.equals(stu.name) && this.age==stu.age && this.sex.equals(stu.sex)){return true;}return false;}@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + ", sex=" + sex+"]"; }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 getSex() {return sex;}public void setSex(String sex) {this.sex = sex;} }Student测试类：package hashsetdemo; import java.util.HashSet; public class TestStudent { public static void main(String[] args) {HashSet<Student> set=new HashSet<Student>();set.add(new Student("令狐冲",21,"男"));set.add(new Student("令狐冲",21,"男"));set.add(new Student("李元芳",22,"男"));set.add(new Student("杨过",21,"男"));set.add(new Student("令狐冲",21,"男"));set.add(new Student("独孤求败",25,"男"));set.add(new Student("令狐冲",24,"男"));set.add(new Student("张无忌",21,"男"));set.add(new Student("小龙女",20,"女"));for(Student stu:set){System.out.println(stu+" ");} } }运行结果为：Student [name=令狐冲, age=24, sex=男] Student [name=独孤求败, age=25, sex=男] Student [name=小龙女, age=20, sex=女] Student [name=令狐冲, age=21, sex=男] Student [name=杨过, age=21, sex=男] Student [name=张无忌, age=21, sex=男] Student [name=李元芳, age=22, sex=男]
TreeSet集合实现类:(1)TreeSet:可以对加入其中的元素进行排序。但前 提是，必须指定排序规则。 (2)构造方法： public TreeSet() *如果使用TreeSet的无参构造实例化TreeSet集合，则加入到TreeSet集合中的元素所对应的类必须实现java.lang. Comparable<T>接口，复写其中的int compareTo(T o)方法，并在方法中编写排序规则。(3)在Comparable<T>接口的compareTo(T o)方法中，指定排序规则(以升序为例)： public int compareTo(Girl girl)｛ if(this.xxx>girl.xxx){ return 1; }else if(this.xxx<girl.xxx){ return -1; }else{ return 0; }｝*TreeSet比较排序的过程，已经对重复元素去重了。例1（以Tree为例）:package treeset; import java.util.TreeSet; public class TreeSetDemo { public static void main(String[] args) {TreeSet<String> set=new TreeSet<>();set.add("中国");set.add("德国");set.add("法国");set.add("英国");set.add("美国");set.add("意大利");set.add("俄罗斯");for(String str:set){System.out.print(str+" ");} } }运行结果为：中国 俄罗斯 德国 意大利 法国 美国 英国 TreeSet集合中自有一套自己的排序规则例2（根据自定义排序）：学生类：package treeset; public class Student implements Comparable<Student>{private String name;private int score;//总分private int math;//数学分数public Student() {super();}@Overridepublic String toString() {return "Student [name=" + name + ", score=" + score + ", math=" + math+ "]";} @Overridepublic int compareTo(Student stu) {if(this.score>stu.score){return -1;}else if(this.score<stu.score){return 1;}else if(this.math>stu.math){return -1;}else if(this.math<stu.math){return 1;}return this.name.compareTo(stu.name);}public Student(String name, int score, int math) {super();this.name = name;this.score = score;this.math = math;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}public int getMath() {return math;}public void setMath(int math) {this.math = math;} }测试类：public class TestStudent { public static void main(String[] args) {TreeSet<Student> set=new TreeSet<>();set.add(new Student("王磊",456,78));set.add(new Student("王忠磊",564,97));set.add(new Student("王磊",456,78));set.add(new Student("王磊",456,78));set.add(new Student("风清扬",786,123));set.add(new Student("杨过",456,98));set.add(new Student("令狐冲",556,86));set.add(new Student("张无忌",665,100));set.add(new Student("独孤求败",786,145));set.add(new Student("孙悟空",754,147));set.add(new Student("唐僧",453,67));for(Student stu:set){System.out.println(stu+" "); } } }运行结果：Student [name=独孤求败, score=786, math=145] Student [name=风清扬, score=786, math=123] Student [name=孙悟空, score=754, math=147] Student [name=张无忌, score=665, math=100] Student [name=王忠磊, score=564, math=97] Student [name=令狐冲, score=556, math=86] Student [name=杨过, score=456, math=98] Student [name=王磊, score=456, math=78] Student [name=唐僧, score=453, math=67] 注意：TreeSet比较排序已经重复元素去重了 补充（泛型）：1.泛型（Generic type）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。2.泛型的好处：解决了类型安全的问题(运行期出现“java.lang.ClassCastException”异常)
泛型类：class Gen<T> { private T ob; // 定义泛型成员变量 public Gen(T ob) { this.ob = ob; } public T getOb() { return ob; } public void setOb(T ob) { this.ob = ob; } public void showType() { System.out.println("T的实际类型是: " + ob.getClass().getName()); }}4.受限泛型（1）设置上限 类名称<? extends 上限类> 只能接收上限类对象或其子类对象（2）设置下限 类名称<? super 下限类> 接收下限类对象或其父类对象注意：若定义泛型类，可以将?设置为泛型标识。例：泛型接口：package generic; import java.util.List; public class MyGeneric<T extends List> { private T info;} 泛型测试类：package generic; import java.util.List; public class TestGeneric { public static void main(String[] args) {MyGeneric<List> mg=new MyGeneric<List>(); } }测试类：package generic; import java.util.*; public class GenericDemo { public static void main(String[] args) {ArrayList<String> list=new ArrayList<String>(); list.add("apple"); list.add("banana"); for(String data:list){ System.out.print(data+" "); } method(list); method(new ArrayList<Object>());} public static void method(List<? super String> list){List<String> temp=(List<String>)list;temp.add("abc");} }运行结果：apple banana 【本次总结完毕】