Day01

1. Object类：所有类的父类

  1 Object类中toString方法： sout方法就是调用了toString方法，一般重写toString方法得到内容
  2 Object类中equals方法 ：
 【Objects类方法】Objects.equals(a,b) 优化 判断是否相等空指针的问题【Object类方法】 a.equals(b)
3.public static <T> T requireNonNull(T obj):查看指定引用对象不是null。
等同于下面这代码，下次代码合法性判断就不用写下面这个方法，就直接用Objects.requireNonNull()非空判断
public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

2. Date类：日期类

java.util.Date类 表示特定的瞬间，精确到毫秒。
public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public long getTime() 把日期对象转换成对应的时间毫秒值。

3. DateFormat类：日期类和字符串之间可以转换

 1.java.text.DateFormat 是日期/时间格式化子类的抽象类【不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。】
完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。
 2.java.text.SimpleDateFormat中的构造方法public SimpleDateFormat(String pattern)
参数pattern是一个字符串，代表日期时间的自定义格式。最常用： DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
 3.DateFormat类的常用方法有：
public String format(Date date)：将Date对象格式化为字符串。
public Date parse(String source)：将字符串解析为Date对象。
代码参考day01【Object类、常用API】

4.Calendar类：日历类的出现就很少用日期类，格式的定义

1.Calendar为抽象类，而是通过静态方法创建，返回子类对象，如下：

Calendar静态方法

public static Calendar getInstance()：使用默认时区和语言环境获得一个日历
常用方法
根据Calendar类的API文档，常用方法有：

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对象。

5.System类：包含大量与系统操作的类

常用的方法有：

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

6.StringBuilder类：与对String类的优化，相当于Sring的字节缓冲区，可以调用方法进行改变序列的长度和内容

java.lang.StringBuilder

根据StringBuilder的API文档，
常用构造方法有2个：
public StringBuilder()：构造一个空的StringBuilder容器。
public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去

StringBuilder常用的方法有2个：

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象。
public StringBuilder reverse() 将内容进行反转

7.包装类：基本类型与对应的包装类，进行装箱和拆箱。

1.由来：基本数据类型使用起来很方便，但是没有对应的方法操作这些数据，
      所以我们用这个类，把基本数据类型包装起来，这个类叫做包装类。
       包装类中定义一些方法，用来操作基本数据类型的数据。

2.   装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        构造方法:
            Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
            Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
                传递的字符串,必须是基本类型的字符串,否则会抛出异常 "100" 正确  "a" 抛异常
        静态方法:
            static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
            static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
    拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        成员方法:
            int intValue() 以 int 类型返回该 Integer 的值。

3.    自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
    JDK1.5之后出现的新特性

4.1 基本类型与字符串类型之间的相互转换
    基本类型->字符串(String)
        1.基本类型的值+""  最简单的方法(工作中常用)
        2.包装类的静态方法toString(参数),不是Object类的toString() 重载
            static String toString(int i) 返回一个表示指定整数的 String 对象。
        3.String类的静态方法valueOf(参数)
            static String valueOf(int i) 返回 int 参数的字符串表示形式。
4.2 字符串(String)->基本类型
        使用包装类的静态方法parseXXX("字符串");
            Integer类: static int parseInt(String s)
            Double类: static double parseDouble(String s)

8.Arrays类：java.util.Arrays

public Sring toString(int [] a) 将数组的内容已字符串的形式打印出来

9.String类：java.lang.String

public char[] toCharArray]() 将数组的内容已字符串的形式打印出来
public int length()获取长度
public char charAt(int index) 获取索引处的char值

Day02

1.Collection集合

1. 容器有集合和数组，集合存储不同类型的对象，数组存储同一类型的元素
2. 集合 ：单列集合根接口Collection和双列集合根接口Map 
3. 单列集合两个子接口：List(有序·可重复) （实现类：Arraylist和LinkedList，Vector集合继承List接口）
                      Set(无序·不重复)（实现类：HashSet和TreeSet，LinkedHashSet继承实现类HashSet）
4.双列集合根接口Map ：

image.png

image.png

java.util.Collection 类常用的方法

增
public boolean add(E e)`：  把给定的对象添加到当前集合中 。
删
public boolean remove(E e)`: 把给定的对象在当前集合中删除。
public void clear()` :清空集合中所有的元素。
查
public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。
public boolean retainAll(Collection<?> c)`: 仅保留此 collection 中那些也包含在指定 collection 的元素
【保留两个集合的交集】
空
public boolean isEmpty()`: 判断当前集合是否为空。
等
public boolean equals(E e)：比较此 collection 与指定对象是否相等
数
public int size()`: 返回集合中元素的个数。
public Object[] toArray()`: 把集合中的元素，存储到数组中。

其他可选用
增
public boolean addAll(Collection<? extends E>) 指定 collection 中的所有元素都添加到此  
删
public boolean removeAll(Collection<? extends E>)`: 把给定的对象在当前集合中删除。
查
public boolean containsAll(Collect<?> e)`:collection 包含指定 collection 中的所有元素，则返回 true

2.迭代器：用于迭代访问（即遍历）Collection中的元素

3.增强for：专门用遍历数组和集合的，其实是个Iterator迭代器，在遍历的过程中，不能对集合中的元素进行增删操作。

4.泛型：1.含有泛型的类 2.含有泛型的方法 3.含有泛型的接口 4.泛型的通配符

4.1含有泛型的类

含有泛型的类：
修饰符 class 类名<代表泛型的变量> {  }

class ArrayList<E>{ 
    public boolean add(E e){ }

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

4.2 含有泛型的方法

定义格式：

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

例如，使用格式：调用方法时，确定泛型的类型

public class MyGenericMethod {    
    public <E> void show(E e) {
        System.out.println(mvp.getClass());
    }
    
    public <E> E show2(E e) {   
        return e;
    }
}

4.3 含有泛型的接口

格式 ：修饰符 interface接口名<代表泛型的变量> {  }

public interface MyGenericInterface<E>{
    public abstract void add(E e);
    
    public abstract E getE();  
}

1、定义类时确定泛型的类型 

public class MyImp1 implements MyGenericInterface<String> {
    @Override
    public void add(String e) {
        // 省略...
    }

    @Override
    public String getE() {
        return null;
    }
}

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public class MyImp2<E> implements MyGenericInterface<E> {
    @Override
    public void add(E e) {
         // 省略...
    }

    @Override
    public E getE() {
        return null;
    }
}

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

4.4 泛型的通配符<?>

1.泛型的通配符的基本使用：不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。
比如下面的test（ArrayList<?> list）方法 ，同时接受String 和Integer类型 就用通配符来解决接受类型的问题。


public class GenericMethod {
    public static void main(String[] args) {
        ArrayList<String> stringlist = new ArrayList<>();
        stringlist.add("Hello");
        stringlist.add("Java");

        ArrayList<Integer> integerlist =new ArrayList<>();
        integerlist.add(1);
        integerlist.add(2);
        
        test(stringlist);
        test(integerlist);
    }
    public static  void  test(ArrayList<?> list){
        for (Object o : list) {
            System.out.println(o);
        }
    }
}

2.通配符高级使用----受限泛型 【能看懂即可】
泛型的上限：
格式： 类型名称 <? extends 类 > 对象名称
意义： 只能接收该类型及其子类

泛型的下限：
格式： 类型名称 <? super 类 > 对象名称
意义： 只能接收该类型及其父类型

// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

Day03

1.数据结构

1.栈 ：弹夹，先进后出
2.队列：排队，先进先出
3.数组：在内存中开辟一段连续的空间
        查找元素快：通过索引，可以快速访问指定位置的元素
        增删元素慢：需要创建新数组开辟新内存，把原数组元素根据索引复制到新数组索引对应的位置
4.链表:一个节点由数据域和指针域组成
        查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
        增删快：只需要修改元素的指针域即可。
5.二叉树：是每个结点不超过2的有序树（tree） 。左子树小，右子树大
              ：红黑树：趋近平衡树，查找速度特别快

2.List集合 【ArrayList（查询），LinkedList（增删，有大量首尾操作的方法）】

特点：存取有序，可重复，有索引

常用方法（继承Collection接口所有的方法，还有一些根据索引操作集合特有方法）：
【特有的方法：】
public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E get(int index) :返回集合中指定位置的元素。
public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

1.ArrayList集合：元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以 ArrayList 是最常用的集合。
2.LinkedList集合：实际开发中对一个集合元素的添加与删除经常涉及到首尾操作LinkedList提供了大量首尾操作的方法。

 【LinkedList 特有方法 了解即可】
public void addFirst(E e) :将指定元素插入此列表的开头。
public void addLast(E e) :将指定元素添加到此列表的结尾。
public void push(E e) :将元素推入此列表所表示的堆栈。等同于 addFirst（）；

public E getFirst() :返回此列表的第一个元素。
public E getLast() :返回此列表的最后一个元素。

public E removeFirst() :移除并返回此列表的第一个元素。
public E removeLast() :移除并返回此列表的最后一个元素。
public E pop() :从此列表所表示的堆栈处弹出一个元素。相当于removeFirst（）  

public boolean isEmpty() ：如果列表不包含元素，则返回true。

Vector 与 List 不同 
List和Vector（都是接口），因为使用是的功能或者调用的方法都是差不多的，那么大家就会去找它们的区别。
1、List是在jdk1.2以后推出的，而Vector是在jdk1.0推出的
2、List采用的是异步处理方式，性能高，而Vector采用的是同步处理方式，性能低
3、List属于非线程安全，Vector属于线程安全
简单点说就是：
如果你需要考虑到性能高一点，快速一点，又不需要考虑线程，那么就用List，反之用Vector

3.Set集合【HashSet，LinkedHashSet】

特点：无序（存取顺序可能不一致），不重复
原理：用add()方法会调用元素的hashhode方法和equals方法，判断元素是否重复，
       如果自定义类，必须重写hashCode方法和equals方法
 1.HashSet 底层是一个哈希表，查询特别快
 2.哈希表：1.8之前 哈希表 = 数组+链表 1.8之后 哈希表 = 数组 + 链表 （长度大于8 自动转换成红黑树），
          数组存储对象的哈希值，对象的内容通过链表/红黑树连接一起
  哈希值：一个十进制的整数，系统随机给对象的地址值，是模拟出逻辑地址，不是数据存储的实际物理地址 
  Object类有一个int hashCode（）返回对象的哈希码值 ，toString（）返回的是十六进制的，将十六进制转十进展就是哈希值。
4.LinkedHashSet：有序的不可重复

哈希表

4.可变参数

类型已知，传入参数个数不确定用可变参数定义，可变参数底层原理是数组
注意事项：1.只能有一个可变参数 举例1，
          2.如果方法参数有多个，那么可变参数必须写在参数列表的末尾见 举例2 
          3.可变参数的终极写法 举例3
举例1.
 public static void demo01 (int...arr){}
举例2.
 public static void demo02 (String a,double c,int...arr){ }
举例3.
 public static void demo03 (Object...objs){}

5.Collections

1.java.utils.Collections是集合工具类
用来对集合进行操作。部分方法如下：

public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
1.sort方法实现Comparable接口中的compareTo的方法，
 如果要自定义类实现集合的排序，需要继承Comparable接口，重写compareTo方法。
2.
    - java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：
        public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
     Comparator和Comparable的区别
        Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
        Comparator:相当于找一个第三方的裁判,比较两个，重写compareTo（）方法
    Comparator的排序规则:
        o1-o2:升序

Day04

1.Map【HashMap,LinkedHashMap】

1.HashMap集合和LinkedHashMap的特点:

1.HashMap集合底层是哈希表:查询的速度特别的快
           JDK1.8之前:数组+单向链表
           JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度
 2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
         java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合
        LinkedHashMap的特点:
1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的

2.Map接口常用方法：

public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
boolean containsKey(Object key) 判断集合中是否包含指定的键。
public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

3.Hashtable

  java.util.Hashtable<K,V>集合 implements Map<K,V>接口

    Hashtable:底层也是一个哈希表,是一个线程安全的集合,是单线程集合,速度慢
    HashMap:底层是一个哈希表,是一个线程不安全的集合,是多线程的集合,速度快

    HashMap集合(之前学的所有的集合):可以存储null值,null键
    Hashtable集合,不能存储null值,null键

    Hashtable和Vector集合一样,在jdk1.2版本之后被更先进的集合(HashMap,ArrayList)取代了
    Hashtable的子类Properties依然活跃在历史舞台
    Properties集合是一个唯一和IO流相结合的集合

4.Debugger

  Debug调试程序:
        可以让代码逐行执行,查看代码执行的过程,调试程序中出现的bug
    使用方式:
        在行号的右边,鼠标左键单击,添加断点(每个方法的第一行,哪里有bug添加到哪里)
        右键,选择Debug执行程序
        程序就会停留在添加的第一个断点处
    执行程序:
        f8:逐行执行程序
        f7:进入到方法中
        shift+f8:跳出方法
        f9:跳到下一个断点,如果没有下一个断点,那么就结束程序
        ctrl+f2:退出debug模式,停止程序
        Console:切换到控制台