Java学习总结——（常用类，正则表达式，集合(List，Set) 迭代器）
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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 {
@Override
protected 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 block
e.printStackTrace();
}
}
}
运行结果：
当前JVM的内存总量是：56623104字节
JVM试图使用的最大内存量：827850752
当前JVM的空闲内存量：55496872
请输入是否关闭汉罗塔：y/n:y
5.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.397
6.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="\\[email protected]\\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号：
email格式正确！
例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()方法分组
在正则表达式中\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）LinkedHashSet
3.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;
}
@Override
public int hashCode() {
return age*2;
}
@Override
public 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;
}
@Override
public 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();
}
@Override
public String toString() {
return "Student [name=" + name + ", score=" + score + ", math=" + math
+ "]";
}
@Override
public 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
【本次总结完毕】
以上是关于Java学习总结——（常用类，正则表达式，集合(List，Set) 迭代器）的主要内容，如果未能解决你的问题，请参考以下文章