黑马程序员技术交流社区

标题: [石家庄校区]就业班笔记[Object类常见API] 及[Collection 泛型] [打印本页]

作者: 娱乐逗 时间: 2018-11-14 17:02
标题: [石家庄校区]就业班笔记[Object类常见API] 及[Collection 泛型]

[石家庄校区]就业班笔记[Object类常见API] 及[Collection 泛型]

第一天 Object类常见API
Object类:
Object类: toString方法
java.lang.Object类: 根类, 所有类的父类
// 成员方法
String toString() ：返回该对象的字符串表示  Person
boolean equals(Object obj) ：指示其他某个对象是否与此对象"相等"
Object类的特点:
1. 是类层次的根类. 每个类都(直接或间接地)使用Object类作为父类
2. 所有类的对象都可以使用Object类中定义的方法
public String toString() ：返回该对象的字符串表示
作用:
任何类的对象都可调用 toString(), 得到一个对象的字符串表示形式, 默认使用Object类中定
义的方式
如果不想使用默认方式, 子类可以重写toString()方法, 转换为自己想要的内容
一般我们都要输出JavaBean的属性名和属性值, Alt + Insert 选择 toString() 即可重写
Object类: equals方法的默认实现方式
重写equals()的作用:
不重写时, 自定义对象默认继承Object类的equals()方法, 通过 == 比较地址值
但开发时, 一般要重写equals()方法, 让对象"根据属性值"来判断是否相等
IDEA快捷键: Alt+Insert, 选 equals() and hashCode()
了解Objects类中的equals方法
s1 = null;
s1.equals(s2);  // NullPointerException
java.util.Objects类: JDK7 添加. 操作对象的工具类, 提供了空指针安全的方法
// 静态方法
static boolean equals(Object a, Object b): 比较两个对象是否相等
如果2个参数都是null, 返回true
如果其中一个为null, 返回false
如果2个参数都不为null, 则使用第1个参数对象的equals()方法来比较
日期时间相关的类
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/940f1dc18d754e22bf9adee29b99cd41/clipboard.png
毫秒值的概念和作用
时间原点: 从 0时区 1970-01-01 00:00:00(英国格林威治时间) 开始, 至今经过的毫秒值(1 秒 = 1000 毫秒)  中国在东八区,需要加8小时.
10位精确到秒  : 1494992791 = 2017/5/17 11:46:31
13位精确到毫秒: 1494992791000 = 2017/5/17 11:46:31
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/917ca6c69fc34f82be87b6f6d8d58991/clipboard.png
Date类: 构造方法, 成员方法
注意: 不要导错包! 有2个包中都有Date类, 一个是java.sql.Date, 另一个是java.util.Date
我们用的是 java.util.Date
java.util.Date类: 日期, 表示特定的瞬间, 精确到"毫秒"
// 构造方法
Date(): 创建Date对象, 表示当前系统时间
Date(long date): 创建Date对象, 使用指定的毫秒值作为时间
// 常用成员方法
long getTime(): 获取Date对象中保存的时间毫秒值
void setTime(long time): 修改Date对象的时间
DateFormat类和SimpleDateFormat类
java.text.DateFormat抽象类: 用于格式化和解析时间. 提供了方便的方法
// 常用成员方法 (抽象类不能创建对象, 但可以有非抽象的方法供子类使用)
String format(Date date): 格式化, 从Date对象转换为String对象
Date parse(String source): 解析, 从String对象转换为Date对象
date -> String "yyyy年MM月dd日 HH:mm:ss"

java.text.SimpleDateFormat类
// 构造方法
SimpleDateFormat(String pattern): 用给定的模式和默认语言环境的日期格式符号创建对象
// 常用模式: 可在SimpleDateFormat类中查看
y: 年
M: 月
d: 日
H: 时 (24小时制)
m: 分
s: 秒

E: 星期
D: 年中的天
K: 小时(12小时制)
S: 毫秒

示例: "yyyy-MM-dd E HH:mm:ss.SSS"
结果: 2016-04-01 星期五 17:29:15.868

如果要匹配普通的英文字母, 则需要用单引号括起来: "'abc'"
如果要匹配单引号, 则使用2个单引号: "''"
// 使用指定的模式创建对象
SimpleDateFormat format = new SimpleDateFormat("yyyy‐MM‐dd HH:mm:ss");
格式化和解析方法: format()方法, parse()方法
String format(Date date): 格式化, 从Date对象转换为String对象
例如, SimpleDateFormat对象的模式是: "yyyy年MM月dd日  HH:mm:ss"
那么, 将Date格式化后就可以是这种样子: 2018年01月02日  03:04:05
Date parse(String source): 解析, 从String对象转换为Date对象
例如, SimpleDateFormat对象的模式是: "yyyy-MM-dd"
要解析为Date对象的字符串必须符合模式: 2000-01-02
Calendar类: 获取Calendar对象
java.util.Calendar抽象类: 代表日历, 提供了不同国家的历法, 封装了很多时间属性
// 静态方法
static Calendar getInstance(): 根据当前系统设置获取合适的Calendar对象, 表示当前系统时间
// 获取日历对象的示例
Calendar c = Calendar.getInstance();  // 代表了当前时间
Calendar类: 常用功能
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/f08dc9e7d8d34dbf860e9cb442e1ab51/clipboard.png

C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/a0492b60e664470f9301e94d82376fac/clipboard.png
  long (数学计算)
      \    SimpleDateFormat
      Date -------------------- String (用户输入和显示)
      /
Calendar (获取时间的某个部分, 调整时间)
long和Date对象互转
利用Date
Date(long millis): long转Date
long getTime(): Date转long
String和Date对象互转
利用SimpleDateFormat
Date parse(String s): String转Date
String format(Date): Date转String
Calendar对象和Date对象互转
利用Calendar
Date getTime(): Calendar转Date
void setTime(Date d): Date转Calendar
System类
System类: currentTimeMillis()和arrayCopy()方法
java.lang.System类: 系统相关功能
// 静态方法
static long currentTimeMillis(): 返回当前系统时间的毫秒值
static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int length):
复制源数组中指定长度个元素到一个新数组中
      * Object src: 源数组 (被复制的数组)
      * int srcPos: 源数组索引 (从源数组的哪个索引开始复制)
      * Object dest: 目标数组 (要复制到哪个数组)
      * int destPos: 目标数组索引 (指定目标数组接收元素的索引位置)
      * int length: 长度 (要复制的元素个数)
StringBuilder类
StringBuilder原理: 字符串拼接问题
+号拼接字符串的问题:
String是不可变的, 使用加号进行字符串拼接, 会创建很多额外的对象, 浪费内存空间
StringBuilder: 构造方法和append()拼接方法
StringBuilder(); 构造一个空StringBuilder容器;
StringBuilder(String str); String转StringBuilder
StringBuilder append(任意类型); 添加任意类型数据的字符串形式,并返回当前对象
链式调用:
StringBuilder().append(1).append(2).append(true);
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/a57696e527a44ea6a2fe10926dff2391/clipboard.png

C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/a57696e527a44ea6a2fe10926dff2391/clipboard.png
StringBuilder: toString()
StringBuilder(String str): String 转StringBuilder
String toString() :StringBuilder转String
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/65b968c0376b442b8798d63bf06d38a2/clipboard.png
包装类
包装类: 基本数据类型对应的引用数据类型
ArrayList<Integer> list = new ArrayList<>();
list.add(10);
int a = list.get(0)
C:/Users/Administrator/AppData/Local/YNote/data/x409428917@163.com/02665b7dfc7949d4b763e41f9cdaa8f4/clipboard.png
包装类: 装箱与拆箱
装箱: 从基本类型转换为对应的包装类对象
装箱原理:
//Integer i1 = new Integer(1);
//Integer i2 = new Integer("1");
Integer i3 = Integer.valueOf(1); //使用包装类中的静态方法valueOf()
拆箱: 从包装类对象转换为对应的基本类型
拆箱原理:
int num = i.intValue();
包装类常用方法: 基本类型与字符串之间转换
基本类型转为String:
1. 拼接空字符串:
String s = "" + 34
2. 每个包装类中的静态方法 static String toString(参数):
String s = Integer.toString(10);
3. String类中的静态方法 static String valueOf(参数):
String s = String.valueOf(10);

String转基本类型: 利用每种包装类中的静态方法
static byte parseByte(String s): 将字符串参数转换为对应的byte基本类型
static short parseShort(String s): 将字符串参数转换为对应的short基本类型
static int parseInt(String s): 将字符串参数转换为对应的int基本类型
static long parseLong(String s): 将字符串参数转换为对应的long基本类型
static float parseFloat(String s): 将字符串参数转换为对应的float基本类型
static double parseDouble(String s): 将字符串参数转换为对应的double基本类型
static boolean parseBoolean(String s): 将字符串参数转换为对应的boolean基本类型
注意: 没有转char的!!
第二天 Collection 泛型
Collection
集合概述
集合: 长度可变容器, 可以存储多个对象
集合和数组的区别:
1. 数组长度不可变; 集合长度可变
2. 数组可以存基本类型或引用类型, 只能存同一种类型; 集合只能存储引用类型元素, 可以是多种类型元素
集合框架介绍
Collection接口: 单列集合顶层
|_ List接口: 元素存取有序, 可重复, 有索引
|_ Set接口: 不可重复, 无索引
学习方法:
学习顶层: 顶层接口/抽象类中共性的方法, 所有子类都可以使用
使用底层: 使用底层子类/实现类创建对象

Collection常用功能
java.util.Collection<E>接口:
// 成员方法(子类都会实现)
boolean add(E e): 把给定的对象添加到当前集合中
void clear(): 清空集合中所有的元素
boolean remove(E e): 把给定的对象在当前集合中删除
boolean contains(E e): 判断当前集合中是否包含给定的对象
boolean isEmpty(): 判断当前集合是否为空(没有元素)
int size(): 返回集合中元素的个数
Object[] toArray(): 把集合中的元素，存储到数组中

Iterator<E> iterator(): 获取集合的迭代器对象 (后面讲到)
      Iterator接口: 迭代器
测试Collection接口的方式:
Collection<String> coll = new ArrayList<>();  一般不用这种方式
迭代器
迭代器Iterator接口介绍和迭代步骤
迭代:
类似于遍历, 判断是否有下一个元素, 有则取出下一个, 直到没有
迭代器:
用于遍历集合的对象
java.util.Collection<E>接口:
// 成员方法(子类都会实现)
Iterator<E> iterator(): 获取集合的迭代器对象
java.util.Iterator<E>接口: 迭代器
// 成员方法
boolean hasNext(): 判断是否有下一个元素
E next(): 获取下一个元素
void remove(): 删除next指向的元素
使用迭代器遍历集合的3步:
1. 使用集合对象的 iterator() 获取迭代器对象, 用 Iterator 接口接收.(多态)
2. 使用 Iterator 接口中的 hasNext() 方法, 判断是否有下一个元素
3. 使用 Iterator 接口中的 next() 方法, 获取下一个元素
使用迭代器的代码实现
// 使用迭代器遍历集合的标准写法:
Iterator<元素类型> iterator = 集合对象.iterator();
while (iterator.hasNext()) {
元素类型变量名 = iterator.next();
}
注意事项:
迭代器对象迭代完毕后, 指针已经指向最后一个元素, 没有下一个元素了. 如果想再次从头遍历集合, 要获取新的迭代器对象
迭代器的实现原理
集合和迭代器对象的关系:
每个集合都有对应的一个迭代器对象
迭代器的原理:
迭代器有一个指针(其实就是个变量, 保存索引值), 最初指向集合的 0 位置
hasNext() 方法可以判断当前索引是否有元素
next() 方法返回当前元素, 并移动指针到下一个索引
迭代器的并发修改异常
并发修改异常的原因:
在使用迭代器迭代的过程中, 如果执行了改变集合长度的操作 (如 add(), remove(), clear()), 则会抛出 ConcurrentModificationException 并发修改异常.
如何避免:
1. 迭代过程中不要修改集合长度
2. 在迭代的过程中添加, 删除元素, 要使用迭代器自带的方法, 而不能使用集合的方法
Iterator中的 remove() 方法
ListIterator中的 add(), remove() 方法
增强for循环
增强for:
也称foreach循环, JDK 5出现, 用于遍历集合, 底层采用迭代器
作用:
遍历数组
遍历集合
增强for格式:
for(元素的数据类型变量名 : Collection集合或数组名){
      //操作代码
}
// 数组示例
int[] arr = {1,2,3};
for (int i : arr) {
      System.out.println(i);
}
-----------------------------
// 集合示例
Collection<Integer> c = new ArrayList<>();
for (int i : c) {
      System.out.println(i);
}
增强for对于数组和集合的操作:
对数组只是写法上的优化, 底层还是普通for循环
对集合是通过迭代器实现的
增强for, 普通for, 迭代器的区别:
增强for:
优点: 获取元素很方便, 格式简单
缺点: 没有普通for中的索引, 没有迭代器对象可以进行元素的增删
应用场景: 适用于遍历获取数组和集合元素的场景
普通for:
优点: 有索引可以使用, 某些方式可以在遍历过程中增删元素
缺点: 格式繁琐
应用场景: 需要用到索引的场景
迭代器:
优点: 可以使用迭代器对象的方法操作元素
缺点: 格式繁琐
应用场景: 需要在迭代过程中增删元素的场景
泛型
泛型的概述以及不使用泛型产生的问题
泛型: Generic Type. JDK 5 增加. 是一种未知的数据类型
定义集合时, 某些方法不知道使用什么类型时, 就可以使用泛型
创建集合对象时, 需要确定泛型具体的类型
泛型可以看作是一个"变量", 用来接收数据类型
定义:
<E>: 声明了一个泛型 (声明了一个变量)
E: 使用E这种类型作为数据类型  (参数数据类型, 返回值类型)
使用:
ArrayList<Integer>: 确定了泛型的具体类型
泛型的好处
不使用泛型的问题:
集合实际存储的是 Object 类型, 存入的元素无论是什么类型, 都会被提升为 Object, 取出来的也是 Object, 要想调用元素特有方法, 就要向下转型, 有可能发生类型转换异常 ClassCastException

泛型的好处:
1. 避免了类型转换的麻烦
2. 将运行时的类型转换异常, 转移到了编译时期 (有利于程序员提前发现问题)
定义和使用含泛型的类
定义泛型
<泛型名>
泛型的"定义"和"使用"
泛型在"定义"时, "不能是"具体的类型, 只是一个变量名: public class ArrayList<E> {}
泛型在"使用"时, "必须是"具体的数据类型 ArrayList<Integer>
// 带有泛型的类定义格式
修饰符 class 类名<代表泛型的名字> {  // 泛型的变量一般用一个大写字母表示, 但也可以是多个字母
}
类中的泛型, "在创建对象时", 确定泛型的具体类型
定义含有泛型的方法与使用
方法中的泛型定义位置:
修饰符和返回值类型之间
// 带有泛型的方法定义格式
修饰符 <代表泛型的名字> 返回值类型方法名(参数){

}
方法中定义泛型后, 返回值类型和参数类型都可以使用泛型
方法泛型的使用:
"在调用方法时"确定泛型的具体类型
定义与使用含有泛型的接口
定义泛型接口与定义泛型类一样
    // 带有泛型的类定义格式
修饰符 interface 接口名<代表泛型的变量> {

}
public interface GenericInterface<I> {
void method(I i);
}
实现类实现了泛型接口后可以有2种选择:
1. "定义实现类时", 确定泛型的具体类型
      public class A implements GenericInterface<String> {
@Override
public void method(String i) {}  // 所有使用泛型的地方都会确定具体类型
      }
2. 定义实现类时仍然沿用泛型, 直到"创建该实现类对象时"才确定泛型的具体类型
      public class A<I> implements GenericInterface<I> {
@Override
public void method(I i) {}  // 泛型不需要确定具体类型, 当创建该类对象时再确定
      }

泛型定义总结:
定义在类上的泛型:
有效范围: 整个类中都有效
何时确定具体类型: 创建该类对象时确定泛型的具体类型
定义在方法上的泛型:
有效范围: 方法中(包括返回值类型和参数类型)有效
何时确定具体类型: 调用方法传参时确定泛型的具体类型
定义在接口上的泛型:
有效范围: 接口中
何时确定具体类型:
1. 子接口或实现类定义时确定泛型的具体类型
2. 创建实现类对象时确定泛型的具体类型
泛型通配符
泛型通配符:
不知道使用什么类型来接收时, 此时可以使用 <?> 来表示未知通配符
示例: List<?> list  接收泛型是任意类型的List对象
      public void addAll(List<?> list){
// ...
      }
注意: 只能接收数据, 不能调用方法存储元素
List<?> list 这种集合不能调用 add() 添加元素, 只能调用 get() 获取元素
List<?> list 其实是一个变量, 所以可以将一个集合赋值给它
如: List<?> list = new ArrayList<String>();  // 正确
但是不能直接new 泛型为?的集合对象:
如: List<?> list = new ArrayList<?>();  // 错误
使用方式:
不能创建对象使用
只能作为方法参数使用. (减少方法重载)
泛型的上限:
格式: 类型名称<? extends 类名> 对象名称
示例: List<? extends Number> list
作用: 只能接收泛型为该类型及其子类的对象 (Number及其子类的泛型)

泛型的下限:
格式: 类型名称<? super 类名> 对象名称
示例: List<? super Number> list
作用: 只能接收泛型为该类型及其父类型的对象 (Number及其父类的泛型);

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2