【Java笔记】---Week06 常用类、正则表达式与集合
写在前面的部分
本周主要学习了以下几个部分，一个是继续学习了常用类的相关知识，第二个学习了正则表达式，然后简单学习了集合方面的知识，扩充补充了二分查找方面的知识
一.常用类
1.System类
System:该类没有构造方法,所以字段和成员方法都用静态修饰
a. 三个字段
（1）in 标准输入流（2）out 标准输出流（3）err 标准错误输出流b. 常用方法
（1） gc() ：调用
gc方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。当控制权从方法调用中返回时，虚拟机已经尽最大努力从所有丢弃的对象中回收了空间。（2）exit() ： public static void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
（3）currentTimeMillis() ：public static long currentTimeMillis()返回当前的时间毫秒值
（4）arraycopy() ： * public static void arraycopy(Object src,int srcPos,Object dest, int destPos,int length) 指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
public class SystemDemo2 { public static void main(String[] args) { //定义两数组,静态初始化 int[] arr1 = {11,22,33,44,55,66} ; int[] arr2 = {3,4,5,6,7,8,9} ; //复制数组 System.arraycopy(arr1, 2, arr2, 1, 2) ; //分别将arr1 和arr2数组以字符串形式显示出来 System.out.println("arr1:"+Arrays.toString(arr1)); System.out.println("arr2:"+Arrays.toString(arr2)); /** * arr1:[11, 22, 33, 44, 55, 66] * arr2:[3, 33, 44, 6, 7, 8, 9] */ } }
2.BigDecimal类
a. 概念：不可变的、任意精度的有符号十进制数。BigDecimal 由任意精度的整数非标度值 和 32 位的整数标度 (scale) 组成。b. 构造方法：
public BigDecimal(String val) 数字字符串
c. 常用成员方法：
（1）add : public BigDecimal add(BigDecimal augend):加（2）subtract ： public BigDecimal subtract(BigDecimal subtrahend):减（3）multiply ： public BigDecimal multiply(BigDecimal multiplicand):乘法
（4）divide ： public BigDecimal divide(BigDecimal divisor):除
（5）divide ： public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode) 参数1:商,参数2:保留几位小数,参数3:舍入的一种模式:ROUND_HALF_UP
3.BigInteger
a. 概念 ：BigInteger:用来计算超出了Integer类型范围的数据b. 构造方法 ：public BigInteger(String val)将字符串表示的数字封装成BigInteger类型c. 常用方法 ：
（1）加减乘除四个方法 详见BigDecimal类（2）divideAndRemainder ：public BigInteger[] divideAndRemainder(BigInteger val) 返回一个BigInteger数组,数组中的元素:商,余数
public class BigIntegerDemo2 { public static void main(String[] args) { //创建BigInteger对象 BigInteger bg1 = new BigInteger("100") ; BigInteger bg2 = new BigInteger("50") ; //public BigInteger add(BigInteger val) System.out.println("add:"+bg1.add(bg2)); // public BigInteger subtract(BigInteger val) System.out.println("sub:"+bg1.subtract(bg2)); //public BigInteger multiply(BigInteger val) System.out.println("mul:"+bg1.multiply(bg2)); //public BigInteger divide(BigInteger val) System.out.println("div:"+bg1.divide(bg2)); BigInteger[] datas = bg1.divideAndRemainder(bg2) ; System.out.println("datas[0]:"+datas[0]);//2 System.out.println("datas[1]:"+datas[1]);//0 } }
4.Calendar类
a. 概念 ：Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法b. 构造方法 ：因为Calendar该类是一个抽象类:不能实例化的,所以通过一下这个方法来创建对象
public static Calendar getInstance()
Calendar c = Calendar.getInstance();c. 字段（被public static final int修饰 均为静态常量） ：
（1）YEAR：表示日历中 的年
（2）MONTH：月份:是0从开始计算的(实际应用中需要加一)
（3）DATE：日期，和DAY_OF_MONTH是同义词，表示月份中的某天
d. 常用方法 ：
（1）get ：public int get(int field)返回给定日历字段的值
int year = c.get(Calendar.YEAR);
（2）add ：public abstract void add(int field,int amount) 为给定的日历的字段添加或者减去时间偏移量
c.add(Calendar.YEAR,-3);
注意增加了偏移量之后，改字段就被永久改变
（3）public final void set(int year,int month,int date) 设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
e. 实例运用：
package org.westos.calendar; import java.util.Calendar; import java.util.Scanner; /** * 键盘录入一个年份,获取任意一年的二月有多少天 * 分析: * 1)创建键盘录入对象,录入某一个年份 * 2)获取日历类对象,getInstance() * 3)设置一个日历字段,年,月,日 * 日历类对象.set(year,2,1):这里其实表示3月1 * 4)将时间往前推一天 * 日历类对象.add(Calendar.DATE,-1) ; * 5)获取DATE月份中的天,输出即可 * * @author Apple */ public class CalendarTest { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //录入并接收数据 System.out.println("请您输入一个年份:"); int year = sc.nextInt() ; //创建日历类对象 Calendar c = Calendar.getInstance() ; //设置日历的字段,年,月,日 c.set(year, 2, 1) ;//其实月份:(month+1):3月1 //将时间往前推算一天 c.add(Calendar.DATE, -1) ; System.out.println("任意一年的二月有:"+c.get(Calendar.DATE)); } }
5.Date类
a. 概念 ：表示特定的瞬间，精确到毫秒。b. 构造方式 ：
（1）public Date():表示分配的一个Date对象:无参: 通过无参构造获取当前系统的具体的时间（2）public Date(long date):指定一个时间毫秒值 和它1970-1-1 00:00:00有时间差c. 常用成员方法 ：
（1）public long getTime():获取当前时间毫秒值 （System.currentTimeMills()）
如果知道Date对象,可以通过getTime()获取时间毫秒值
（2）public void setTime(long time)
d. 格式化与解析
（1）格式化：将Date对象--->String类型的日期的"文本格式":格式化
1） 要进行转换:必须使用中间桥梁:DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期Date -> 文本String）、解析（文本String-> 日期Date）和标准化
2）SimpleDateFormat类：
（i）public SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
（ii）pattern是指日期与时间模式
y年比如:2017---->yyyy
M 年中的月份:2------>MM
d 月份中的天数 :----->dd
H 小时HH
m 小时中的分钟数mm
s 分钟中的秒数ss
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
（2）解析 ：String类型日期的"文本格式"---->Date日期对象:解析
public Date parse(String source) 该方法本身会抛出一个异常:ParseException(解析异常:编译时期异常) 需要在方法后面加上throws ParseException
（3）应用实例
public class DateFormatDemo { public static void main(String[] args) throws ParseException { //Date日期对象--->格式化---->String:日期文本格式 //创建日期对象 Date d = new Date() ; // System.out.println(d); //创建SimpleDateFormat类对象,用该对象格式化Date对象 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ; //格式化 //public final String format(Date date) String dateStr = sdf.format(d) ; System.out.println("dateStr:"+dateStr); System.out.println("-----------------------"); //String日期"文本格式"----->解析----->Date对象 / 注意事项: 一定要保证SimpleDateFormat中的String Pattern这个模式和当前给的字符串的文本格式的模式必须一致! / String s = "2017-12-30" ; //创建SimpleDateFormat类的对象,用该对象解析String的日期的"文本格式" // SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日") ; SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ; //ava.text.ParseException: Unparseable date: "2017-12-30" //开始解析 //public Date parse(String source) Date d2 = sdf2.parse(s); System.out.println("d2:"+d2); } }
e. 应用 —— 求已经存活的天数
package org.westos.date_02;
import java.text.ParseException;
import java.util.Date;
import java.util.Scanner;
/**
* 键盘录入你的出生年月日,计算你来到这个世界有多少天了?
*
* 分析:
* 1)键盘键盘录入出生年月日,录入这一个String类型的数据
* 2)创建SimpleDateFormat对象指定一种模式
* 3)将当前String日期文本格式转换成date对象
* 4)通过Date对象获取getTime():获取时间毫秒值
* 5)得到当前系统时间的毫秒值(System.currentTimeMillis)
* 6):5)-4)=long 类型的时间
* 7)换算成多少天
* 8)输出
* @author Apple
*/
public class MyYearOldTest {
public static void main(String[] args) throws ParseException {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入并接收数据
System.out.println("请输入你的出生年月日: ");
String line = sc.nextLine() ;
//使用刚才DateUtil工具类
Date d = DateUtil.stringToDate(line, "yyyy-MM-dd") ;
//获取当前出生年日所在的时间毫秒值
long oldTime = d.getTime() ;
//获取当前系统时间的毫秒值
long nowTime = System.currentTimeMillis() ;
long time = nowTime - oldTime ;
//换算
long day = time/1000/60/60/24 ;
//输出
System.out.println("你来到这个世界有"+day+"天了");
}
}6.Math类
（1）public static int abs(int a):绝对值a. 常用方法 ：
（2）public static double ceil(double a):向上取整
（3）public static double floor(double a):向下取整
（4）public static double max(double a,double b):获取最大值
（5）public static double min(double a,double b):获取最小值
（6）public static double pow(double a,double b):a的b次幂
（7）public static double random():取值范围:[0.0,1.0)
（8）public static long round(double a):四舍五入
（9）public static double sqrt(double a):一个数的正平方跟
二.正则表达式
1.正则表达式
a. 常用语法 ：
（1）字符：x 字符 x :任意的字符
\\ 反斜线字符在代码中书写正则表达式:\------>用两个\\代表一个反斜线
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A')IO流中要写入换行符号:windows "\r\n"
\r 回车符 ('\u000D')
（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）数量词 ：X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
（6）简单应用 ：package org.westos.regex; import java.util.Scanner; /** * 需求:校验一个QQ号码 * 定义一个规则:1)由5到10为组成的数字 * 2)不能以0开头 * 分析: * 1)键盘录入一个QQ号码,使用字符串接收 * 2)定义一个校验QQ的功能 * 3)在main()中调用返回boolean类型 * @author Apple */ 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}"); } }
b. 校验手机号码：
String类中matches方法检测字符串是否匹配给定的正则表达式public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
str.matches("[1-9][0-9]{4,9}");package org.westos.regex_01; import java.util.Scanner; /** * 使用正则表达式校验手机号码: * 规则: * 手机号码: * 13689257284 * 13688886666 * 13892866555 * 18992844422 * 13257222222 * ... * *1)创建键盘录入对象,录入手机号码 *2)定义正则规则: *3)String类的特有功能 * public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。 *4)输出 * * @author Apple */ public class RegexDemo { 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); } }
c. 简单应用：（检验邮箱）d. 分割功能 ：package org.westos.regex_01; import java.util.Scanner; /** * 需求:校验邮箱: * QQ邮箱: * [email protected] * [email protected] * [email protected] * [email protected] * [email protected] * [email protected].... * 分析:1)键盘录入邮箱 * 2)定义正则规则 * 3)使用String中的特有功能校验 * 4)输出即可 * @author Apple */ 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); } }
（1）public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串（注意返回值是字符串数组，把分割后的多个子差存放起来）（2）应用//应用场景常出现在检索中 //例如给定字符串"18-24"需求是使用分割功能分离出检索的范围 String ages = "18-24"; String regex = "-"; //使用分割功能 String str[] = ages.split(regerx); //分割后的字符数组存放了18和24
package org.westos.regex_02; /** * 分割功能的应用: * @author Apple */ 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
e. 替换功能
（1）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); } }f. 模式和匹配器
package org.westos.regex_02; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * 关于模式和匹配器的使用:获取功能 * 模式和匹配器基本使用顺序 * @author Apple */ 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); } }
三.集合
1.Collection
a. 集合的由来： 我们学习java的语言,是一种面向对象语言,面向对象语言对事物的描述是通过对象体现出来的,那么存储很多个学生,就需要使用容器变量进行存储
b. 思考：集合和数组的区别?
1)长度的区别:
数组:长度是固定的;
集合:长度是可变的
2)存储数据类型的区别:
数组:可以存储引用类型,可以存储基本数据类型
集合:只能存储引用类型
3)存储元素的区别
数组:在同一个数组中,只能存储同一种数据类型的元素;举例 数组:杯子:只能装水
集合:可以 存储多种数据类型的元素; 举例:集合:杯子:装水,其他饮料...
d. Collection ：
表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现
e. 常用成员方法：
（1）添加功能:
boolean add(Object e):给集合中添加指定的元素
只要给集合中添加成功元素就返回true
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
iterator():迭代器
（6）转换功能:
Object[] toArray():将集合转换成数组
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); } }
f. 集合的高级功能 ：
g. 集合转换为数组：package org.westos.collection; import java.util.ArrayList; import java.util.Collection; / 集合的高级功能: boolean addAll(Collection c):添加一个集合中的所有元素 boolean removeAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除? boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有 boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思? @author Apple / 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); } }
Object[] toArray():将集合转换成数组
package org.westos.collection; import java.util.ArrayList; import java.util.Collection; /** * Object[] toArray():将集合转换成数组 * * 需求:给集合中添加String类型的元素,遍历集合 * @author Apple */ public class CollectionDemo3 { public static void main(String[] args) { //创建Collection集合对象 Collection c = new ArrayList() ; //给集合中添加元素 c.add("高圆圆") ;//c.add(Object obj)=====>Object obj = new String("高圆圆") ;//向上转型了 c.add("邓超") ; c.add("WE") ; c.add("RNG") ; //集合中有元素了,将集合转换数组 Object[] objs = c.toArray() ; //遍历对象数组 for(int x = 0 ; x < objs.length ; x ++){ // System.out.println(objs[x]); //需求:获取集合中元素的同时,获取集合中每一个元素的字符串长度 // System.out.println(objs[x]+"---"+objs[x].length()); //要获取字符串长度:需要使用length(),该方法属于String类的特有功能 String s = (String) objs[x] ;//向下转型 System.out.println(s+"----"+s.length()); } } }
i. 遍历方式 —— 迭代器
（1）集合的专有遍历方式:使用集合自己本身迭代功能遍历集合中的元素
Iterator iterator():迭代器
（2）常用方法：
Object next()返回迭代的下一个元素:获取功能
boolean hasNext():判断一个集合中是否有下一个可以迭代的元素:判断功能
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()); } } }
2.多重继承关系
3.List类
a. List list = new ArrayList();b. List集合是一个有序的集合(存储元素和取出元素是一致的!)(元素可以重复)c. 特有方法：
（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)用指定元素替换列表中指定位置的元素
public class ListDemo { public static void main(String[] args) { //创建List集合对象 List list = new ArrayList() ; //添加一些元素 list.add("hello") ; list.add("world") ; list.add("java") ; //void add(int index, Object element)在列表的指定位置插入指定元素,在指定位置前面插入一个新的元素 // list.add(1, "javaweb") ; //Object remove(int index)移除列表中指定位置的元素,返回被删除的元素 //IndexOutOfBoundsException:角标越界了 // System.out.println("remove:"+list.remove(3)); // System.out.println("remove:"+list.remove(2)); // set(int index,Object element)用指定元素替换列表中指定位置的元素 // System.out.println("set:"+list.set(1, "JavaEE")) ; System.out.println("get:"+list.get(1)) ; // System.out.println("get:"+list.get(11)) ; System.out.println("list"+list); } }
d. 遍历方式
（1）使用toArray()方法
（2）使用普通for的方法去遍历list集合,使用size()和get()相结合
（3）获取迭代器对象
package org.westos_02; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /** *List集合的遍历方式 * 1)toArray() * 2)Collection集合中的Iterator iterator(); * @author Apple */ public class ListDemo2 { 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") ; //获取集合中的元素 /* System.out.println(list.get(0)); System.out.println(list.get(1)); System.out.println(list.get(2)); System.out.println(list.get(3)); System.out.println(list.get(4)); System.out.println(list.get(5));*/ //使用普通for的方法去遍历list集合,使用size()和get()相结合 for(int x = 0 ; x < list.size(); x ++){ // Object object = list.get(x) ; //需求:获取字符串内容同时,获取字符串长度 String s = (String)list.get(x) ; 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()); } } }
e. 列表迭代器
a. 常用方法 ：
（1）boolean hasNext():判断是否有下一个可以迭代的元素(正向遍历)
（2）Object next():如果有可以遍历的元素,就获取这个元素
（3）boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)
（4）Object previous():如果有上一个可以迭代的元素,就获取上一个元素