1 BigInteger介绍

java.math.BigInteger类是一个引用数据类型，可以用来对一些大整数做运算。当超出基本数据类型数据范围的整数运算时就可以使用BigInteger了。

2 BigInteger API

构造方法 描述
BigInteger(String value) 可以将整数的字符串，转换为BigInteger对象


方法声明 描述
public BigInteger add (BigInteger value) 超大整数加法运算
public BigInteger subtract (BigInteger value) 超大整数减法运算
public BigInteger multiply (BigInteger value) 超大整数乘法运算
public BigInteger divide (BigInteger value) 超大整数除法运算，除不尽取整数部分

BigInteger的功能：
可以对大整数进行运算

BigInteger的加，减，乘，除的方法名：
add, subtract, multiply, divide

BigDecimal介绍：

java.math.BigDecimal可以对大浮点数进行运算，保证运算的准确性。float，double 他们在存储及运算的时候，会导致数据精度的丢失。如果要保证运算的准确性，就需要使用BigDecimal。

构造方法名 描述
BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal
方法声明 描述
public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算(除不尽会有异常)
public BigDecimal divide(BigDecimal divisor, int roundingMode) 除法运算(除不尽，使用该方法)
参数说明：
scale 精确位数，
roundingMode取舍模式
BigDecimal.ROUND_HALF_UP 四舍五入
BigDecimal.ROUND_FLOOR 去尾法
BigDecimal.ROUND_UP 进一法

BigDecimal的功能：
可以对大小数进行运算,精度不丢失

BigDecimal的加，减，乘，除的方法名：
add, subtract ,multiply, divide

1 Arrays类介绍
java.util.Arrays是数组的工具类，里面有很多静态的方法用来对数组进行操作（如排序和搜索），还包含一个静态工厂，可以将数组转换为List集合

2 Arrays的方法使用

方法 功能描述
public static void sort(int[] a) 按照数字顺序排列指定的数组
public static String toString(int[] a) 返回指定数组的内容的字符串表示形式

3 代码实践
随机生成10个[0,100]之间的整数，放到整数数组中，按照从小到大的顺序排序并打印元素内容。

Arrays 功能：
是数组的工具类，里面有很多静态的方法用来对数组进行操作（如排序和搜索），还包含一个静态工厂，可以将数组转换为List集合

Arrays的sort和toString 功能：
sort 可以对数组进行排序
toString 可以将数组转换为字符串来表示

包装类

包装类的作用 :
1 Java中的基本数据类型没有方法和属性，而包装类就是为了让基本数据类型拥有方法和属性，实现对象化交互。
2 字符串和基本数据类型做转换

包装类-数据类型的转换基本数据类型与字符串的转换：
在开发过程中数据在不同平台之间传输时都以字符串形式存在的，有些数据表示的是数值含义，如果要用于计算我们就需要将其转换基本数据类型.
例如:把一个字符串转成基本数据类型 , 或者把基本数据类型转成字符串 **

基本数据类型转换为字符串

1.直接在数值后加一个空字符串
2.通过String类静态方法valueOf()

字符串转换为基本数据类型
1.包装类型除了Character之外，都存在一个静态方法：parseXxxx
如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常

包装类的parseXxx方法
public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

包装类型小结

int和char对应的包装类型名字:
Integer，Character

将基本数据类型转换为字符串:
1.直接拼接空字符串
2.使用String的valueOf静态方法

将字符串转换为基本数据类型:
除了Character之外，都有静态方法parseXxx方法可以完成字符串转换基本数据类型。

字符串拼接 public String concat (String str) 将当前字符串与参数字符串进行“拼接”，返回一个新字符串。等效于加号拼接
字符串判断 public boolean contains (CharSequence s) 判断参数字符串在当前字符串中是否存在(区分大小写)，存在返回true。
public boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾(区分大小写)。
public boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始(区分大小写)
public int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。如果不包含，则返回-1.
public int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。 如果不包含，则返回-1.
替换截取 public String replace(CharSequence target,CharSequence replacement) 将与字面目标序列匹配的字符串的每个子字符串替换为指定的文字替换序列。
public String substring(int beginIndex) 将当前字符串从beginIndex开始截取到末尾。
public String substring(int beginIndex, int endIndex) 将当前字符串从beginIndex开始截取到endIndex - 1处。（包头，不包尾）
字符串转换 public char[] toCharArray() 将当前字符串转换为char[]数组。
public char charAt(int index) 将字符串中指定索引的字符获取
public String toLowerCase() 将当前字符串中的所有英文字符转换为小写，并返回一个转换后的新字符串，原字符串不变。
public String toUpperCase() 将当前字符串中的所有英文字符转换为大写，并返回一个转换后的新字符串，原字符串不变。
前后空格去除 public String trim() 去掉当前字符串的前后空格（空字符，制表符，换行符等），并返回一个新字符串，原字符串不变。
字符串的切割 public String[] split(String regex) 切割字符串——将字符串以regex作为分隔符进行切割。

字符串拼接功能
Concat

字符串判断功能
contains，endsWith，startsWith，indexOf,lastIndexOf

字符串替换截取
replace, subString
toCharArray,charAt, toLowerCase,toUpperCase

字符串去前后空格
Trim

字符串切割功能
split

LocalDateTime获取功能

public int getYear() 获取年
public int getMonthValue() 获取月份（1-12）
public int getDayOfMonth() 获取月份中的第几天（1-31）
public int getDayOfYear() 获取一年中的第几天（1-366）
public DayOfWeek getDayOfWeek() 获取星期
public int getMinute() 获取分钟
public int getHour() 获取小时

时间的增加或减少

public LocalDateTime plusYears (long years) 添加或者减去年
public LocalDateTime plusMonths(long months) 添加或者减去月
public LocalDateTime plusDays(long days) 添加或者减去日
public LocalDateTime plusHours(long hours) 添加或者减去时
public LocalDateTime plusMinutes(long minutes) 添加或者减去分
public LocalDateTime plusSeconds(long seconds) 添加或者减去秒
public LocalDateTime plusWeeks(long weeks) 添加或者减去周

时间的修改
public LocalDateTime withYear(int year) 直接修改年
public LocalDateTime withMonth(int month) 直接修改月
public LocalDateTime withDayOfMonth(int dayofmonth) 直接修改日期(一个月中的第几天)
public LocalDateTime withDayOfYear(int dayOfYear) 直接修改日期(一年中的第几天)
public LocalDateTime withHour(int hour) 直接修改小时
public LocalDateTime withMinute(int minute) 直接修改分钟
public LocalDateTime withSecond(int second) 直接修改秒

LocalDateTime格式化和解析

public String format (日期格式化器对象)
把一个LocalDateTime格式化成为一个字符串
public static LocalDateTime parse (准备解析的字符串, 日期格式化器对象)
把一个日期字符串解析成为一个LocalDateTime对象
public static DateTimeFormatter ofPattern(String pattern)
使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象

Period日期间隔类

public static Period between(开始时间,结束时间) 计算两个“时间”的间隔
public int getYears() 获得这段时间的年数
public int getMonths() 获得此期间的总月数
public int getDays() 获得此期间的天数
Duration时间间隔类

public static Duration between(开始时间,结束时间) 计算两个“时间”的间隔
public long toDays() 两个时间差的天数public long toHours() 两个时间差的小时数
public long toMinutes() 两个时间差的分钟数
public long toMillis() 两个时间差的毫秒数**

正则表达式

正则表达式概述：
正则表达式通常用来校验，检查字符串是否符合规则的。
例如 : 在一些数据录入的场景中要求年龄必须是2位的数字;
用户名必须是8位长度而且只能包含大小写字母 ; 手机号码的合法性 ; QQ号码的合法性等

正则表达式的作用
正则表达式通常用来校验，检查字符串用的。

如何用正则表达式表示一个字符类？
中括号表示表示一个字符

任意字符，数字字符，空白字符，单词字符对应的预定义字符是哪些？
“.” ： 匹配任何字符
“\d”：任何数字[0-9]的简写；
“\s”： 空白字符：[ \t\n\x0B\f\r] 的简写
“\w”：单词字符：[a-zA-Z_0-9]的简写

请说出 ? * + {n} {n,} {m,n}表达
X? : 0次或1次
X* : 0次到多次
X+ : 1次或多次
X{n} : 恰好n次
X{n,} : 至少n次
X{n,m}: n到m次(n和m都是包含的)

Collection
集合概述：
我们之前所学的ArrayList就是集合，集合就是一种能够存储多个数据的容器。常见的容器有集合和数组。
集合和数组有什么区别呢？
集合长度可变，数组长度不可变。
集合可以只能存储引用数据类型（如果要存储基本数据类型需要进行装箱），数组可以存储基本数据类型也可以存储引用数据类型(对象数组)
2 集合的分类
集合有两大分类：
Collection集合（今天学习）
Map集合（后面学习）
我们此前所学ArrayList就是Collection集合的一种实现。

3 Collection集合继承体系

在学习集合体系，一般先学习顶层接口。学习了顶层接口的方法，子类型继承而来的方法，就可以不用重复学习。

Collection-常用方法

public boolean add(E e)： 把给定的对象添加到当前集合中 。public void clear() :清空集合中所有的元素。public boolean remove(E e): 把给定的对象在当前集合中删除。public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。public boolean isEmpty(): 判断当前集合是否为空。public int size(): 返回集合中元素的个数。public Object[] toArray(): 把集合中的元素，存储到数组中

java.util.Collection是集合的顶层类型，而且是一个接口，我们不能直接对Collection类型进行实例化，我们可以借助之前我们所学的ArrayList进行实例化。

Collection的继承体系

Collection 接口
|—List —- 子接口
|—ArrayList
|—LinkedList
|—Vector
|—Set —- 子接口
|—HashSet
|—LinkedHashSet
|—TreeSet
Collection中有常用的方法：
add,clear,remove,contains,isEmpty,size,toArray

时间提取
//获取现在时间简化输出，并且可以单独提年月日出来。
public class ArraysDemo { public static void main(String[] args) { LocalDateTime now = LocalDateTime.now(); System.out.println(now); int yaer=now.getYear()；//get写什么输出的就是什么！
System.out.println(yaer); //单独提出来当前年输出
}}
 计算时间差 LocalDateTime.of**

public class Demo01 { public static void main(String[] args) { LocalDateTime start=LocalDateTime.now(); System.out.println(start); //输出现在时间 LocalDateTime end=LocalDateTime.of(2050,3,4,9,12,50); System.out.println(end); //输出指定格式设定时间 Duration v=Duration.between(start,end); //设定开始和结束时间！ System.out.println(v.toDays()); //指定时间与现在时间相差天数 System.out.println(v.toHours()); //指定时间与现在时间相差小时数 System.out.println(v.toMinutes()); //指定时间与现在时间相差分钟数 }}**

随机生成字符串 并进行有序排序

public class ArraysDemo { public static void main(String[] args) { int []arr=new int [10]; Random rd=new Random(); //10-100=[0-90]+10 // arr[0]= rd.nextInt(91)+10; for (int i = 0; i < arr.length; i++) { arr[i]=rd.nextInt(91)+10; } //集合数组 利用toString 打印数组 System.out.println(Arrays.toString(arr)); //[96, 30, 54, 12, 34, 20, 81, 100, 74, 57] //从小到大排序arr数组中的随机数 Arrays.sort(arr); System.out.println(Arrays.toString(arr)); //[12, 20, 30, 34, 54, 57, 74, 81, 96, 100] }}
大整数数值计算 Biginteger
public class Demo03 { public static void main(String[] args) { String num=”10”; BigInteger b1=new BigInteger(num); BigInteger b2=new BigInteger(“2”); BigInteger add = b1.add(b2);//加 System.out.println(“add = “ + add); BigInteger subtract = b1.subtract(b2);//减 System.out.println(“subtract = “ + subtract); BigInteger multiply = b1.multiply(b2);//乘法 System.out.println(“multiply = “ + multiply); BigInteger divide = b1.divide(b2); System.out.println(“divide = “ + divide);//除法 // BigInteger divide1 = b1.divide(b2, 3, BigDecimal.ROUND_UP);错误格式 //高精度大整数数值计算 BigDecilmal BigDecimal v1=new BigDecimal(“200”); BigDecimal v2=new BigDecimal(“100”); BigDecimal divide1 = v1.divide(v2, 3, BigDecimal.ROUND_UP); System.out.println(“divide1 = “ + divide1);// }}
基本数据类型转字符串

public class IntegerDemo { public static void main(String[] args) { Integer i1=100;//装箱 int i2=i1;//拆箱** String a1=100+””;//基本数据类型转字符串 String s = String.valueOf(100);//valueof方法转换** String s3=”1000”; int S3=Integer.parseInt(s3); System.out.println(“S3 = “ + S3);** String s4=”1000”; double v = Double.parseDouble(s4); System.out.println(“v = “ + v); }}**

集合数组的API方法类
public class Demo { public static void main(String[] args) { Collectioncollection=new ArrayList<>(); collection.add(“欧克11”); collection.add(“欧克22”); collection.add(“欧克33”); collection.add(“欧克44”); System.out.println(“collection = “ + collection); //删除remove System.out.println(collection.remove(“欧克11”)); System.out.println(“collection = “ + collection); System.out.println(collection.isEmpty());//false 不是空的 如果是空的就是true System.out.println(collection.size());//集合内剩余几个数值 }}

替换 截取 判断 计算次数
String 类型字符串的方法API

public class StringDemo1 { public static void main(String[] args) { String str = “I Love Java, I Love Heima”; // 判断是否存在 “Java” //区分大小写！ boolean java = str.contains(“Java”); System.out.println(“java = “ + java); //判断是否以Heima字符串结尾 boolean p = str.endsWith(“Heima”); System.out.println(“p = “ + p); //判断 Java在字符串中的第一次出现位置 int love = str.indexOf(“Love”); System.out.println(“love = “ + love); System.out.println(str.indexOf(“love”));//直接输出方法 //判断 love 最后一次出现的位置 System.out.println(str.lastIndexOf(“Love”)); //将所有LOVE替换like System.out.println(str.replace(“Love”, “Nike”)); //截取字符串“I love heima” System.out.println(str.substring(13)); //截取字符java System.out.println(str.substring(7, 11)); //计算字符a出现的次数（使用tocharArray） int count=0; char[] chars = str.toCharArray(); for (int i = 0; i <chars.length ; i++) { if(‘a’==chars[i]){ count++; } } System.out.println(“ a 出现了：”+count+”次！”); //字符串字母变大写 System.out.println(str.toUpperCase(Locale.ROOT)); //字符串字母变小写 System.out.println(str.toLowerCase());** }}**

逻辑运算符

public class RegexDemo2 { public static void main(String[] args) { String s=”hod”; //验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符 System.out.println(s.matches(“h[aeiou]d”)); // 验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符 System.out.println(s.matches(“h[^aeiou]d”)); // 验证str是否a-z的任何一个小写字符开头，后跟ad System.out.println(s.matches(“[a-z]ad”)); //验证str是否以a-d或者m-p之间某个字符开头，后跟ad System.out.println(“aad”.matches(“[a-dm-p]ad”)); System.out.println(“had”.matches(“[a-dm-p]ad”)); // 运算符： // 1.&& 并且 // 2. | 或者 // 要求字符串是除a、e、i、o、u外的其它小写字符开头，后跟ad System.out.println(“aad”.matches(“[a-z&&[^aeiou]]ad”)); System.out.println(“had”.matches(“[a-z&&[^aeiou]]ad”)); // 要求字符串是aeiou中的某个字符开头，后跟ad System.out.println(“had”.matches(“ [a|e|i|o|u]ad”));** }}**

正则表达式数量词

public class RegexDemo5 { public static void main(String[] args) {// 验证str是否3位数字 System.out.println(“143”.matches(“\d{3}”));// 验证str是否是手机号 ( 1开头，第二位：3/5/8，剩下9位都是0-9的数字) System.out.println(“15649103930”.matches(“1[358]\d{9}”));// 验证qq号码：1).5—15位；2).全部是数字;3).第一位不是0 System.out.println(“447528616”.matches(“[1-9]\d{4,14}”)); }}**

数量词 :- X? : 0次或1次- X* : 0次到多次- X+ : 1次或多次- X{n} : 恰好n次- X{n,} : 至少n次- X{n,m}: n到m次(n和m都是包含的)
预定义字符 : 简化字符类的书写
**格式：“字符”.matchse（“判断条件”）.var
**”.” ：匹配任何字符。
“\d” ：任何数字[0-9]的简写
“\D” ：任何非数字[^0-9]的简写
“\s” ：空白字符：[\t\n\x0B\f\r] 的简写
“\S” ：非空白字符：[^\s] 的简写
“\w” ：单词字符：[a-zA-Z_0-9]的简写
“\W” ：非单词字符：[^\w]

正则表达式表示一个字符类： 中括号表示 表示一个字符！
java中\本身是一个转义字符，是一个特殊字符在java层面将 \ 变成普通字符就是：\
所以一般表达都是\D, \d, \s …..。**

Ctrl+F \d + .* 搜索所有数字
Ctrl+F \w + .* 搜索所有字母

集合和数值： 集合长度可以改变 数组长度不能改变
集合只能存储引用类型，数组可以使用任意类型定义，并存储对应数据的类型。

迭代器的使用
迭代器是对iterator的称呼，专门用来对Collection 集合进行遍历使用，学习迭代器就是为了遍历集合。

迭代器只能使用一次，如果要再次使用需要再次定义！

注意事项：
当迭代器迭代元素完成后，不能继续next获取元素，否则会报错。
迭代器使用过程中，不能使用集合对象直接增删元素，否则会报错 如果非要删除可以使用迭代器来删除！

迭代器的使用有俩个重要的接口，Iterable，Iterator。

迭代器的使用步骤：
1.先获取获取迭代器对象
2.使用迭代器对象调用hasNext（），判断是否存在下一个元素
3.如果有调用next（）方法，获取下一个元素
4.循环2，3，步骤，知道hasNext方法返回为止！
Iterator iterator = collection.iterator();//已定义的集合while (iterator.hasNext()){ String next=iterator.next(); System.out.println(next);}

增强for循环
概述:
增强for循环（foreach），专门来遍历单列集合或者数组，底层实现使用迭代器。

定义格式：
for（变量类型 变量：数值/集合）{
变量代表的就是集合或者数组的元素
}
快捷键 ： 数组名/集合名.for

int[] arr = {11, 22, 33, 44, 55};
for (int i : arr) {
System.out.println(“i = “ + i);
}

day04-常用API,正则表达式,Collection集合

今日目标

  • BigInteger类
  • BigDecimal类
  • Arrays类
  • 包装类
  • String类的常用方法
  • 正则表达式
  • Collection集合

1 BigInteger类

1.1 概述

  • 概述 : java.math.BigInteger类是一个引用数据类型 , 可以用于计算一些大的整数 , 当超出基本数据类型数据范围的整数运算时就可以使用BigInteger了。

1.2 构造方法

  • 构造方法 : 可以将整数的字符串 . 转成BigInteger类型的对象

1.3 成员方法

  • | 方法声明 | 描述 | | —- | —- | | public BigInteger add (BigInteger value) | 超大整数加法运算 | | public BigInteger subtract (BigInteger value) | 超大整数减法运算 | | public BigInteger multiply (BigInteger value) | 超大整数乘法运算 | | public BigInteger divide (BigInteger value) | 超大整数除法运算，除不尽取整数部分 |
  1. package com.itheima.api_demo.biginteger_demo;
  3. import java.math.BigInteger;
  5. /*
  6.     构造方法 :
  7.         BigInteger(String value)    可以将整数的字符串，转换为BigInteger对象
  8.     成员方法 :
  9.         public BigInteger add (BigInteger value)        超大整数加法运算
  10.         public BigInteger subtract (BigInteger value)    超大整数减法运算
  11.         public BigInteger multiply (BigInteger value)    超大整数乘法运算
  12.         public BigInteger divide (BigInteger value)    超大整数除法运算，除不尽取整数部分
  14.  */
  15. public class BigIntegerDemo {
  16.     public static void main(String[] args) {
  17.         // 获取大整数对象
  18.         BigInteger bigInteger1 = new BigInteger("2147483648");
  19.         // 获取大整数对象
  20.         BigInteger bigInteger2 = new BigInteger("2");
  21.         // public BigInteger add (BigInteger value)        超大整数加法运算
  22.         BigInteger add = bigInteger1.add(bigInteger2);
  23.         System.out.println(add);
  25.         System.out.println("=============");
  27.         // public BigInteger subtract (BigInteger value)    超大整数减法运算
  28.         BigInteger subtract = bigInteger1.subtract(bigInteger2);
  29.         System.out.println(subtract);
  31.         System.out.println("=============");
  33.         // public BigInteger multiply (BigInteger value)    超大整数乘法运算
  34.         BigInteger multiply = bigInteger1.multiply(bigInteger2);
  35.         System.out.println(multiply);
  37.         System.out.println("=============");
  38.         // public BigInteger divide (BigInteger value)    超大整数除法运算，除不尽取整数部分
  39.         BigInteger divide = bigInteger1.divide(bigInteger2);
  40.         System.out.println(divide);
  41.     }
  42. }

2 BigDecimal类

2.1 概述

  • 概述 : java.math.BigDecimal可以对大浮点数进行运算，保证运算的准确性。float，double 他们在存储及运算的时候，会导致数据精度的丢失。如果要保证运算的准确性，就需要使用BigDecimal。

2.2 构造方法

  • 构造方法 :
    • public BigDecimal(String val) : 将 BigDecimal 的字符串表示形式转换为 BigDecimal

2.3 成员方法

  • 成员方法 :
    • | 方法声明 | 描述 | | —- | —- | | public BigDecimal add(BigDecimal value) | 加法运算 | | public BigDecimal subtract(BigDecimal value) | 减法运算 | | public BigDecimal multiply(BigDecimal value) | 乘法运算 | | public BigDecimal divide(BigDecimal value) | 除法运算(除不尽会有异常) | | public BigDecimal divide(BigDecimal divisor, int roundingMode) | 除法运算(除不尽，使用该方法)参数说明：scale 精确位数，roundingMode取舍模式 BigDecimal.ROUND_HALF_UP 四舍五入 BigDecimal.ROUND_FLOOR 去尾法 BigDecimal.ROUND_UP 进一法 |
  1. package com.itheima.api_demo.bigdecimal_demo;
  3. import java.math.BigDecimal;
  5. /*
  6.     构造方法 :
  7.         public BigDecimal(String val)    将 BigDecimal 的字符串表示形式转换为 BigDecimal
  8.     成员方法 :
  9.         public BigDecimal add(BigDecimal value)    加法运算
  10.         public BigDecimal subtract(BigDecimal value)    减法运算
  11.         public BigDecimal multiply(BigDecimal value)    乘法运算
  12.         public BigDecimal divide(BigDecimal value)    除法运算(除不尽会有异常)
  13.         public BigDecimal divide(BigDecimal value, int scale, RoundingMode roundingMode)    除法运算(除不尽，使用该方法)
  14.         参数说明：
  15.         scale 精确位数，
  16.         roundingMode取舍模式
  17.                    BigDecimal.ROUND_HALF_UP 四舍五入
  18.                    BigDecimal.ROUND_FLOOR 去尾法
  19.                    BigDecimal.ROUND_UP  进一法
  20.  */
  21. public class BigDecimalDemo {
  22.     public static void main(String[] args) {
  23.         BigDecimal bigDecimal1 = new BigDecimal("0.1");
  24.         BigDecimal bigDecimal2 = new BigDecimal("0.2");
  26.         // public BigDecimal add(BigDecimal value)    加法运算
  27.         BigDecimal add = bigDecimal1.add(bigDecimal2);
  28.         System.out.println(add);
  30.         System.out.println("=================");
  32.         // public BigDecimal subtract(BigDecimal value)    减法运算
  33.         BigDecimal subtract = bigDecimal1.subtract(bigDecimal2);
  34.         System.out.println(subtract);
  36.         System.out.println("=================");
  38.         // public BigDecimal multiply(BigDecimal value)    乘法运算
  39.         BigDecimal multiply = bigDecimal1.multiply(bigDecimal2);
  40.         System.out.println(multiply);
  42.         System.out.println("=================");
  44.         // public BigDecimal divide(BigDecimal value)    除法运算(除不尽会有异常)
  45.         // BigDecimal divide = bigDecimal1.divide(bigDecimal2);
  46.         // System.out.println(divide);
  48.         /*
  49.             public BigDecimal divide(BigDecimal divisor, int roundingMode)    除法运算(除不尽，使用该方法)
  50.             参数说明：
  51.             scale 精确位数，
  52.             roundingMode : 取舍模式
  53.                        BigDecimal.ROUND_HALF_UP 四舍五入
  54.                        BigDecimal.ROUND_FLOOR 去尾法
  55.                        BigDecimal.ROUND_UP  进一法
  56.         */
  58.         // BigDecimal divide = bigDecimal1.divide(bigDecimal2, 3, BigDecimal.ROUND_HALF_UP);
  59.         // BigDecimal divide = bigDecimal1.divide(bigDecimal2, 3, BigDecimal.ROUND_FLOOR);
  60.         // BigDecimal divide = bigDecimal1.divide(bigDecimal2, 3, BigDecimal.ROUND_UP);
  61.         // System.out.println(divide);
  63.     }
  64. }

3 Arrays类

3.1 概述

  • 概述 : java.util.Arrays是数组的工具类，里面有很多静态的方法用来对数组进行操作（如排序和搜索），还包含一个静态工厂，可以将数组转换为List集合（后面会讲到集合知识

3.2 构造方法

  • 构造方法 : private Arrays(){}
  • | public static void sort(int[] a) | 按照数字顺序排列指定的数组 | | —- | —- | | public static String toString(int[] a) | 返回指定数组的内容的字符串表示形式 |
  1. package com.itheima.api_demo.arrays_demo;
  3. import java.util.Arrays;
  4. import java.util.Random;
  6. /*
  7.     1 随机生成10个[0,100]之间的整数，放到整数数组中，按照从小到大的顺序排序并打印元素内容。
  8.  */
  9. public class ArraysDemo {
  10.     public static void main(String[] args) {
  11.         // 创建数组
  12.         int[] arr = new int[10];
  14.         // 创建随机数对象
  15.         Random r = new Random();
  17.         // 采用随机数给数组的每一个元素赋值
  18.         for (int i = 0; i < arr.length; i++) {
  19.             arr[i] = r.nextInt(101);
  20.         }
  22.         // 对数组进行排序
  23.         Arrays.sort(arr);
  25.         // 把数组转成指定格式的字符串
  26.         System.out.println(Arrays.toString(arr));
  27.     }
  28. }

4 包装类

4.1 概述

  • 概述 :
    • Java中基本数据类型对应的引用数据类型

4.2 包装类的作用

  • 包装类的作用 :
    • 基本数据类型 , 没有变量 , 没有方法 , 包装类就是让基本数据类型拥有变量和属性 , 实现对象化交互
    • 基本数据类型和字符串之间的转换

4.3 基本数据类型和包装类对应

  • 基本数据类型和包装类的对应关系
    | 基本数据类型 | 包装类型 | | —- | —- | | byte | Byte | | short | Short | | int | Integer | | long | Long | | float | Float | | double | Double | | char | Character | | boolean | Boolean |

4.4 自动装箱和自动拆箱

  • 自动转型和自动拆箱
    • 自动装箱和拆箱是JDK1.5开始的
    • 自动装箱 : 基本数据类型自动转成对应的包装类类型
    • 自动拆箱 : 包装类类型自动转成对应的基本数据类型
      1. Integer i1 = 10;
      2. int i2 = i1;

4.5 基本数据类型和字符串之间的转换

  • 使用包装类, 对基本数据类型和字符串之间的转换

    • 在开发过程中数据在不同平台之间传输时都以字符串形式存在的，有些数据表示的是数值含义，如果要用于计算我们就需要将其转换基本数据类型.
    • 基本数据类型—> String
      • 直接在数值后加一个空字符串
      • 通过String类静态方法valueOf()
    • String —> 基本数据类型
      • | public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。 | | —- | | public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。 | | public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。 | | public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。 | | public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。 | | public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。 | | public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。 |

  • 注意事项 :

    • 包装类对象的初始值为null（是一个对象）
    • Java中除了float和double的其他基本数据类型，都有常量池
      • 整数类型：[-128,127]值在常量池
      • 字符类型：[0,127]对应的字符在常量池
      • 布尔类型：true，false在常量池
    • 在常量池中的数据 , 会进行共享使用 , 不在常量池中的数据会创建一个新的对象

5 String类的常用方法

5.1 常用方法

image-20210404212729376

  1. package com.itheima.api_demo.string_demo;
  3. /*
  4.     已知字符串，完成需求
  5.     String str = "I Love Java, I Love Heima";
  6.     判断是否存在  “Java”
  7.     判断是否以Heima字符串结尾
  8.     判断是否以Java开头
  9.     判断 Java在字符串中的第一次出现位置
  10.     判断  itcast 所在的位置
  12.  */
  13. public class Test {
  14.     public static void main(String[] args) {
  15.         String str = "I Love Java, I Love Heima";
  17.         // 判断是否存在  “Java”
  18.         System.out.println(str.contains("Java"));// true
  20.         // 判断是否以Heima字符串结尾
  21.         System.out.println(str.endsWith("Heima"));// true
  23.         // 判断是否以Java开头
  24.         System.out.println(str.startsWith("Java"));// false
  26.         // 判断 Java在字符串中的第一次出现位置
  27.         System.out.println(str.indexOf("Java"));// 7
  29.         // 判断  itcast 所在的位置
  30.         System.out.println(str.indexOf("itcast"));// -1
  31.     }
  32. }
  1. package com.itheima.api_demo.string_demo;
  3. /*
  4.     已知字符串，完成右侧需求
  5.     String str = "I Love Java, I Love Heima";
  6.     需求：
  7.     1.将所有 Love 替换为 Like ,打印替换后的新字符串
  8.     2.截取字符串 "I Love Heima"
  9.     3.截取字符串 "Java"
  11.  */
  12. public class Test2 {
  13.     public static void main(String[] args) {
  14.         String str = "I Love Java, I Love Heima";
  16.         // 1.将所有 Love 替换为 Like ,打印替换后的新字符串
  17.         System.out.println(str.replace("Love", "Like"));
  18.         // 2.截取字符串 "I Love Heima"
  19.         System.out.println(str.substring(13));
  20.         // 3.截取字符串 "Java"
  21.         System.out.println(str.substring(7 , 11));
  23.     }
  24. }
  1. package com.itheima.api_demo.string_demo;
  3. /*
  4.     已知字符串，完成右侧需求
  5.     String str = "I Love Java, I Love Heima";
  6.     需求：
  7.     1 计算字符 a 出现的次数（要求使用toCharArray）
  8.     2 计算字符 a 出现的次数（要求使用charAt）
  9.     3 将字符串中所有英文字母变成小写
  10.     4 将字符串中所有英文字母变成大写
  13.  */
  14. public class Test3 {
  15.     public static void main(String[] args) {
  16.         String str = "I Love Java, I Love Heima";
  18. //        1 计算字符 a 出现的次数（要求使用toCharArray）
  19.         int count1 = 0;
  20.         char[] chars = str.toCharArray();
  21.         for (int i = 0; i < chars.length; i++) {
  22.             if (chars[i] == 'a') {
  23.                 count1++;
  24.             }
  25.         }
  26.         System.out.println("字符a出现了" + count1 + "次");
  29. //        2 计算字符 a 出现的次数（要求使用charAt）
  30.         int count2 = 0;
  31.         for (int i = 0; i < str.length(); i++) {
  32.             char ch = str.charAt(i);
  33.             if(ch == 'a'){
  34.                 count2++;
  35.             }
  36.         }
  37.         System.out.println("字符a出现了" + count2 + "次");
  39. //        3 将字符串中所有英文字母变成小写
  40.         String s1 = str.toLowerCase();
  41.         System.out.println(s1);
  43. //        4 将字符串中所有英文字母变成大写
  44.         String s2 = str.toUpperCase();
  45.         System.out.println(s2);
  46.     }
  47. }

6 正则表达式

6.1 概述 :

  • 正则表达式通常用来校验，检查字符串是否符合规则的

6.2 体验正则表达式

  1. package com.itheima.regex_demo;
  3. import java.util.Scanner;
  5. /*
  6.     设计程序让用户输入一个QQ号码，验证QQ号的合法性：
  7.     1. QQ号码必须是5--15位长度
  8.     2. 而且首位不能为0
  9.     3. 而且必须全部是数字
  11.  */
  12. public class Test1 {
  13.     public static void main(String[] args) {
  14.         Scanner sc = new Scanner(System.in);
  16.         System.out.println("请输入您的qq号码:");
  17.         String qq = sc.nextLine();
  19.         System.out.println(checkQQ2(qq));
  21.     }
  23.     private static boolean checkQQ(String qq) {
  24. //        1. QQ号码必须是5--15位长度
  25.         if (qq.length() < 5 || qq.length() > 15) {
  26.             return false;
  27.         }
  28. //       2 . 而且首位不能为0
  29.         if (qq.charAt(0) == '0') {
  30.             return false;
  31.         }
  33. //        2. 而且必须全部是数字
  34.         for (int i = 0; i < qq.length(); i++) {
  35.             char ch = qq.charAt(i);
  36.             if (ch < '0' || ch > '9') {
  37.                 return false;
  38.             }
  39.         }
  41.         return true;
  42.     }
  44.     // 正则表达式改进
  45.     private static boolean checkQQ2(String qq) {
  46.         return qq.matches("[1-9][0-9]{4,14}");
  47.     }
  48. }

6.3 正则表达式的语法

  • boolean matches（正则表达式） :如果匹配正则表达式就返回true，否则返回false
    • boolean matches（正则表达式） :如果匹配正则表达式就返回true，否则返回false

  • 字符类
    • [abc] ：代表a或者b，或者c字符中的一个。
    • [^abc]：代表除a,b,c以外的任何字符。
    • [a-z] ：代表a-z的所有小写字符中的一个。
    • [A-Z] ：代表A-Z的所有大写字符中的一个。
    • [0-9] ：代表0-9之间的某一个数字字符。
    • [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
    • [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符
  1. package com.itheima.regex_demo;
  2. /*
  3.     字符类 : 方括号被用于指定字符
  4.     [abc] ：代表a或者b，或者c字符中的一个。
  5.     [^abc]：代表除a,b,c以外的任何字符。
  6.     [a-z] ：代表a-z的所有小写字符中的一个。
  7.     [A-Z] ：代表A-Z的所有大写字符中的一个。
  8.     [0-9] ：代表0-9之间的某一个数字字符。
  9.     [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
  10.     [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符
  12.     需求 :
  13.     1 验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
  14.     2 验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符
  15.     3 验证str是否a-z的任何一个小写字符开头，后跟ad
  16.     4 验证str是否以a-d或者m-p之间某个字符开头，后跟ad
  17.     注意: boolean  matches（正则表达式） :如果匹配正则表达式就返回true，否则返回false
  18.  */
  19. public class RegexDemo {
  20.     public static void main(String[] args) {
  21. //        1 验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
  22.         System.out.println("had".matches("h[aeiou]d"));
  24. //        2 验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符
  25.         System.out.println("hwd".matches("h[^aeiou]d"));
  27. //        3 验证str是否a-z的任何一个小写字符开头，后跟ad
  28.         System.out.println("aad".matches("[a-z]ad"));
  30. //        4 验证str是否以a-d或者m-p之间某个字符开头，后跟ad
  31.         System.out.println("bad".matches("[a-dm-p]ad"));
  33.     }
  34. }

  • 逻辑运算符
    • && ：并且
    • | ：或者
  1. package com.itheima.regex_demo;
  2. /*
  3.     逻辑运算符 :
  4.         1 && : 并且
  5.         2 |  : 或者
  7.     需求 :
  8.         1 要求字符串是除a、e、i、o、u外的其它小写字符开头，后跟ad
  9.         2 要求字符串是aeiou中的某个字符开头，后跟ad
  10.  */
  11. public class RegexDemo2 {
  12.     public static void main(String[] args) {
  13. //        1 要求字符串是除a、e、i、o、u外的其它小写字符开头，后跟ad
  14.         System.out.println("vad".matches("[a-z&&[^aeiou]]ad"));
  15. //        2 要求字符串是aeiou中的某个字符开头，后跟ad
  16.         System.out.println("aad".matches("[a|e|i|o|u]ad"));
  17.     }
  18. }

  • 预定义字符类
    • “.” ： 匹配任何字符。
    • “\d”：任何数字[0-9]的简写；
    • “\D”：任何非数字[^0-9]的简写；
    • “\s” ： 空白字符：[ \t\n\x0B\f\r] 的简写
    • “\S” ： 非空白字符：[^\s] 的简写
    • “\w” ：单词字符：[a-zA-Z_0-9]的简写
    • “\W”：非单词字符：[^\w]
  1. package com.itheima.regex_demo;
  2. /*
  3.     预定义字符 : 简化字符类的书写
  5.     "."  ：匹配任何字符。
  6.     "\d" ：任何数字[0-9]的简写
  7.     "\D" ：任何非数字[^0-9]的简写
  8.     "\s" ：空白字符：[\t\n\x0B\f\r] 的简写
  9.     "\S" ：非空白字符：[^\s] 的简写
  10.     "\w" ：单词字符：[a-zA-Z_0-9]的简写
  11.     "\W" ：非单词字符：[^\w]
  13.     需求 :
  14.        1 验证str是否3位数字
  15.        2 验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字
  16.        3 验证字符串是否以h开头，以d结尾，中间是任何字符
  18.  */
  19. public class RegexDemo3 {
  20.     public static void main(String[] args) {
  21. //        1 验证str是否3位数字
  22.         System.out.println("123".matches("\\d\\d\\d"));
  24. //        2 验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字 ）
  25.         System.out.println("15188888888".matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));
  27. //        3 验证字符串是否以h开头，以d结尾，中间是任何字符
  28.         System.out.println("had".matches("h.d"));
  29.     }
  30. }

  • 数量词
    • X? : 0次或1次
    • X* : 0次到多次
    • X+ : 1次或多次
    • X{n} : 恰好n次
    • X{n,} : 至少n次
    • X{n,m}: n到m次(n和m都是包含的)
  1. package com.itheima.regex_demo;
  3. /*
  4.     数量词 :
  5.         - X?    : 0次或1次
  6.         - X*    : 0次到多次
  7.         - X+    : 1次或多次
  8.         - X{n}  : 恰好n次
  9.         - X{n,} : 至少n次
  10.         - X{n,m}: n到m次(n和m都是包含的)
  12.     需求 :
  13.       1 验证str是否3位数字
  14.       2 验证str是否是多位(大于等于1次)数字
  15.       3 验证str是否是手机号 ( 1开头，第二位：3/5/8，剩下9位都是0-9的数字)
  16.       4 验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0
  18.  */
  19. public class RegexDemo4 {
  20.     public static void main(String[] args) {
  21. //        1 验证str是否3位数字
  22.         System.out.println("123".matches("\\d{3}"));
  24. //        2 验证str是否是多位(大于等于1次)数字
  25.         System.out.println("123456".matches("\\d+"));
  27. //        3 验证str是否是手机号 ( 1开头，第二位：3/5/8，剩下9位都是0-9的数字)
  28.         System.out.println("15188888888".matches("1[358]\\d{9}"));
  30. //        4 验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0
  31.         System.out.println("122103987".matches("[1-9]\\d{4,14}"));
  32.     }
  33. }

  • 分组括号 :
    • 将要重复使用的正则用小括号括起来，当做一个小组看待
  1. package com.itheima.regex_demo;
  2. /*
  3.     分组括号 : 将要重复使用的正则用小括号括起来，当做一个小组看待
  4.     需求 :  window秘钥 , 分为5组，每组之间使用 - 隔开 , 每组由5位A-Z或者0-9的字符组成 , 最后一组没有 -
  5.     举例 :
  6.         xxxxx-xxxxx-xxxxx-xxxxx-xxxxx
  7.         DG8FV-B9TKY-FRT9J-99899-XPQ4G
  8.     分析：
  9.         前四组其一  ：DG8FV-    正则：[A-Z0-9]{5}-
  10.         最后一组    ：XPQ4G     正则：[A-Z0-9]{5}
  12.     结果 : ([A-Z0-9]{5}-){4}[A-Z0-9]{5}
  14.  */
  15. public class RegexDemo5 {
  16.     public static void main(String[] args) {
  17.         System.out.println("DG8FV-B9TKY-FRT9J-99899-XPQ4G".matches("([A-Z0-9]{5}-){4}[A-Z0-9]{5}"));
  18.     }
  19. }

  • 字符串中常用含有正则表达式的方法
    • public String[] split ( String regex ) 可以将当前字符串中匹配regex正则表达式的符号作为”分隔符”来切割字符串。
    • public String replaceAll ( String regex , String newStr ) 可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。
  1. package com.itheima.regex_demo;
  3. import java.util.Arrays;
  5. /*
  7.     1 字符串中常用含有正则表达式的方法
  8.         public String[] split ( String regex ) 可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。
  9.         public String replaceAll ( String regex , String newStr ) 可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。
  11.     需求:
  12.         1 将以下字符串按照数字进行切割
  13.         String str1 = "aa123bb234cc909dd";
  15.         2 将下面字符串中的"数字"替换为"*“a
  16.         String str2 = "我卡里有100000元，我告诉你卡的密码是123456，要保密哦";
  18.  */
  19. public class RegexDemo6 {
  20.     public static void main(String[] args) {
  21.         // 1 将以下字符串按照数字进行切割
  22.         String str1 =  "aa123bb234cc909dd";
  23.         String[] strs = str1.split("\\d+");
  24.         System.out.println(Arrays.toString(strs));
  26.         // 2 将下面字符串中的"数字"替换为"*“a
  27.         String str2 = "我卡里有100000元，我告诉你卡的密码是123456，要保密哦";
  28.         System.out.println(str2.replaceAll("\\d+" , "*"));
  29.     }
  30. }

7 引用数据类型使用

7.1 使用方式

  1. - 基本数据类型可以当做方法的参数，返回值及成员变量使用，传递或者保存的是数据值。
  2. - 引用数据类型也可以当做方法的参数，返回值及字段使用，传递或者保存的是对象的引用（地址）。
  3. - 特别要注意，如果是抽象类或者接口那么传递或者保存的就是子类对象的地址引用了
  1. package com.itheima.datatype_demo;
  4. public interface Player {
  5.     public abstract void play();
  6. }
  8. abstract class Mp3Player implements Player {
  10. }
  12. class IPod extends Mp3Player {
  13.     @Override
  14.     public void play() {
  15.         System.out.println("IPod播放音乐...");
  16.     }
  17. }
  1. package com.itheima.datatype_demo;
  3. /*
  4.    1 分别定义含有Play，Mp3Player , Ipod参数的方法，并调用传入实参进行测试
  6.    2  定义一个学生类，里面定义含有Player， Mp3Player,Ipod类型的成员变量
  7.       创建学生对象并给成员变量赋值
  9.  */
  10. public class PlayerTest {
  11.     public static void main(String[] args) {
  12.         show1(new IPod());
  13.         show2(new IPod());
  14.         show2(new IPod());
  16.         Student s = new Student();
  17.         s.setPlayer(new IPod());
  18.         s.setMp3Player(new IPod());
  19.         s.setiPod(new IPod());
  20.     }
  22.     public static void show1(Player player) {// 方法的参数是一个接口 , 接收实现类对象
  23.         player.play();
  24.     }
  26.     public static void show2(Mp3Player player) {// 方法的参数是一个抽象类 , 接收子类对象
  27.         player.play();
  28.     }
  30.     public static void show3(Mp3Player player) {// 方法的参数是具体的类 , 接收此类对象或者子类对象
  31.         player.play();
  32.     }
  33. }
  35. /*
  36.     定义一个学生类，里面定义含有Player， Mp3Player,Ipod类型的成员变量
  37.     创建学生对象并给成员变量赋值
  38.  */
  39. class Student {
  40.     private Player player;   // 接口的类型的成员变量 , 保存的是实现类对象地址
  41.     private Mp3Player mp3Player; // 实现类的类型的成员变量 , 保存的是子类对象地址
  42.     private IPod iPod; // 具体类类型的成员变量 , 保存的是此类对象或者此类的子类对象地址
  45.     public Player getPlayer() {
  46.         return player;
  47.     }
  49.     public void setPlayer(Player player) {
  50.         this.player = player;
  51.     }
  53.     public Mp3Player getMp3Player() {
  54.         return mp3Player;
  55.     }
  57.     public void setMp3Player(Mp3Player mp3Player) {
  58.         this.mp3Player = mp3Player;
  59.     }
  61.     public IPod getiPod() {
  62.         return iPod;
  63.     }
  65.     public void setiPod(IPod iPod) {
  66.         this.iPod = iPod;
  67.     }
  68. }

8 Collection集合

8.1 集合和数组的区别

  • 长度区别
    • 数组 : 长度固定
    • 集合 : 长度可变

  • 存储数据类型
    • 数组 : 可以存储基本数据类型, 也可以存储引用数据类型
    • 集合 : 只能存储引用数据类型 , 要想存储基本数据类型 , 需要存储对应的包装类类型

8.2 集合的体系

image-20210404232635762

8.3 Collection集合常用的方法

  • 在学习集合体系，一般先学习顶层接口。学习了顶层接口的方法，子类型继承而来的方法，就可以不用重复学习。
    • public boolean add(E e)： 把给定的对象添加到当前集合中 。
    • public void clear() :清空集合中所有的元素。
    • public boolean remove(E e): 把给定的对象在当前集合中删除。
    • public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
    • public boolean isEmpty(): 判断当前集合是否为空。
    • public int size(): 返回集合中元素的个数。
    • public Object[] toArray(): 把集合中的元素，存储到数组中

8.4 迭代器

  • 概述 :
    • 迭代器就是对Iterator的称呼 , 专门用来对Collection集合进行遍历使用的。学习迭代器的目的就是为了遍历集合

  • 注意 :
    • 只有继承/实现Iterable接口才具有迭代的能力
    • Collection接口继承了Iterable接口所以 , Collection及其子类都具备迭代的能力

  • 获取迭代器对象的方式
    • 通过Collection集合对象调用Iterable接口中的iterator方法 , 就可以获取迭代器对象

  • Iterator(迭代器)中的方法

    | boolean | hasNext() | 如果迭代具有更多元素，则返回 true 。 | | —- | —- | —- | | E | next() | 返回迭代中的下一个元素。 | | default void | remove() | 从底层集合中删除此迭代器返回的最后一个元素（可选操作）。 |

  • 迭代器的注意事项
    • 当迭代器迭代元素完成后，不能继续next获取元素，否则会报：NoSuchElementException
    • 当迭代器在使用的过程中，不能使用集合对象直接增删元素。会导致报错ConcurrentModificationException。如果要删除可以使用迭代器来删除

8.5 增强for循环

  • 增强for循环（foreach），专门用来遍历集合或者数组，底层实现使用迭代器
  • 定义格式 : 
    1. for(元素的类型 变量名 : 数组/单列集合 ){
    2.  变量代表的就是集合或者数组的元素
    3. }