【石家庄校区】Object类-常用API，Collection-泛型笔记 - 黑马程序员技术交流社区

【石家庄校区】Object类-常用API，Collection-泛型笔记

java.lang.Object类: 根类, 所有类的父类

String toString() ：返回该对象的字符串表示

boolean equals(Object obj) ：指示其他某个对象是否与此对象"相等"

1是所有类的父类, 任何一个类都直接或间接地继承自Object类, 并可以使用Object类中定义的方法

2一个类如果没有指定继承某个父类, 则默认继承Object类

Object类之 toString方法

public String toString() ：返回该对象的字符串表示。

1任何类的对象都可调用toString(), 得到一个对象的字符串表示形式, 默认使用Object类中定义的方式

2如果不想使用默认方式, 子类可以重写toString()方法, 转换为自己想要的内容

一般我们都要输出JavaBean的属性名和属性值, Alt + Insert 选择 toString() 即可重写

Object类之equals方法

public boolean equals(Object obj) ：指示其他某个对象是否与此对象“相等”。

重写equals()的作用:

不重写时, 自定义对象默认继承Object类的equals()方法, 通过 == 比较地址值

但开发时, 一般要重写equals()方法, 让对象根据属性值来判断是否相等

IDEA快捷键: Alt+Insert, 选 equals() and hashCode()

Date(): 创建Date对象, 表示当前系统时间

Date(long date): 创建Date对象, 使用指定的毫秒值作为时间

例：SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

Date date = sdf.parse(s);

long time = date.getTime();//将date转化为long

sout(long)//97032960000

// 常用成员方法

long getTime(): 获取Date对象中保存的时间毫秒值

例：// 字符串转Date
Date date = new Date();
// Date转long
Date birthday = sdf.parse(s);
// 获取当前时间的毫秒值
long todayTime = date.getTime();

void setTime(long time): 修改Date对象的时间

java.text.DateFormat抽象类: 用于格式化和解析时间. 提供了方便的方法

// 常用成员方法 (抽象类不能创建对象, 但可以有非抽象的方法供子类使用)

String format(Date date): 格式化, 从Date对象转换为String对象

DateFormat类之格式化format方法

Date date = new Date();

// 创建日期格式化对象,在获取格式化对象时可以指定风格

DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");

String str = df.format(date);

System.out.println(str); // 2008年1月23日

Date parse(String source): 解析, 从String对象转换为Date对象

DateFormat之解析parse方法

DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");

String str = "2018年12月11日";

Date date = df.parse(str);

System.out.println(date); // Tue Dec 11 00:00:00 CST 2018

-----------------------------------------

示例: "yyyy-MM-dd E HH:mm:ss.SSS"

结果: 2016-04-01 星期五 17:29:15.868

如果要匹配普通的英文字母, 则需要用单引号括起来: "'abc'"

如果要匹配单引号, 则使用2个单引号: "''"

java.util.Calendar抽象类: 代表日历, 提供了不同国家的历法, 封装了很多时间属性

// 静态成员变量

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 :秒

DAY_OF_WEEK 周中的天（周几，周日为1，可以-1使用）

// 非静态成员方法

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

//获取日历对象
Calendar c = Calendar.getInstance();
//int get(int field) get方法用来获取指定字段的值
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;
int dayOfMonth = c.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+month+"月"+dayOfMonth+"日");//2018年7月24日

//void set(int field, int value) set方法用来设置指定字段的值
c.set(Calendar.YEAR,2012);
c.set(Calendar.MONTH,11);
c.set(Calendar.DAY_OF_MONTH,25);

year = c.get(Calendar.YEAR);//2012
month = c.get(Calendar.MONTH)+1;//12
dayOfMonth = c.get(Calendar.DAY_OF_MONTH);//25
System.out.println(year+"年"+month+"月"+dayOfMonth+"日");//2012年12月25日

//void add(int field, int amount)对指定日历字段的值进行加减操作
c.add(Calendar.YEAR,8);

year = c.get(Calendar.YEAR);//2020
month = c.get(Calendar.MONTH)+1;//12
dayOfMonth = c.get(Calendar.DAY_OF_MONTH);//25

System.out.println(year+"年"+month+"月"+dayOfMonth+"日");//2020年12月25日

//Date getTime() Calendar转Date 拿到对应的Date对象
Date date = c.getTime();
System.out.println(date);//Fri Dec 25 16:28:48 CST 2020

//void setTime(Date d) Date转Calendar
c.setTime(new Date());

year = c.get(Calendar.YEAR);//
month = c.get(Calendar.MONTH)+1;//
dayOfMonth = c.get(Calendar.DAY_OF_MONTH);//
System.out.println(year+"年"+month+"月"+dayOfMonth+"日");//2018年7月24日

3.1 currentTimeMillis方法 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

例 long start = System.currentTimeMillis(); // 先记录开始时间毫秒值

3.2 arraycopy方法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将

数组中指定的数据拷贝到另一个数组中。

Int [] src = {1,2,3,4,5}

Int [] dest = {6,7,8,9,10}

System.arraycopy(src,0,dest,0,3)

Sout(Arrays.toString(src));//[1,2,3,4,5]

Sout(Arrays.toString(dest));//[1,2,3,9,10]

四 StringBuilder类

public StringBuilder() ：构造一个空的StringBuilder容器。

public StringBuilder(String str) ：构造一个StringBuilder容器，并将字符串添加进去。

例:StringBuilder sb2 = new StringBuilder("itcast");

1 public StringBuilder append(任意类型) ：添加任意类型数据的字符串形式，并返回当前对象自身。

//创建StringBuilder对象

StringBuilder sb = new StringBuilder();

sb.append(123).append(true).append("你好Java");

2 public String toString() ：将当前StringBuilder对象转换为String对象。

String s = sb.toString();

System.out.println(s); // 123true你好Java

基本类型对应的包装类（位于java.lang包中）

装箱：从基本类型转换为对应的包装类对象。

IInteger i = 10; // 自动装箱: Integer i = Integer.valueOf(10);

拆箱：从包装类对象转换为对应的基本类型。

Integer j = 20; // 自动装箱: Integer j = Integer.valueOf(20);

包装类常用方法: 基本类型与字符串之间转换

基本类型转为String: 拼接空字符串

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基本类型

集合: 长度可变容器, 可以存储多个对象

集合和数组的区别:

1. 数组长度不可变; 集合长度可变

2. 数组可以存基本类型或引用类型, 只能存同一种类型; 集合只能存储引用类型元素, 可以是多种类型元素

Collection接口: 单列集合顶层

|_ List接口: 元素存取有序, 可重复, 有索引

|_ Set接口: 元素存取无序, 不可重复, 无索引

ArrayList<String> add("aaaa") add("bbb") add("ccc") add("ccc")

HashSet<String> add("aaaa") add("bbb") add("ccc")

Collection集合的常用功能

Collection接口中定义了哪些方法, 分别有什么作用

// 多态创建对象: 父类引用指向子类对象

ArrayList list = new ArrayList();

list.特有方法();

Collection<String> coll = new ArrayList<>();

// 多态调用方法

java.util.Collection接口:

// 成员方法(子类都会实现)

Boolean add(E e): 把给定的对象添加到当前集合中

Void clear(): 清空集合中所有的元素

Boolean remove(E e): 把给定的对象在当前集合中删除

Boolean contains(E e): 判断当前集合中是否包含给定的对象

Boolean isEmpty(): 判断当前集合是否为空(没有元素)

Int size(): 返回集合中元素的个数

Object[] toArray(): 把集合中的元素，存储到数组中

//测试以下Collection接口中的方法

Collection<String> coll = new ArrayList<>();
//boolean add(E e): 把给定的对象添加到当前集合中
boolean b1 = coll.add("虚空行者");
boolean b2 = coll.add("虚空掠夺者");
boolean b3 = coll.add("虚空先知");
boolean b4 = coll.add("虚空遁地兽");
System.out.println("b1:"+b1);//t
System.out.println("b2:"+b2);//t
System.out.println("b3:"+b3);//t
System.out.println("b4:"+b4);//t

//boolean remove(E e): 把给定的对象在当前集合中删除
boolean b5 = coll.remove("虚空先知");
System.out.println("删除虚空先知:"+b5);//t

//boolean contains(E e): 判断当前集合中是否包含给定的对象
boolean b6 = coll.contains("卡萨丁");
boolean b7 = coll.contains("虚空行者");
System.out.println("包含卡萨丁:"+b6);//f
System.out.println("包含虚空行者:"+b7);//t

//int size(): 返回集合中元素的个数
int i = coll.size();
System.out.println("返回集合中元素的个数为:"+i);//3

//Object[] toArray(): 把集合中的元素，存储到数组中
Object[] obj = coll.toArray();
for (int j = 0; j < obj.length; j++) {
System.out.println(obj[j]);//虚空行者掠夺者遁地兽

//void clear(): 清空集合中所有的元素
coll.clear();

//boolean isEmpty(): 判断当前集合是否为空(没有元素)
boolean b8 = coll.isEmpty();
System.out.println("当前集合是否为空:"+b8);//t

测试Collection接口的方式:

使用多态方式创建对象: Collection c = new ArrayList();

编译看左边, 这样只能调用Collection接口中定义的方法, 不会出现子类特有方法

迭代: 类似于遍历, 判断是否有下一个元素, 有则取出下一个, 直到没有

迭代器: 用于遍历集合的对象

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();

Collection<String> coll = new ArrayList<>();

coll.add("詹姆斯");

coll.add("艾弗森");

// 获取迭代器对象

Iterator<String> iterator = coll.iterator();

while (iterator.hasNext()) {

String s = iterator.next();

System.out.println(s);

1. 迭代器对象迭代完毕后, 指针已经指向最后一个元素, 没有下一个元素了. 如果想再次从头遍历集合, 要获取

新的迭代器对象

2. 在使用迭代器迭代的过程中, 如果执行了改变集合长度的操作 (如add(), remove(), clear()), 则会抛出

ConcurrentModificationException 并发修改异常. 如果要在迭代的过程中添加, 删除元素, 要使用迭代器自带的方

法, 而不能使用集合的方法

增强for: 也称foreach循环, JDK 5出现, 用于遍历集合, 底层采用迭代器

for(元素的数据类型变量名 : Collection集合或数组名){

int[] arr = {1,2,3};

System.out.println(i);

Collection<Integer> c = new ArrayList<>();

System.out.println(i);

增强for的IDEA快捷键: 集合/数组名.for

增强for对于数组和集合的操作:

对数组只是写法上的优化, 底层还是普通for循环

对集合是通过迭代器实现的

增强for, 普通for, 迭代器的区别:

优点: 获取元素很方便, 格式简单

缺点: 没有普通for中的索引, 没有迭代器对象可以进行元素的增删

应用场景: 适用于遍历获取数组和集合元素的场景

优点: 有索引可以使用, 某些方式可以在遍历过程中增删元素

缺点: 格式繁琐

应用场景: 需要用到索引的场景

优点: 可以使用迭代器对象的方法操作元素

缺点: 格式繁琐

应用场景: 需要在迭代过程中增删元素的场景

泛型: Generic. JDK 5 增加. 是一种未知的数据类型

定义集合时, 某些方法不知道使用什么类型时, 就可以使用泛型

创建集合对象时, 需要确定泛型具体的类型

泛型可以看作是一个变量, 用来接收数据类型

定义和使用含泛型的类

泛型的定义和使用

泛型在定义时, 不能是具体的类型, 只是一个变量名

泛型在使用时, 必须是具体的数据类型

// 带有泛型的类定义格式

修饰符 class 类名<代表泛型的名字> { // 泛型的变量一般用一个大写字母表示, 但也可以是多个字母

例:public class GenericClass<E> {

定义含有泛型的方法与使用

方法中的泛型定义位置:

修饰符和返回值类型之间

// 带有泛型的方法定义格式

修饰符 <代表泛型的名字> 返回值类型方法名(参数){

例:public <M> void method(M m) {

定义与使用含有泛型的接口

定义泛型接口与定义泛型类一样

// 带有泛型的类定义格式