1. Object类
java.lang.Object,是所有类的父类。
1.1 toString()方法
- 默认的toString()方法是直接输出对象的地址值。和直接输出对象的名字是一样的效果。
- 为了输出自己想要的东西,可以@Override toString()。
- sout(obj)和sout(obj.toString())效果一致。
1.2 equals()方法
- 用来比较两个对象是否相等。
- 对于基本数据类型:比较的是值
- 对于引用类型:比较的是两个对象的内存地址
注意:equals(Object obj)传进来的是Object类的对象,有可能遇到多态的弊端:无法使用子类特有的变量或方法。使用向下转型(强制类型转换)把Object转换为某类。转换之前,需要用instanceof来判断是否是同一个子类。
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Zi zi = (Zi) o;
return num == zi.num;
}
idea自动添加的equals代码,其中getClass() != o.getClass()
叫反射。
1.3 Objects类
提供了静态方法,这些静态方法是空指针安全的。
- Objects.equals(o1,o2)
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
先判断内存地址是否相同,再调用equals()
2. 日期类
- java.util.Date 精确到毫秒
- 1970年1月1日 00:00:00:0000代表的就是0ms(GMT时间)
long currentTime = System.currentTimeMillis()
,返回从0ms到现在经过的毫秒,
2.1 Date类的空构造函数
import java.util.Date;
Date date = new Date();
System.out.println("现在时间是:" + date);
//========输出=========//
现在时间是:Sat May 16 17:57:37 CST 2020
2.2 Date类的带参数构造函数
Date date = new Date(long time)
传进去毫秒,转换为日期。
import java.util.Date;
Date date = new Date(0);
System.out.println("0ms的日期是:" + date);
//========输出=========//
0ms的日期是:Thu Jan 01 08:00:00 CST 1970
2.3 Date.getTime()方法
long time = new Date().getTime()
Date date = new Date(); long time = date.getTime()
- 等同于
long currentTime = System.currentTimeMillis()
3. DateFormat类
java.text.DateFormat,是一个用于格式化时间的抽象类。
-
格式化:日期 -> 文本; 解析:文本 -> 日期。
-
String format(Date date)
按照指定的格式,把日期格式化为字符串
-
Date parse(String source)
按照指定的格式,把字符串解析为日期。
-
这个类是个抽象类,我们可以用java.text.SimplyDateFormat类,这是DateFormat的子类。
-
构造函数:SimpleDateFormat(String pattern)
-
pattern:
字母 含义 y 年 M 月 d 日 H 时 m 分 s 秒 S 毫秒
"yyyy-MM-dd HH:mm:ss"就是"2020-05-16 19:01:20"的意思
注意: 字母不能改,连接符可以改。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatDemo {
public static void main(String[] args) {
String pattern = "yyyy年MM月dd日 HH时mm分ss秒";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
String stime = simpleDateFormat.format(new Date());
System.out.println(stime);
System.out.println("=====================");
try {
Date date = simpleDateFormat.parse(stime);
System.out.println(date);
} catch (ParseException e) {
e.printStackTrace();
System.out.println(e);
}
}
}
//=========输出=========//
2020年05月16日 19时10分19秒
=====================
Sat May 16 19:10:19 CST 2020
4. Calendar类
java.util.Calendar
- 抽象类,但是提供了一个直接获取实例的方法
Calendar now = Calendar.getInstance();
4.1 Calendar类的方法
-
public int get(int field) 返回指定字段的值
int year = now.get(Calendar.YEAR)
字段 含义 DATE 当前月的第几天 DAY_OF_WEEK 当前周的第几天 DAY_OF_WEEK_IN_MONTH 当前月中的第几个星期 HOUR 12小时制的小时 HOUR_OF_DAY 24小时制的小时 MINUTE 分钟 SECOND 秒 MILLISECOND 毫秒 -
下面四个是设置日期
-
public final void set(int field, int value)
-
public final void set(int year, int month, int date)
-
public final void set(int year, int month, int date, int hourOfDay, int minute)
-
public final void set(int year, int month, int date, int hourOfDay, int minute, int second)
-
abstract void add(int field, int amount) 根据日历的规则,为给定的日历字段添加或减去指定的时间量。
-
Date getTime() 返回一个表示此 Calendar 时间值(从历元至现在的毫秒偏移量)的 Date 对象。
5. System类
java.lang.System
5.1 public static long currentTimeMillis()
获取当前系统时间与1970年1月1日 00:00:00的毫秒差值
5.2 arraycopy()
public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)
- src - 源数组。
- srcPos - 源数组中的起始位置。
- dest - 目标数组。
- destPos - 目标数据中的起始位置。
- length - 要复制的数组元素的数量。
6. StringBuilder类
可变字符序列
6.1 构造函数
- 无参构造,生成一个空的。
StringBuilder sb = new StringBuilder()
- 参数为一个字符串的构造函数,用字符串初始化这个StringBuilder。
- 初始化长度为16。
6.2 常用函数
- sb.append(…),添加任意类型数据的字符串形式。
- sb.toString(),返回sb的字符串形式。
String s = "abc";
StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder(s);
sb2.append("12");
sb1.append("ggg");
sb2.append(sb1);
System.out.println(sb2);
//=============输出=============//
abc12ggg
7. 包装类
装箱、拆箱
用Integer举例
7.1 装箱
把基本数据类型的数据装进包装类
-
构造方法(已过时)
- Integer(int value)
- Integer(String s)
-
静态方法
- Integer.valueOf(int value)
- Integer.valueOf(String s)
7.2 拆箱(成员方法)
在包装类中取出基本数据类型的数据
Integer in = 123
- int in.intValue()
- long in.longValue()
7.3 自动装箱与自动拆箱(JDK 1.5+)
7.4 基本类型与字符串的相互转换
7.4.1 基本类型->字符串
-
基本类型的值+空字符串
String s = 123+"";
-
包装类的静态方法(Integer为例)
Integer.toString(int i)
-
String类的静态方法
String.valueOf(int i)
7.5 字符串->基本类型
-
基本类型的静态方法
Integer.parseInt(String s)
Double.parseDouble(String s)
8. Collection集合
8.1 集合和数组的区别
- 数组长度不可变,集合长度可变。
- 数组中存储的都是同一类型的数据,集合中可以存储不一样类型的对象。
- 数组可以存储基本类型和对象,集合只能存储对象。
8.2 Collection的方法
- add(E) : 添加内容,类似于vector的push_back()。
- clear() : 移除此 collection中的所有元素。
- remove(E) : 从此 collection中移除指定元素的单个实例,不存在的话返回false。
- contains(E) : 如果此 collection 包含指定的元素,则返回 true。
- isEmpty() : 如果此 collection 不包含元素,则返回 true。
- size()
- toArray() : 返回包含此 collection 中所有元素的数组。
8.3 Iterator 迭代器
-
hasNext() 是否有下一个元素。
-
next() 取出下一个元素。
-
Iterator是个接口,对象需要通过Collection对象的.iterator()方法来获取。
package CollectionDemo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class test {
public static void main(String[] args) {
Collection<String> col = new ArrayList<>();
col.add("12");
col.add("46");
col.add("26");
col.add("456");
col.add("356");
Iterator<String> i = col.iterator();
//方法1:通过显式迭代器
while (i.hasNext()) System.out.println(i.next());
//方法2:通过语法糖,增强的for循环,隐式迭代器
//JDK1.5开始
for(String s:col) System.out.println(s);
}
}
Tips : 通过增强的for循环迭代时,不可对集合进行增删操作
9. 泛型
是一种未知的数据类型
- Element E
- Type T
9.1 定义和使用含有泛型的类
9.1.1 定义方式:在类名后面加上
package GenericClassDemo;
public class GenericClass<E> {
private E obj;
public GenericClass(E obj) {
this.obj = obj;
}
public E getObj() {
return obj;
}
public void setObj(E obj) {
this.obj = obj;
}
}
9.1.2 使用:新建对象时在类名后面加上<具体用的类型>
package GenericClassDemo;
public class test {
public static void main(String[] args) {
GenericClass<String> s = new GenericClass<>();
s.setObj("abc");
System.out.println(s.getObj());
}
}
//=============输出==============//
abc
9.1.3 定义含有泛型的方法
泛型定义在方法的修饰符与返回值类型之间。
- 普通泛型方法
//这样就能实现传进来任意类型的参数的功能
public <M> int fun(M m){
System.out.println(m);
return 1;
}
- 静态泛型方法
public static <M> void fun(M m){
System.out.println(m);
}
9.2 定义和使用含有泛型的接口
9.2.1 定义含有泛型的接口
package GenericInterfaceDemo;
public abstract class GenericInterface<E> {
abstract void method(E e);
}
9.2.2 使用含有泛型的接口
-
接口的实现类指定泛型类型
在实现接口时,指定泛型的类型,实现接口的类里面直接使用指定的类型即可。
package GenericInterfaceDemo;
public class GenericInterfaceImpl_1 extends GenericInterface<String> {
@Override
void method(String s) {
System.out.println(s);
}
}
-
接口的实现类跟着泛型走
实现接口时不指定泛型类型。
package GenericInterfaceDemo;
public class GenericInterfaceImpl_2<E> extends GenericInterface<E> {
@Override
void method(E e) {
System.out.println(e);
}
}
9.3 泛型通配符<?>
一旦使用泛型通配符,只能用Object中的方法。
注意:此时只能接受数据,不能往集合中存储数据。不能用来创建对象,只能在方法里使用。
package GenericInterfaceDemo;
import java.util.ArrayList;
import java.util.Iterator;
public class test {
public static void main(String[] args) {
ArrayList<String> l1 = new ArrayList<>();
ArrayList<Integer> l2 = new ArrayList<>();
l1.add("a");
l1.add("b");
l1.add("c");
l2.add(1);
l2.add(2);
l2.add(3);
printArray(l1);
printArray(l2);
}
private static void printArray(ArrayList<?> obj) {
//快速迭代器, 增强for循环
for (Object o : obj) {
System.out.print(o + " ");
}
System.out.println();
//普通迭代器
Iterator<?> iterator = obj.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
System.out.println();
}
}
//===============输出==============//
a b c
a b c
1 2 3
1 2 3
9.4 受限通配符
9.4.1 上限 <? extends 某个类>
表示只接受这个类以及它的子类。
9.4.2 下限 <? super 某个类>
表示只接受这个类以及它的超类。
9.5 Collections类
操作集合的工具类 java.util.Collections
-
Collections.shuffle(List<?> list)
使用指定的随机源对List进行置换,将List随机打乱。