第十五天

1:正则表达式(理解)
(1)就是符合一定规则的字符串
(2)常见规则
A:字符
x 字符 x。举例：'a'表示字符a
\\ 反斜线字符。
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')

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

C:预定义字符类
. 任何字符。我的就是.字符本身，怎么表示呢? \.
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方。
举例：hello world?haha;xixi

E:Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
(3)常见功能：(分别用的是谁呢?)
A:判断功能
String类的public boolean matches(String regex)
B:分割功能
String类的public String[] split(String regex)
C:替换功能
String类的public String replaceAll(String regex,String replacement)
D:获取功能
Pattern和Matcher
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");

find():查找存不存在
group():获取刚才查找过的数据
(4)案例
A:判断电话号码和邮箱
B:按照不同的规则分割数据
C:把论坛中的数字替换为*
D:获取字符串中由3个字符组成的单词

2:Math(掌握)
(1)针对数学运算进行操作的类
(2)常见方法(自己补齐)
A:绝对值
B:向上取整
C:向下取整
D:两个数据中的大值
E:a的b次幂
F:随机数
G:四舍五入
H:正平方根
(3)案例：
A:猜数字小游戏
B:获取任意范围的随机数

3:Random(理解)
(1)用于产生随机数的类
(2)构造方法:
A:Random() 默认种子，每次产生的随机数不同
B:Random(long seed) 指定种子，每次种子相同，随机数就相同
(3)成员方法:
A:int nextInt() 返回int范围内的随机数
B:int nextInt(int n) 返回[0,n)范围内的随机数

4:System(掌握)
(1)系统类,提供了一些有用的字段和方法
(2)成员方法(自己补齐)
A:运行垃圾回收器
B:退出jvm
C:获取当前时间的毫秒值
D:数组复制

5:BigInteger(理解)
(1)针对大整数的运算
(2)构造方法
A:BigInteger(String s)
(3)成员方法(自己补齐)
A:加
B:减
C:乘
D:除
E:商和余数

6:BigDecimal(理解)
(1)浮点数据做运算，会丢失精度。所以，针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)
(2)构造方法
A:BigDecimal(String s)
(3)成员方法：
A:加
B:减
C:乘
D:除
E:自己保留小数几位

7:Date/DateFormat(掌握)
(1)Date是日期类，可以精确到毫秒。
A:构造方法
Date()
Date(long time)
B:成员方法
getTime()
setTime(long time)
C:日期和毫秒值的相互转换
案例：你来到这个世界多少天了?
(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat
A:SimpleDateFormat(String pattern) 给定模式
yyyy-MM-dd HH:mm:ss
B:日期和字符串的转换
a:Date -- String
format()

b:String -- Date
parse()
C:案例：
制作了一个针对日期操作的工具类。

8:Calendar(掌握)
(1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
(2)如何得到一个日历对象呢?
Calendar rightNow = Calendar.getInstance();
本质返回的是子类对象
(3)成员方法
A:根据日历字段得到对应的值
B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
C:设置日历对象的年月日
(4)案例：
计算任意一年的2月份有多少天?

 

1:看看下面的类，是否都熟悉，简要说明每个类主要是干什么呢?
Object：是类层次结构的根类，所有类都直接或者间接的继承自该类。
Scanner：获取键盘录入数据的
String：针对字符串的常见操作的
StringBuffer/StringBuilder：字符串缓冲区类，提高字符串的操作效率
Arrays：针对数组进行操作的工具类
Integer：把int类型封装成Integer类型，可以调用方法了，最主要是可以把String转换int类型了
Character：把char类型封装成Character类型，可以调用方法了。了解几个方法就可以了。
Pattern：正则表达式的编译表示形式。模式对象。
Matcher：匹配器对象。
Math：针对数学运算操作的类
Random：产生随机数的类
System：系统类，提供了几个有用方法
BigInteger：大整数的运算
BigDecimal：浮点数的运算用这个，不会有精度的丢失
Date：针对日期操作的类，可以精确到毫秒
DateFormat：针对日期进行格式化或者针对字符串进行解析
Calendar：日历类，把所有的日历字段进行了封装，要什么，自己获取，然后拼接。

2:把常见对象部分的总结看一遍

3:把常见对象部分的案例练习一遍

4:准备常见对象的考试

5:请完成下面的代码：(思考题)
我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。

学生：Student
成员变量：name,age
构造方法：无参,带参
成员方法：getXxx()/setXxx()

存储学生的数组?自己想想应该是什么样子的?

 

1:集合的由来?
2:集合和数组的区别?
3:Collection集合的功能概述?
4:Collection集合存储字符串并遍历?(迭代器)
5:Collection集合存储自定义对象并遍历?(迭代器)
6:List集合的特有功能?
7:List集合存储字符串并遍历?(迭代器和普通for)
8:List集合存储自定义对象并遍历?(迭代器和普通for)
9:并发修改异常出现的原因?解决方案?
10:常见的数据结构的特点?
栈：
队列：
数组：
链表：
11:List集合的子类特点
ArrayList:
Vector:
LinkedList:
12:List的三个儿子你准备使用谁?请说明理由。

 

1:对象数组(掌握)
(1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
(2)案例：
用数组存储5个学生对象，并遍历数组。

2:集合(Collection)(掌握)
(1)集合的由来?
我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组
而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
(2)集合和数组的区别?
A:长度区别
数组固定
集合可变
B:内容区别
数组可以是基本类型，也可以是引用类型
集合只能是引用类型
C:元素内容
数组只能存储同一种类型
集合可以存储不同类型(其实集合一般存储的也是同一种类型)
(3)集合的继承体系结构?
由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。

Collection
|--List
|--ArrayList
|--Vector
|--LinkedList
|--Set
|--HashSet
|--TreeSet
(4)Collection的功能概述(自己补齐)
A:添加功能
add(Object obj)
B:删除功能
remove(Object obj)
C:判断功能
contains(Object obj)
D:获取功能
Iterator iterator()
E:长度功能
size()
F:交集(了解)
G:把集合转数组(了解)
(5)Collection集合的遍历
A:把集合转数组(了解)
B:迭代器(集合专用方式)
(6)迭代器
A:是集合的获取元素的方式。
B:是依赖于集合而存在的。
C:迭代器的原理和源码。
a:为什么定义为了一个接口而不是实现类?
b:看了看迭代器的内部类实现。
(7)Collection集合的案例(遍历方式 迭代器)
集合的操作步骤：
A:创建集合对象
B:创建元素对象
C:把元素添加到集合
D:遍历集合

A:存储字符串并遍历
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;

public class CollectionDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();

//创建并添加元素
c.add("hello");
c.add("world");
c.add("java");

//遍历集合
Iterator it = c.iterator();
while(it.hasNext()) {
String s =(String) it.next();
System.out.println(s);
}
}
}

B:存储自定义对象并遍历
public class Student {
private String name;
private int age;

public Student(){}

public Student(String name,int age) {
this.name = name;
this.age = age;
}

//getXxx()/setXxx()
}

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

public class StudentDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();

//创建学生对象
Student s1 = new Student("林青霞",27);
Student s2 = new Student("风清扬",30);
Student s3 = new Student("刘意",30);
Student s4 = new Student("武鑫",25);
Student s5 = new Student("刘晓曲",16);

//添加元素
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(s5);

//遍历集合
Iterator it = c.iterator();
while(it.hasNext()) {
Student s = (Student)it.next();
System.out.println(s.getName()+"---"+s.getAge());
}
}
}

3:集合(List)(掌握)
(1)List是Collection的子接口
特点：有序(存储顺序和取出顺序一致)，可重复。
(2)List的特有功能：(自己补齐)
A:添加功能
add(int index,Object obj)
B:删除功能
remove(int index)
C:获取功能
get(int index)
D:迭代器功能
ListIterator listIterator()
E:修改功能
set(int index,Object obj)
(3)List集合的特有遍历功能
A:由size()和get()结合。
B:代码演示
//创建集合对象
List list = new ArrayList();

//创建并添加元素
list.add("hello");
list.add("world");
list.add("java");

//遍历集合
Iterator it = list.iterator();
while(it.hasNext()) {
String s =(String) it.next();
System.out.println(s);
}
System.out.println("----------");

for(int x=0; x<list.size(); x++) {
String s =(String) list.get(x);
System.out.println(s);
}
(4)列表迭代器的特有功能；(了解)
可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
(5)并发修改异常
A:出现的现象
迭代器遍历集合，集合修改集合元素
B:原因
迭代器是依赖于集合的，而集合的改变迭代器并不知道。
C:解决方案
a:迭代器遍历，迭代器修改(ListIterator)
元素添加在刚才迭代的位置
b:集合遍历，集合修改(size()和get())
元素添加在集合的末尾
(6)常见数据结构
A:栈 先进后出
B:队列 先进先出
C:数组 查询快，增删慢
D:链表 查询慢，增删快
(7)List的子类特点(面试题)
ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

到底使用谁呢?看需求?
分析：
要安全吗?
要：Vector(即使要，也不使用这个，后面再说)
不要：ArrayList或者LinkedList
查询多；ArrayList
增删多：LinkedList

什么都不知道，就用ArrayList。
(8)List集合的案例(遍历方式 迭代器和普通for)
A:存储字符串并遍历
B:存储自定义对象并遍历

1:集合的由来?
存储多个对象，可以使用数组，数组的长度固定，不适应变化的需求，所以Java就提供了集合。
2:集合和数组的区别?
数组：长度固定，可以存储基本类型和引用类型，同一种数据类型
集合：长度可变，只能存储引用类型，可以存储多种引用类型(一般我们仅仅存储一种)
3:Collection集合的功能概述?
添加
删除
判断
获取
长度
4:Collection集合存储字符串并遍历?(迭代器)
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");

Iterator it = c.iterator();
while(it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
}

5:Collection集合存储自定义对象并遍历?(迭代器)
Student.java
StudentDemo.java

6:List集合的特有功能?
添加功能
获取功能
删除功能
修改功能

7:List集合存储字符串并遍历?(迭代器和普通for)

List list = new ArrayList();

list.add("hello");
list.add("java");
list.add("world");

Iterator it = list.iterator();
while(it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
}

for(int x=0; x<list.size(); x++) {
String s = (String) list.get(x);
System.out.println(s);
}
8:List集合存储自定义对象并遍历?(迭代器和普通for)

9:并发修改异常出现的原因?解决方案?
迭代器遍历集合的时候，通过集合去修改了集合的元素。而迭代器是依赖于集合的，它并不知道集合改变了，所以报错。

A:迭代器遍历，迭代器修改集合
B:集合遍历，集合修改集合

10:常见的数据结构的特点?
栈：先进后出
队列：先进先出
数组：查询快，增删慢
链表：查询慢，增删块
11:List集合的子类特点
ArrayList:
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
Vector:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
LinkedList:
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
12:List的三个儿子你准备使用谁?请说明理由。

 

1:List的子类特点
2:ArrayList练习
A:ArrayList存储字符串并遍历
B:ArrayList存储自定义对象并遍历
3:LinkedList练习
A:LinkedList存储字符串并遍历
B:LinkedList存储自定义对象并遍历
4:泛型是什么?格式是?好处是?
5:增强for的格式是?好处是?弊端是?
6:静态导入的格式是?注意事项是?
7:可变参数的作用是?格式是?注意事项是?
8:用下列集合完成代码
Collection
List
ArrayList
Vector
LinkedList

存储字符串并遍历
存储自定义对象并遍历

要求加入泛型，并有增强for遍历。
代码我会检查的。