public class Person {  
    private String name;
    private int age;

    // 覆盖重写toString方法
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

1.2 equals方法

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

调用成员方法 equals 并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

默认地址比较：如果没有覆盖重写 equals 方法，那么 Object 类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。；
对象内容比较：如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写 equals 方法。

在IntelliJ IDEA中，可以使用 Code 菜单中的 Generate… 选项，也可以使用快捷键 alt+insert ，并选择 equals() and hashCode() 进行自动代码生成。

代码实现：覆盖重写 equals 方法：

public class Person {	
	private String name;
	private int age;
	
    // 覆盖重写equals方法
    @Override
    public boolean equals(Object o) {
        // 如果对象地址一样，则认为相同
        if (this == o)
            return true;
        
        // 如果参数为空，或者类型信息不一样，则认为不同
        if (o == null || getClass() != o.getClass())
            return false;
        
        // 转换为当前类型
        Person person = (Person) o;
        
        // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age && Objects.equals(name, person.name);
    }
}

1.3 String类中的equals方法与Object类中的equals方法的不同点

String 类中的 equals 方法是用来判断两个对象的内容是否相同，而 Object 类中的 equals 方法是用来判断两个对象是否是同一个对象，所谓同一个对象指的是内存中的同一块存储空间。

1.4 StringBuilder类与String类的区别

String 类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响。

StringBuilder 又称为可变字符序列，是JDK5.0中新增加的一个类，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。即它是一个容器，容器中可以装很多字符串，并且能够对其中的字符串进行各种操作。它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容， StringBuilder 会自动维护数组的扩容。

2. 时间日期类

2.1 Date类

java.util.Date 类表示特定的瞬间，精确到毫秒。

继续查阅 Date 类的描述，发现 Date 拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

public Date() ：分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public Date(long date) ：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。
public long getTime() : 把日期对象转换成对应的时间毫秒值。

代码实现：获取当前的日期,并把这个日期转换为指定格式的字符串：

public class DateTest {
    public static void main(String[] args) {
        //获取当前日期对象 now;
        Date now = new Date();
        
        //创建SimpleDateFormat对象 df,并制定日期格式
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        //调用df的format(Date  date) 方法,传入now; 接收返回的字符串
        String datestr = df.format(now);
        System.out.println(datestr);
    }
}

2.2 DateFormat类

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在 Date 对象与 String 对象之间进行来回转换。

格式化：按照指定的格式，从 Date 对象转换为 String 对象。
解析：按照指定的格式，从 String 对象转换为 Date 对象。

由于 DateFormat 为抽象类，不能直接使用，所以需要常用的子类 java.text.SimpleDateFormat 。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

public SimpleDateFormat(String pattern) ：用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat ，参数 pattern 是一个字符串，代表日期时间的自定义格式。
public String format(Date date) ：将 Date 对象格式化为字符串。
public Date parse(String source) ：将字符串解析为 Date 对象。

常用的格式规则为：

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

代码实现：使用 SimpleDateFormat 类,把2020-03-16转换为2020年03月16日：

public class DateFormatTest {
    public static void main(String[] args) throws ParseException {
        //创建SimpleDateFormat对象df1,指定日期模式为yyyy-MM-dd
        SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
        
        //调用df1的parse(String str)方法传入2020-03-16,得到对应日期类型
        Date date = df1.parse("2020-03-16");
       
        //创建日期格式化对象df2,在获取格式化对象时可以指定风格
        DateFormat df2 = new SimpleDateFormat("yyyy年MM月dd日");
        
        //调用df2的format(Date date) 传入刚才转换的日期
        String str = df2.format(date);
        System.out.println(str);
    }
}

2.3 Calendar类

java.util.Calendar 是日历类，在 Date 后出现，替换掉了许多 Date 的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

Calendar 为抽象类，由于语言敏感性， Calendar 类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象

public static Calendar getInstance() ：使用默认时区和语言环境获得一个日历
public int get(int field) ：返回给定日历字段的值
public void set(int field, int value) ：将给定的日历字段设置为给定值
public abstract void add(int field, int amount) ：根据日历的规则，为给定的日历字段添加或减去指定的时间量
public Date getTime() ：返回一个表示此 Calendar 时间值（从历元到现在的毫秒偏移量）的 Date 对象

Calendar 类中提供很多成员常量，代表给定的日历字段：

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

代码实现：用程序判断2020年03月16日是星期几：

public class CalendarTest {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar c = Calendar.getInstance();
        
        //将给定的日历字段设置到Calendar对象中
        c.set(Calendar.YEAR, 2020);
        c.set(Calendar.MONTH, 03);
        c.set(Calendar.DATE, 16);
        
        //设置年、月、日、星期
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int date = c.get(Calendar.DATE);
        char week = getWeek(c.get(Calendar.DAY_OF_WEEK));
        
        //输出结果
        System.out.println(year+"年"+month+"月"+date+"日是星期"+week);
    }
    
    //定义方法，获取星期汉字
    public static char getWeek(int a){
        char[] c = {' ','日','一','二','三','四','五','六'};
        return c[a];
    }
}

3. System类

java.lang.System 类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，常用的方法有：

public static long currentTimeMillis() ：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将数组中指定的数据拷贝到另一个数组中。

3.1 currentTimeMillis方法

用法： currentTimeMillis 就是：获取当前系统时间与1970年01月01日00:00之间的毫秒差值。

3.2 arraycopy方法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将数组中指定的数据拷贝到另一个数组中。

System.arraycopy 方法具有5个参数，含义分别为：

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

4. StringBuilder类

java.lang.StringBuilder 的API， StringBuilder 又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

StringBuilder 是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。 StringBuilder 会自动维护数组的扩容。

public StringBuilder() ：构造一个空的 StringBuilder 容器。
public StringBuilder(String str) ：构造一个 StringBuilder 容器，并将字符串添加进去。
public StringBuilder append(...) ：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString() ：将当前 StringBuilder 对象转换为 String 对象。

5. 包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

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

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

public static byte parseByte(String s) ：将字符串参数转换为对应的 byte 基本类型。
public static short parseShort(String s) ：将字符串参数转换为对应的 short 基本类型。
public static int parseInt(String s) ：将字符串参数转换为对应的 int 基本类型。
public static long parseLong(String s) ：将字符串参数转换为对应的 long 基本类型。
public static float parseFloat(String s) ：将字符串参数转换为对应的 float 基本类型。
public static double parseDouble(String s) ：将字符串参数转换为对应的 double 基本类型。
public static boolean parseBoolean(String s) ：将字符串参数转换为对应的 boolean 基本类型。

6. Collection集合

集合按照其存储结构可以分为两大类，分别是单列集合 java.util.Collection 和双列集合 java.util.Map 。

Collection ：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是 java.util.List 和 java.util.Set 。其中， List 的特点是元素有序、元素可重复。 Set 的特点是元素无序，而且不可重复。 List 接口的主要实现类有 java.util.ArrayList 和 java.util.LinkedList ， Set 接口的主要实现类有 java.util.HashSet 和 java.util.TreeSet 。

Collection 是所有单列集合的父接口，因此在 Collection 中定义了单列集合( List 和 Set )通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

public boolean add(E e) ：把给定的对象添加到当前集合中。
public void clear() :清空集合中所有的元素。
public boolean remove(E e) : 把给定的对象在当前集合中删除。
public boolean contains(E e) : 判断当前集合中是否包含给定的对象。
public boolean isEmpty() : 判断当前集合是否为空。
public int size() : 返回集合中元素的个数。
public Object[] toArray() : 把集合中的元素，存储到数组中。

代码实现： Collection 集合数组转集合：

public class CollectionTest {
    public static void main(String[] args) {
        //定义int数组
        int[] arr = {1,2,3,4,5};
        ArrayList<Integer> list = listTest(arr);
        System.out.println(list);
    }

    public static ArrayList<Integer> listTest(int[] arr) {
        //定义集合
        ArrayList<Integer> list = new ArrayList<Integer>();
        
        //遍历数组，把元素依次添加到集合当中
        for (int a : arr) {
            list.add(a);
        }
        return list;
    }
}

7. Iterator迭代器

当遍历集合时，首先通过调用集合的 Iterator() 方法获得迭代器对象，然后使用 hasNext() 方法判断集合中是否存在下一个元素，如果存在，则调用 next() 方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

Iterator 迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，在调用 Iterator 的 next() 方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的 next() 方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用 next() 方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到 hasNext() 方法返回false，表示到达了集合的末尾，终止对元素的遍历。

7.1 Iterator接口

Iterator 接口也是Java集合中的一员，但它与 Collection 、 Map 接口有所不同， Collection 接口与 Map 接口主要用于存储元素，而 Iterator 主要用于迭代访问（即遍历） Collection 中的元素，因此 Iterator 对象也被称为迭代器。

public Iterator iterator() : 获取集合对应的迭代器，用来遍历集合中的元素的。
public E next() :返回迭代的下一个元素。
public boolean hasNext() :如果仍有元素可以迭代，则返回 true。

代码实现：使用 iterator 迭代集合中元素：

public class IteratorDemo {
  	public static void main(String[] args) {
        // 使用多态方式创建对象
        Collection<String> col = new ArrayList<String>();

        // 添加元素到集合
        col.add("玩家1");
        col.add("玩家2");
        col.add("玩家3");
        
        // 使用迭代器遍历
        Iterator<String> it = col.iterator();
        
        // 判断是否有迭代元素
        while(it.hasNext()){ 
            //获取迭代出的元素
            String s = it.next();
            System.out.println(s);
        }
    }
}

7.2 增强for

增强 for 循环(也称 for each 循环)是JDK1.5以后出来的一个高级 for 循环，专门用来遍历数组和集合的。它的内部原理其实是个 iterator 迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。它用于遍历 Collection 和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

// 基本格式
for(元素的数据类型  变量 : Collection集合or数组){ 
  	// 代码
}

8. 泛型

在学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成 Object 类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

泛型：可以在类或方法中预支地使用未知的类型。好处是：将运行时期的 ClassCastException ，转移到了编译时期变成了编译失败；避免了类型强转的麻烦。

8.1 泛型的定义

定义常见几种格式：

// 1.定义和使用含有泛型的类
修饰符 class 类名<代表泛型的变量> {  }

// 举例：ArrayList集合
class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

// 2.定义和使用含有泛型的方法
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

// 举例
public class MyMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

// 3.含有泛型的接口
修饰符 interface接口名<代表泛型的变量> {  }

// 举例
public interface MyInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

8.2 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符 <?> 表示。但是一旦使用泛型的通配符后，只能使用 Object 类中的共性方法，集合中元素自身方法无法使用。

泛型的通配符：不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。此时只能接受数据,不能往该集合中存储数据。

8.3 受限泛型

泛型的上限：

格式：类型名称<? extends 类 > 对象名称
意义：只能接受该类型以及子类

泛型的下限：

格式：类型名称<? super 类 > 对象名称
意义：只能接受改类型及其父类型

欢迎关注博主，欢迎互粉，一起学习！

感谢您的阅读，不足之处欢迎指正！

不撸先疯。

发布了10 篇原创文章 · 获赞 36 · 访问量 1万+

私信关注

Java从入门到高级（第一天）

1. Object类

1.1 toString方法