java.lang.Object类               类Object是类层次结构的根（最顶层）类。每一类都是用Object作为超（父）类。所有对象（包括数组）都实现这个类的方法。               String toString() 返回这个类的方法,打印对象的信息。重写前打印的是包名类名@地址值；重写后打印的是对象中的属性值。               直接打印对象名字其实就是调用对象的toString()方法p=p.toString();               看一个类是否重写了toString方法，直接打印这个类对应对象的名字即可，如果没有重写toString方法，那么打印的就是对象的地址值（默认）               如果重写toString方法，那么就按照重写的方法打印。               boolean equals(Object obj)指示其他某个对象是否与此对象"相等"。重写前比较对象的地址值；重写后比较的是对象中的属性值。              Object类 equals方法的源码：                                                            public boolean equals(Object obj){                                                                     return (this == obj);                                                        }                                                       参数：Object obj：可以传递任意的对象                                                       方法体：                                                                    ==：比较运算符，返回的就是一个布尔值 true，false                                                                    基本类型比较值，引用类型比较对象的地址值                                                                    this是调用equals方法的那个对象，obj是传过来的参数             Objects类的equals方法：对两个对象进行比较，防止空指针异常。比较两个对象是否相同，但是加了一些健壮性的判断。                               

               public static boolean equals(Object a, Object b) {return (a == b) || (a != null && a.equals(b));}

     java.util.Date:表示日期和时间的类
               类Date表示特定的瞬间，精确到毫秒。  毫秒：千分之一秒 1000毫秒=1秒；
               特定的瞬间：一个时间点，一刹那时间。  毫秒的作用：可以对时间和日期进行计算。
               2099-01-03到2088-01-01中间一共多少天
               可以日期转换为毫秒进行计算，计算完毕，再把毫秒转换成日期。
               把日期转换成毫秒：
                    当前的日期：2088-01-01
                    时间原点(0毫秒)：1970年1月1日00：00：00(英国格林威治)                     
                    就是计算当前日期到时间原点之间一共经历了多少毫秒(374267540068L)
               注意：
                    中国属于东八区，会把时间增加8个小时1970年1月1日08：00：00
              把毫秒转换成日期：
                    1天=24*60*60=68400秒=68400*1000=68400000毫秒                      

               System.out.println(System.currentTimeMillis());//获取当前系统时间到1970年1月1日00：00：00经历了多少毫秒

                    
             Date类的空参数构造方法：  Date()获取的就是当前系统的日期和时间 
              Date类的带参数构造方法：  Date(long date)传递毫秒值（long类型值），把毫秒值转化为Date日期。（从1970起）
              long getTime() 把日期转换为毫秒(相当于System.CurrentTimeMillis())
                         返回自1970年1月1日00：00：00GMT以来此Date对象表示的毫秒数。
              String toLocalString(); 根据本地格式转化日期对象。
         不仅仅是Java，几乎所有的语言的时间都是从这一刻开始算起的。原因:java起源于UNIX系统，而UNIX认为1970年1月1日0点是时间纪元。
        
java.text.DateFormat:是时间/日期格式化子类的抽象类
作用：     格式化（也就是日期->文本）、解析（文本->时间）
构造方法：   SimpleDateFormat(String s); 根据指定模板传进日期格式化对象。
成员方法：
           String format(Date date)按照指定的模式，把Date日期，格式化为符合模式的字符串。
                   1.创建SimpleDateFormat对象，构造方法中传递的模式。
                   2.调用SimpleDateFormat对象中的format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）
           Date parse(String source)把符合模式的字符串，解析为Date日期
                   1.创建SimpleDateFormat对象，构造方法中传递的模式。
                   2.调用SimpleDateFormat对象中的parse，把符合构造方法中模式的字符串，解析为日期。
DateFormat类是一个抽象类，无法直接创建对象使用，但可以使用Dateformat的子类
java.text.SimpleDateFormat extends DateFormat
构造方法：
      SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
      参数： String pattern：传递指定的模式
      模式： 区分大小写
         y年 M月 d天 H时 m分 s秒
         写对应的模式，会把模式替换为对应的日期和时间"yyyy-MM-dd HH-mm-ss" "yyyy年MM月dd日 HH时mm分ss秒" 
      注意：模式中的字母不能更改，连接模式的符号可以更改。
java.util.Calendar类：日历类
     Calendar类是一个抽象类，里面提供了很多操作日历字段的方法（YEAR、MONTH、DAY_OF_MONTH、HOUR）
     Calendar类无法直接创建对象使用，里面有一个静态方法叫getInstance()，该方法返回了Calendar类的子类对象
     static Calendar getInstance() 使用默认时区和语言环境获得一个日历。
java.util.Calendar类的成员方法：
         public int get(int field):返回给定日历字段的值。
         public void set(int field,int value):将给定的日历字段设置为给定的值。（set有一个重载方法可以同时设置年月日）
         public abstract void add(int field,int amount):根据日历的规则，为给定的日历字段添加或者减去指定的时间量。
                   int field：传递指定的日历字段
                   int amount:增加/减少的值（正、负）
         public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象；将日历对象转换为日期对象。
java.lang.System类提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

          public static long currenTimeMIllis():返回以毫秒为单位的当前时间。（返回的时间值可以当时间戳或者文件名进行使用）
          public static void arrayCopy(Object src,int srcPos,Object edst,int desPos,int length):将数组中指定的
             数据拷贝到另一个数组中。

java.lang.StringBuffer类

     字符串缓冲区，可以提高字符串的操作效率（看成一个长度可以变化的字符串）
     底层也是一个数组，但是没有被final修饰，可以改变长度: byte[] value=new byte[16];
     StringBuilder在内存中始终是一个数组，占用空间少，效率高。如果超出了StringBuilder的容量，会自动地扩容。 
     构造方法：
                   public StringBuilder():构造一个空的StringBuiler容器；
                   public StringBuilder(String str):构造一个StringBuiler容器，并将字符串添加进去。
     成员方法：
          public StringBuilder append(...):添加任意类型的字符串形式，并返回当前对象自身。使用append方法无需接收返回值
              参数：可以是任意类型。可以链式编程
         StringBuilder reverse();反转内容，使用reverse方法无需接收返回值
             String toString();将缓存区内容转换为字符串。 

StringBuiler和String可以相互转换：
     String-》StringBuilder :可以使用StringBuilder的构造方法StringBuilder(String str)构造一个字符串生成器，
并初始化为指定的字符串内容。
     StringBuilder-》String:可以使用StringBuilder中的toString 方法
         public String toString():当前StringBuilder对象转换为String对象。

包装类：基本数据类型的数据，使用起来非常地方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型数据包装起来，
     这个类叫包装类，在包装类中可以定义一些方法，用来操作基本类型的数据。          装箱：把基本类型的数据，包装到包装类中（基本类型的数据-》包装类）                   构造方法：                                   Interger(int value) 构造一个新分配的Integer对象，它表示指定的int值                                   Integer(String s) 它表示String参数所指的int值； 传递的字符串，必须是基本类型的字符串否则会抛出异常                    静态方法：                                   static Integer valueOf(int i)返回一个表示指定的 int值的Integer实例                                   static String valueOf(String s) 返回保存指定的String 的值的Integer对象。          拆箱：在包装类中取出基本类型的数据（包装类-》基本数据类型）                     成员方法：int  intValue()   以int类型返回该Integer的值。          自动装箱与拆箱：                    基本类型的数据和包装类之间可以自动的相互转换。JDK1.5之后出现的新特性。
                   自动装箱：直接把int类型的整数赋值给包装类：                              Integer in=1；就相当于 Integer in=new Integer(1);                    自动拆箱：in是包装类无法直接参与晕眩，可以自动转换为基本类型的数据，再参与运算in+2;相当于in.inValue() +2=3;                                    in=in+2;就相当于in=new Integer(3)自动装箱                    ArrayList集合无法直接储存整数，可以储存Integer包装类                                     ArrayList<Integer> list=new ArrayList<>();                                                  list.add(1);//自动装箱相当于list.add(new Integer(1));                                                int a=list.get(0);//自动拆箱相当于 list.get(0).intValue(); 基本类型转换为String：                   方法一：  基本类型直接与""相连接即可；如：34+""                    方法二： 使用包装类中的静态方法             static String toString(int i)返回一个指定整数的String对象。                    方法三：使用String类中的静态方法： 使用包装类中的静态方法static String valueOf(int i)返回int参数的字符串表示形式 String转换成对应的基本类型：除了Character类之外，其他所有包装类都具有parseXxx 静态方法可以将字符串参数转换为对应的基本类型：                                       Integer类：   static int parseInt(String s)

---

集合和数组的区别：               集合是java提供的一种容器，可以用来储存多个数据。数组的长度是固定的，集合的长度是可变的。               数组中储存的是同一种类型的元素，可以储存基本数据类型值。集合储存的都是对象。而对象的类型可以是不一致的。在开发中一般当对象多的时候，使用集合进行储存。   集合框架的学习方式：      1.学习顶层接口/抽象类中共性的方法，所有子类都可以使用。      2.使用底层：顶层不是接口就是抽象类，无法创建对象使用底层的子类创建对象使用。   Collection接口      定义的是所有单列集合中共性的方法；所有的单列集合都可以使用共性的方法，没有带索引的方法。有两个子接口List和Set               List接口：                    1.有序的集合（存储和取出元素顺序相同） 2.允许存储重复的元素 3.有索引，可以使用普通的for循环遍历                                    Vector集合                    ArrayList集合  ：底层是数组实现的，查询快增删慢                                   LinkedList集合：底层是链表实现的，查询慢，增删快。                Set接口                    1.不允许存储重复元素  2.没有索引（不能使用普通的for循环遍历）                     3.无序的集合（储存和取出元素的顺序有可能不一致）                    TreeSet集合：底层是二叉树实现的，一般用于排序                    HashSet集合：底层是哈希表+（红黑树）实现的，无索引，不可以存储重复元素，存取无序                              |                    LinkedHashSet集合：底层是哈希表+链表实现的，无索引，不可以存储重复元素、可以保证存储顺序。                boolean add(E e):   向集合中添加元素              boolean remove(E e); 删除集合中的某个元素；               void clear();  清空集合所有的元素               boolean contains(E e):判断集合中是否包含某个元素。               boolean isEmpty(); 判断集合是否为空                 int   size() ：  获取集合的长度               Object []  toArray(); 将集合转换成一个数组 java.util.Iterator接口：迭代器（对集合进行遍历） 两个常用的方法：                    boolean hasNext()  如果仍有元素可以迭代，则返回true                                   判断集合中还有没有下一个元素，有就返回true，没有就返回false；                              E next()  返回迭代的下一个元素。                                   取出集合中的下一个元素。（没有元素，则会抛出NoSuch ElementException没有元素异常）                                   它做了两件事：1.取处下一个元素2.会把指针向后移动一位。                    Iterator迭代器是一个接口，无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方法比较特殊。 Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现类对象。                  Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。获取迭代器的实现类对象，并且会把指针(索引)指向集合的-1索引  迭代器的使用步骤：                         1.使用集合中方法iterator() 获取迭代器的实现类对象，使用Iterator接口接收(多态)。                                   Collecyion<E> coll=new ArrayList<E>();                                   Iterator<E> it=coll.iterator();                         2.使用Iterator接口中的方法hasNext判断还有没有下一元素。                          3.使用Iterator接口中的方法next出集合中的下一个元素。 增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写，是JDK1.5之后出现的新特性。 Collection<E> extends Iterable<E>:所有单列集合都可以使用增强for循环 public interface Iterable<T> 实现这个接口允许对象成为"foreach"语句的目标；增强for循环：用来遍历集合和数组 格式：for（集合/数组的数据类型  变量名：集合名/数组名）{ System.out.print(变量名)；  }   泛型：是一种位置的数据类型，当我们不知到使用什么数据了类型的时候，可以使用泛型；  泛型也可以看出是一种变量，用来接收数据类型：  E e：Element 元素          T t:Type  元素 ArrayList集合在定义的时候，不知道集合都会存储什么类型的数据，所以类型使用泛型。(不写<E>默认为Object类型)   创建集合对象，使用泛型：          好处：1.避免了类型转换的麻烦，储存的是什么类型，取处的就是什么类型；                   2.把运行期异常(代码运行之后会抛出的异常),提升到了编译器(写代码的时候会报错)          弊端：泛型是什么类型，只能储存什么类型的数据。 创建集合对象，不使用泛型：          好处：集合不使用泛型，默认的类型就是Object类型，可以储存任意类型的数据。          弊端：不安全，会引发异常。                    

                    比如向下转型，调用子类方法出错：String str=(String)obj;
                    System.out.println(str.length());

                                      java.base/java.lang.Integer cannot be cast to java.base/java.lang.String 定义一个含有泛型的类：public class GenericClass<E>{  private E name;...} 定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间。 格式：  修饰符 <泛型>  返回值类型 方法名（参数列表（使用泛型））{方法体}

     public <M> void method01(M m){System.out.println(m);}

含有泛型的接口定义格式： 修饰符 interface 接口名<代表泛型的变量>{   }    
         例如：   public interface MyInterface<E>{ public abstract void add(E e);}
含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型。
     Scanner类实现了Iterator接口，并指定接口的泛型为String,所以重写的next方法泛型默认就是String
               public final class Scanner implements Iterator<String>{  public String next(){...}}
含有泛型的接口，第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走，就相当于定义了含有泛型的类，创建
               对象的时候确定泛型的类型。
                                        public interface list<E>{
                                                              boolean add(E e);
                                                               E get(int index);
                                             }

                                          public class ArrayList<E>  implements list<E>{                                                                 public boolean add(E e){}                                                                  public E get(int index){}                                                 }   泛型通配符： 当使用泛型通配符或着接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示，但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合元素自身方法无法使用。                    只能接受数据，不能往该集合中存储数据；不能创建对象使用，只能作为方法的参数使用（泛型没有继承的概念）          定义一个方法，能遍历所有类型的ArrayList集合，这时候我们不知道ArrayLilst集合使用什么数据类型，可以泛型的通配符？来接收数据类型 泛型的上限限定： ？extends E 代表使用的泛型只能时E类型的子类/本身 泛型的下限限定： ？super E 代表使用的泛型只能是E类型的父类/本身  

---

数据结构：    栈：先进后出，入口和出口在同一侧；   队列：先进先出；                     数组：查询快：数组的地址是连续的，我们可以通过数组的首地址找到数组，通过数组的索引可以快速查找到某一个元素。                              增删慢：数组的长度是固定的，我们要增加/删除一个元素必须创建一个新数组，把原数组的数据复制过来，原数组会在内存中被销毁                                 在堆内存中，频繁的创建数组，复制数组中的元素，销毁数组，效率低下。       

---

---

---

---