|
Day01 Object类 常用API 1：Object、toString、equals
Java.lang.Object类：根类，所有类的父类；
String toString():返回该对象的字符串表示；alt + ins键 选择toString(),即可重写
equals(Object obj):指示其他某个对象是否与此对象“相等”不重写时，通过==比较的时地址值；但开发时，一般要重写equals()方法，让对 象根据属性值判断是否相等，其实就是比较内容。
static boolean equals(Object a, Object b): 比较两个对象是否相等
如果2个参数都是null, 返回true
如果其中一个为null, 返回false
如果2个参数都不为null, 则使用第1个参数对象的equals()方法来比较
// Objects类中equals()方法源码
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
2：日期时间类 Date、long、String、Calendar
Date： 时间 long：表示时间，精确到毫秒，int数字
String:时间字符串 Calendar:日历
java.util.Date类: 日期, 表示特定的瞬间, 精确到"毫秒"
// 构造方法
Date(): 创建Date对象, 表示当前系统时间
Date(long date): 创建Date对象, 使用指定的毫秒值作为时间
// 常用成员方法
long getTime(): 获取Date对象中保存的时间毫秒值
void setTime(long time): 修改Date对象的时间
DateFormat 类及其构造方法
java.text.DateFormat抽象类: 用于格式化和解析时间. 提供了方便的方法
// 常用成员方法 (抽象类不能创建对象, 但可以有非抽象的方法供子类使用)
String format(Date date): 格式化, 从Date对象转换为String对象
Date parse(String source): 解析, 从String对象转换为Date对象
java.text.SimpleDateFormat类
// 构造方法
SimpleDateFormat(String pattern): 用给定的模式和默认语言环境的日期格式符号创建对象
// 使用指定的模式创建对象
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
y: 年 M: 月 d: 日 H: 时 (24小时制) m: 分
s: 秒 E: 星期 D: 年中的天 K: 小时(12小时制) S: 毫秒
例：
public class Test {
public static void main(String[] args) {
// 创建SimpleDateFormat对象用于格式化日期为字符串
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
// 创建日期对象(使用当前系统时间)
Date date = new Date();
// 格式化
String s = sdf.format(date);
System.out.println(s); // 2018年07月24日 14:45:48
}
}
parse()解析时间：
将时间字符串解析为日期对象
// 已知日期字符串"2000-10-01"
String s = "2000-10-01";
// 将该日期字符串解析为日期对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(s); // 红线按 Alt + Enter , 选择第一项 Add exception to method
signature
然后将date转化为long值：
long time = date.getTime();
System.out.println(time)
Calendar抽象类：代表日历
// 静态方法
static Calendar getInstance(): 根据当前系统设置获取合适的Calendar对象, 表示当前系统时间
// 获取日历对象的示例
Calendar c = Calendar.getInstance(); // 代表了当前时间
Calendar.getInstance() 会根据当前系统获取合适的子类对象, 我们获取到的是 GregorianCalendar
// 静态成员变量
static int YEAR :年份
static int MONTH :月份. 注意月份数值是 0-11
static int DAY_OF_MONTH :日期
static int HOUR :小时(12小时制)
static int HOUR_OF_DAY :小时(24小时制)
static int MINITE :分钟
static int SECOND :秒
// 非静态成员方法
int get(int field): 获取指定日历字段的值 int year = cal.get(Calendar.YEAR)
void set(int field, int value): 修改指定日历字段为指定的值
void add(int field, int amount): 调整指定日历字段的值. 正数增加, 负数减少
Date getTime(): Calendar转Date
void setTime(Date d): Date转Calendar
// 示例
// 获取日期:
int day = calendar.get(Calendar.DAY_OF_MONTH);
// 修改年:
calendar.set(Calendar.YEAR, 2000);
// 修改月:
calendar.set(Calendar.MONTH, 0);
// 日期增加一天:
calendar.add(Calendar.DAY_OF_MONTHY, 1);
// 日期减少一天:
calendar.add(Calendar.DAY_OF_MONTHY, -1);
日期转换总结:
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();获取当前时间毫秒
long now = System.currentTimeMillis();
java.lang.System类: 系统相关功能(数组复制方法)
// 静态方法
static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int length): 复制源数
组中指定长度个元素到一个新数组中
* Object src: 源数组 (被复制的数组)
* int srcPos: 源数组索引 (从源数组的哪个索引开始复制)
* Object dest: 目标数组 (要复制到哪个数组)
* int destPos: 目标数组索引 (指定目标数组接收元素的索引位置)
* int length: 长度 (要复制的元素个数)
StringBuilder类：字符串拼接
之前学习的字符串拼接我们常用“+”号
“+”使用加号进行字符串拼接, 会创建很多额外的对象, 浪费内存空间
实际上+加号在最终执行时, 会被翻译为:
new StringBuilder("原字符串").append("要拼接的字符串").toString();
额外创建了多余的StringBuilder对象
StringBuilder(): 构造一个空的StringBuilder容器
StringBuilder(String str): String转StringBuilder
StringBuilder append(任意类型): 添加任意类型数据的字符串形式, 并返回当前对象
String toString(): 将当前StringBuilder对象转换为String对象
String和StringBuilder互转: 利用StringBuilder
StringBuilder(String str): String转StringBuilder
String toString(): StringBuilder转String
例：
/*
需求:
使用StringBuilder拼接以下内容:
123
true
你好Java
并最终转换为String类型, 打印出来
*/
public class Test {
public static void main(String[] args) {
// 创建StringBuilder对象
StringBuilder sb = new StringBuilder();
// 链式调用
sb.append(123).append(true).append("你好Java");
// 转换为String
String s = sb.toString();
System.out.println(s); // 123true你好Java
// 更简单的配合匿名对象形式
String result = new StringBuilder().append(123).append(true).append("你好
Java").toString();
System.out.println(result); // 123true你好Java
}
}
Day02 Collection 泛型笔记 Collection接口 定义的是所有单列集合中共性的方法
所有单列集合都可以使用的共性方法
List接口： 1、有序的集合（存储和取出元素顺序相同）
2、允许存储重复的元素
3、有索引，可以使用普通的for循环遍历
Set接口： 1、不允许存储重复元素
2、没有索引，不能使用普通的for循环遍历
Collection<String> c = new Arraylist<>();
1、add(E,e):把给定对象添加到当前集合中 boolean b1 = c.add(“张三”) 返回值是一个布尔值
2、clear():清空集合中的所有元素 没有返回值
3、remove（E，e）:把给定的对象在当前集合中删除 boolean b2 = c.remove(“张三”) 如果集合中存在对应元素，返回值为true,相反为false
4、contains(E,e):判断当前集合中是否包含给定的对象 boolean b3 = c.contains(张三) 返回值为布尔值
5、isEmpty():判断当前集合是否为空 boolea b4 = c.isEmpty 返回值为布尔值
6、int size() 返回集合中元素的个数
7、Object[] toArray():把集合中的元素，存储到数组当中
8、Iterator<E> iterator():获取集合的迭代器对象
Iterator迭代器
迭代：类似于遍历，判断是否有下一个元素，有则取出一个，直到没有
迭代器：用于遍历集合的对象
Iterator<元素类型> iterator = 集合对象.iterator();
while(iterator.hasNext()){
元素类型 变量名 = iterator.next();
System.out.println(变量名)
}
迭代器的原理：
迭代器有一个指针（其实就是个变量保存索引值），最初指向集合的-1索引
hasNext() 方法可以判断下一个索引是否有元素
next() 方法移动指针到下一个索引，并返回元素
增强for循环：
也称foreach循环，用于遍历集合，底层采用迭代器
作用：遍历数组和集合
基本格式：
for(元素的数据类型 变量名 ： Collection集合或数组名){
操作代码
}
简易操作：Collection集合或数组名.for
例：Collection<Integer> c = new ArrayList<>();
for(int i : c){
System.out.println(i);
}
增强for, 普通for, 迭代器的区别:
增强for:
优点: 获取元素很方便, 格式简单
缺点: 没有普通for中的索引, 没有迭代器对象可以进行元素的增删
应用场景: 适用于遍历获取数组和集合元素的场景
普通for:
优点: 有索引可以使用, 某些方式可以在遍历过程中增删元素
缺点: 格式繁琐
应用场景: 需要用到索引的场景
迭代器:
优点: 可以使用迭代器对象的方法操作元素
缺点: 格式繁琐
应用场景: 需要在迭代过程中增删元素的场景
泛型<>：
泛型的好处：
1、避免了类型转换的麻烦
2、将运行时的类型转换异常，转移到了编译时期，更有利于提前发现问题
Collection coll = new ArrayList();
coll.add(1);
for(Object o : coll){
sout(o)
}
方法中的泛型定义位置:
修饰符 和 返回值类型 之间
// 带有泛型的方法定义格式
修饰符 <代表泛型的名字> 返回值类型 方法名(参数){
}
方法中定义泛型后, 返回值类型和参数类型都可以使用泛型
方法泛型的使用:
在调用方法时确定泛型的具体类型
定义泛型接口与定义泛型类一样
// 带有泛型的类定义格式
修饰符 interface接口名<代表泛型的变量> {
}
实现类实现了泛型接口后可以有2种选择:
1. 定义实现类时就确定泛型的具体类型
2. 定义实现类时仍然沿用泛型, 直到创建该类对象时才确定泛型的具体类型
泛型定义总结:
定义在类上的泛型:
有效范围: 整个类中都有效
何时确定具体类型: 创建该类对象时确定泛型的具体类型
定义在方法上的泛型:
有效范围: 方法中(包括返回值类型和参数类型)有效
何时确定具体类型: 调用方法传参时确定泛型的具体类型
定义在接口上的泛型:
有效范围: 接口中
何时确定具体类型:
1. 子接口或实现类定义时确定泛型的具体类型
2. 创建实现类对象时确定泛型的具体类型
|
|
收藏
淘帖
踩
