2019-8-15

1.开源就是开放源代码

2.版本J2SE   J2EE   J2ME

3.历程：JDK配置与安装    直接吧bin目录添加到path中即可 测试javac即可检验安装是否完成

4.JRE：Java runtime enviroment   

5.JDK目录介绍：bin:存放JAVA编译器和解释器都是可执行文件

                            db：一个轻量级数据库

                           include:存放接口文件

                            jre：存放java运行环境文件

                            lib:存放java类库文件

6.主函数是程序的入口

7.println可以不传参数，此时表示换行 但是 print必须传参数

8.注释：单行 多行 文档    

2019-8-16

1.环境变量就是用于记录可执行文件所在路径的特殊量

2.把变量理解为容器

3.变量在使用的时候必须要先初始化

4.在一个文件中不可声明两个同名变量（可以使用中文变量名但不推荐   ）

5.byte（8位 一个字节）  -128~127

6.历程：类型转换（自动类型转换前提是 小范围变大范围，强制类型转换）

    ->整型分类byte short -32768 ~ 32767      int    正负21亿      long  

    ->进制转换  日常生活中一般使用十进制

    ->十进制转二进制：拆分法            二进制转十进制：加权法

                           负数情形下：十进制转二进制：绝对值转为二进制，按位取反加一

                                              二进制转十进制：按位取反加一，转为十进制后添加符号即可

    ->八进制和十六进制 对 二进制转换只做熟悉

    ->IDE开发环境安装

2019-8-17

1.快捷键：  Alt+/ 辅助提示     ctrl+/  添加或取消注释         ctrl+shift+f 格式化代码      ctrl+D 删除当前行

                    ctrl+S  保存当前代码   

2.历程：eclipse介绍  

                ->Scanner输入的使用  主要是next();    nextLine();

                ->运算符  算术，字符串连接，当+号两边有一个是字符时，就当作连接符来处理，    自增自减运算符，                     赋值运算符，关系/比较运算符，  与 和 或 都是具有短路特性，三目运算符可以嵌套，移位运算符

                ->反码：正数的反码就是本身   负数的反码是非符号位按位取反

                ->分支结构：if else

2019-8-18

1.历程： for循环（次数明确），while循环，   do-while循环，  for循环中定义的变量叫做块变量，作用域只   限       于for循环内  

    ->正序倒序输出1-10

    ->break和continue

    ->循环嵌套（外层循环一次，内层循环所有次）

    ->当型 while 和 直到型 do-while

     ->while用在明确循环次数

2019-8-19

1.历程：数组 ->一维数组的本质就是一块连续的内存空间，可以在不同的存储单元存储不同的内容，数组名称用于存储内存空间中的首地址。  声明方式，例如：int[] arr = new int[5];

初始化的时候直接赋值： int[] arr = {1,2,3};  或者： int[] arr = new int[]{1,2,3,4};

数组的复制：System.arrayCopy(原数组，元素组要复制的起始位置，目标数组，起始位置，复制长度)        Arrays.copyOf(起始数组，需要复制的长度)

数组的输出：array.toString(数组名);   这个是便捷输出

->二维数组

2019-8-20

1.历程：面向对象 ：强调对象，然后由对象去调用功能     面向过程：强调的是每一个功能的步骤

    ->面向对象特征：继承，封装，抽象

    ->属性：该事物的描述信息             行为：该事物能做什么    

    ->类是JAVA的基本单位，类：是一组相关属性和行为的集合

    ->对象是该类的具体表现形式   创建对象就是对象的实例化  类名用大驼峰命名法

    ->成员变量 和 成员方法 都能调用。

    ->成员方法：   1.返回值类型       2.形参列表       3.成员方法体

2019-8-21

历程：1.面向对象   JAVA的JVM内存 三个区：堆区  栈区  方法区    

        ->构造方法：  作用：对类进行初始化操作      构造方法就是与类同名的那个方法      

              构造方法没有返回值类型        创建新对象时

                当自定义类中没有定义构造方法时，编译器会自动添加一个构造方法，空的，缺省的构造方法，但是当类中已经有构造方法时，则编译器不会去生成一个空的构造方法。       

        ->方法的重载：名字相同但是参数列表不同就构成了方法重载     不同体现：个数，类型，参数顺序

2019-8-22

历程：1.访问控制：  所有的成员变量都用private修饰  所有的成员方法都用public修饰

            2.封装  基本概念：在测试类中可以给成员变量赋值一些合法但是不合理

                                流程：私有化成员变量    提供共有的set和get  在构造方法中调用set变量    进行合理值的判断

            3.static关键字：有static修饰就是类层级  如果没有就是对象层级

                                基本概念：通常情况下成员变量都隶属于对象层级，每个对象都拥有独立的内存空间来记录自己的成员变量，当所有的对象的成员变量    都完全一样的hi后，单独记录则会浪费内存空间，此时应该将成员变量从对象层级提升到类层级，在内存中只保留一个从而被所有对象所共享。

            4.继承：当多个类具有相同的特征和行为的时候，就可以将相同的部分提取出来组成一个新类                     提高复用性，可维护性，可拓展性

                关键字：extends     名词：父类，子类    

注意：有有参构造的时候最好加上无参构造

2019-8-23

1.历程:   this和super关键字      概述：this关键字代表本类的对象      super关键字代表父类的对象

                                使用方式：使用this.方式可以访问本类的成员变量和成员方法

                                                    使用super.方式可以访问父类的成员变量和成员方法

                方法的重写：当父类继承的方法满足不了需要，则需要重写方法    

                                        要求（方法名相同，参数列表相同，返回值类型相同）    

                                            访问权限可以变大，但是不能变小

                1.final关键字：最终的，无法更改的

                                        ->final类   表示该类不能被继承

                                        ->final方法  表示该方法不能被重写

                                        ->final变量  必须初始值，且不能更改 

                           补充：一般final和static不单独使用，一般是这样组合 public static final

                2.创建对象过程：    ->将.class文件中的信息读取到内存的方法区，这个过程叫做类的加载

                                                ->从main()函数开始，使用new来创建对象

                                        子类对象创建的过程：1.先加载父类 再加载子类  先是父类static 后是子类static

                                                                               2.父类的构造块，然后父类的构造方法体

                                                                                3.执行子类的构造块，然后子类的构造方法体

                3.多态: 同一种事物表现出的多种形态

                            JAVA只有一种多态：运行时多态

                4.抽象类：并且要用abstract修饰，他不能够被实例化

                抽象方法：    不能被具体实现的方法，没有方法体

                抽象类：就是使用abstract关键字修饰的类，不能被实例化

                注意事项： - 抽象类中可以有成员变量 和成员方法 以及构造方法

                                   -抽象类中可以有抽象方法也可以没有

                                   -有抽象方法一定是抽象类

                                    -继承抽象类一定要重写抽象方法

                5.接口：    ->就是一种比抽象类还抽象的类，该类型不能实例化对象

                                  ->定义类的关键字是class  而定义接口的关键字是interface

                                  ->继承类的关键字是 extends   而实现接口的关键字是implements

                                   ->Java中可以通过接口来解决单继承无法解决的类型无法共享的问题

                                    ->接口不关心内部数据    ，也不关心实现细节，只关心类必须提供的方法

                                     注意事项：（1）接口可以实现多继承，也就是说一个接口可以同时继承多个父接口

                                                       （2）实现接口的类如果不能实现所有接口中待重写的方法，则必须设置为抽象类

                                                       （3）  一个类只能继承一个父类  但是可以实现多个接口

                                                       （4）接口中所有成员变量必须由public static final共同修饰，也就是常量

                                                       （5）接口中所有成员方法必须用public abstract共同修饰，也就是抽象方法。

                   6.类和接口之间的关系

                            ->类与类之间采用继承的关系         extends                 单继承

                            ->类与接口之间是实现的关系         implements           多继承

                            ->接口与接口之间采用继承的关系  extends                通常认为支持单继承

                    7.抽象类和接口的区别

                               ->定义关键字  class,interface

                               ->抽象类的继承是extends   而接口的实现是implements

                               ->继承抽象类支持单继承，而实现接口支持多实现

                                ->抽象类有构造方法，但是接口没有

                                ->接口中的所有成员变量都必须是常量，而抽象类可以是变量

                                ->接口中的所有成员方法都是抽象方法，抽象类中可以是普通方法

                                ->接口中增加方法一定影响子类，而抽象类中可以不影响  

2019-8-28

1.Object类：java中常用的包   ->java.lang包，他是核心包，虚拟机自动导入

                                                ->java.util包，他是java工具包

                                                ->java.io包，他是输入输出包

                                                 ->java.net包，提供java网络通信类的内容

                                                 ->java.lang.reflect包，反射包，提供反射相关的类

2019-8-29

1.包装类：     ->自动拆箱   包装类 向 基本数据类型 自动转换

                       ->自动装箱    基本数据类型 向 包装类 自动转换

                        基本概述：在某些场合要求必须使用类类型的对象，而JAVA中8个基本数据类型都不是对象

                                            为了使这些变量能够使用，则必须借助包装类包装成对象来使用。

                               Integer： java.lang.Integer是Object间接子类，用于包装in类型数据，该类是final类，不能被继承

                                                常用方法：->Integer(int  value)          根据参数指定的整数值来构造对象

                                                                       Integer（String s）     根据参数指定的字符串来构造对象

                                                                    int intValue()            用于获取调用对象中含有的int类型数据并返回

                                                                                                    用于实现讲Integer类型拆包为int

                                                            static int parseInt(String s)         用于将字符串类型的数据转换为int类型的整数（掌握）

                                                  自动装箱池：为了提高性能在Integer类的内部提供了自动装箱池，也就是把 -128 ~ 127之间的数提前装箱完毕，若程序需要其中的的数据则直接获取，无需创建新对象。

                                String（非常重要）：java.lang.String用于描述字符串，可以描述Java所有字符串字面值

                                              该类描述的字符串是个常量，一旦创建完毕则无法更改。

                                                常量池：出于性能的考虑，JVM会将字符串字面量对象缓存在常量池中，对于重复出现的字符串直接量，JVM会首先在缓存池中查找，如果存在即返回该对象。

                                             ->常用的构造方法：

                                                            String（）                    使用无参构造来创建对象

                                                            String（byte[] bytes）  根据指定的数组来创建对象

                                                            String（byte[] bytes , int offset , int length）使用参数数组中的一部分来构造对象

                                                            String（String original）  根据参数指定的内容来构造对象。

                                                            String(StringBuffer buffer)   根据参数指定的引用来构造对象

                                                            String（StringBuilder builder） 根据参数指定的引用来构造对象

                                             ->常用的成员方法：

                                                            char charAt（int index）    -用于返回参数指定下标位置的字符

                                                               int length()                       -用于返回当前字符串的长度

                                                 int compareTo(String anotherString)  -用于比较调用对象和参数对象的字符串大小关系并返回。

                                                                            例如：  "abc" < "bcd"            "abc" < "abd"               "abc" < "abcd"

                                                     boolean equals(Object anObject)   -用于比较字符串内容是否相等并返回

                                                      boolean equalsIgnoreCase(String anotherString)   -用于标胶字符串是否相等，不考虑大小写

                              boolean contains(Char Sequence s)    -用于判断调用对象是否包含参数指定内容

                                                                                          -其中参数是接口类型，因此实参传递有两种方式

                                                                                               a.创建实现类的对象作为实参传递，而String类就是该接口的实现类

                                                                                                b.使用匿名内部类创建接口类型的对象作为实参传递

                             boolean endWith(String suffix)    -用于判断当前字符串是否以参数指定的内容为结尾

                              boolean startWith(String prefix)    -用于判断当前字符串是否以参数指定的内容为开头

                                String toLowerCase()                -用于将当前字符串所有的字符转换为小写并返回

                                  String toUpperCase                  -用于将当前字符串所有的字符转换为大写并返回

                                  String trim()                              -用于去除当前字符串中两端的空白字符并返回。

                            byte[] getBytes()                             -用于将当前字符串内容转换为char数组并返回

                                char[]  toChaeArray()                 -用于将当前字符串转换为char数组并返回

                            int IndexOf( int ch )                           -用于返回当前字符串中参数ch指定的字符第一次出现的下标

                             int indexOf(int ch , int fromIndex)    -用于从fromIndex位置开始查询ch指定的字符，若查找失败则返回-1

                               int indexOf(String str)                     -用于查找参数str指定的字符串并返回下标

                          int idexOf(String str , int fromIndex)    -用于从fromIndex位置开始查找

                             int lastIndexOf( int ch )                           -用于返回当前字符串中参数ch指定的字符最后一次出现的下标

                             int lastIndexOf(int ch , int fromIndex)    -用于从fromIndex位置开始查询ch指定的字符，反向搜索一次若查找失败则返回-1

                               int lastindexOf(String str)                     -用于返回str指定的字符串最后一次出现的下标

                          int lastindexOf(String str , int fromIndex)    -用于从fromIndex位置开始反响搜索一次

                            String substring(int beginIndex )                     -用于获取当前字符串中从beginIndex位置开始的子字符串并返回

                            String substring(int beginIndex,int endIndex)        -用于获取当前字符串从beginIndex位置开始到endIndex结尾的子字符串并返回

3. StringBuffer和  StringBuilder类

                基本概述：由于String类描述字符序列是不可改变的,因此描述多个类似的字符串需要单独保存，此时内存空间消耗比较大，为了内存空间直接对字符序列本身进行改变，则使用StringBuffer 和 StringBuilder

               StringBuffer 线程安全类 效率低

                StringBuilder  非线程安全类 效率高  （推荐使用）

                StringBuilder(String str)   根据字符串来构造对象

                                             - 初始容量为: 16 + 字符串参数的长度

                                             - 该类没有重写equals() 和 hashcod（）方法，但是重写了 toString()     方法

                            int capacity()      -   用于获取当前对象的容量并返回

                            int length  ()         -用于返回当前对象的字符个数

                    StringBuilder  insert （int offset,String str）   - 用于将str插入到当前字符串中offset位置并返回。

                      StringBuilder  append（String str）         -用于将str字符串追加到当前字符串的末尾位置

                     StringBuilder   delete(int start , int end)       -移除start 到 end的字符串内容

                     StringBuilder   replace  (int start , int end , String str)    -替换 start 到 end的内容

                      StringBuilder  reverse  （）                             -用于反转当前字符串字符内容

注意：静态方法通过 类名.方法名  的方式调用

            注意      类层级  和  对象层级  方法调用的不同之处          

2019-9-1

1.日期相关的类

    ->Date                 基本概念：java.util.Date类用于描述特定的瞬间，可以精确到毫秒，通常用于描述年月日时分秒

                                常用方法：    Date（）  -     无参构造方式，默认使用当前系统时间来初始化对象。

                                                      Date（long date ） -     根据参数指定的毫秒来构造对象，

                                                            -参数为距离1970年1月1日 0时0分0秒， 1 秒 = 1000  毫秒  ， 1 毫秒 = 1000 微秒

                                                            -该方法与File类中的方法搭配使用，很方便

                                                      long getTime（）  -    用于获取 调用对象距离1970年1月1日0时0分0秒的毫秒数。

                                                      void setTime(long time)    -    根据参数指定的毫秒数来调整对象描述时间

->SimpleDateFormat类  

                                基本概念：java.text.SimpleDateFormate类用于实现  Date类 和 String类之间的转换，调用时间格式

                                常用方法：SimpleDateFormat（String Pattern）   -根据参数指定的格式来构造对象

                                                                                                      -参数字符串中格式有：y-年 m-月 d-日   H-时 M-分 S-秒

                                                    String format(Date date)  -  用于将Date类型转换为String类型 并返回。

                                                    Date parse(String source)  -   用于将String类型转换为Date类型并返回

2019-9-2

集合：用于存储一种或者多种引用类型，并且长度可变。

集合的外延有： List集合，Set集合，Queue集合

List集合：                -   适用于有序存储可重复元素的集合

                                -    list接口继承了Collection接口，声明有序存储对象（可重复）功能的公共接口。

                                 -    List集合的实现类有：ArrayList, Vector ,LinkedList

                    ！！！集合中只能存储引用数据类  不能存储  基本数据类型

                                    List 集合常用方法：

                                                        add(E   e)   -   像列表末尾追加元素

                                                         add(int index , E e)    -  在指定位置上添加一个对象

                                                          addAll(Collection<? extends E>  c)   -   将集合元素添加到指定集合末尾

                                                           get(int index)  -    返回指定位置对象

                                                            remove (int index)    -   删除指定位置对象

                                                            set(int index , E element)  -   用指定元素替换列表中指定位置的元素。

                                                            indexOf(Object o )   -   返回第一个匹配对象位置

                                                            lastIndexOf(Object o )   -   返回最后一个匹配对象的索引

                                                            size()  -   返回此列表中的元素数

                                ArrayList类

                                                        - 基于数组实现的，长度可变的，分配连续内容空间的List集合

                                 迭代器遍历

                                                          迭代器（Iterator）  -   迭代器是一种使用迭代法遍历集合的对象

                                                          -    Iterable  java集合框架的顶级集合

                                                                Iterator接口中常用的方法：

                                                                            hasNext()   -   判断是否还有其他元素

                                                                            next()          -    获取下一个元素

                                                                            remove        -   删除最后一次调用next方法返回的元素

                                                                    迭代器遍历步骤

                                                                                1.调用Iterator()  得到一个指向集合序列第一个元素的迭代器

                                                                                2.用循环调用hasNext() 方法，如果有元素，返回true

                                                                                3.在循环中，使用next()方法获取集合的下一个元素。

泛型：          -       是一种把类型明确明确的工作推迟到创建对象活调用方法的时候采取明确的特殊类型

                             又称之为参数化类型，把类型当做参数一样传递

                 语法格式：

                                    <数据类型>

                                   此处的数据类型只能是引用数据类型/类类型

                   泛型优点：

                                      1.将运行期间的问题提到了编译期间

                                      2.避免了强制类型转换

                                      3.优化了程序设计，解决了黄色警告线

                    泛型分类：

                                            泛型类：

                                                        -   定义：把泛型定义在类上

                                                       -    格式：public class 类名<泛型类型1。。。>

                                                        -     注意：泛型类型必须是引用类型

                                            泛型方法：

                                                        -  把泛型定义在方法上

                                                        -  格式：public  <泛型类型>返回值类型 方法名（泛型类型）

                                            泛型接口

                                                        -  把泛型定义在接口上

                                                        -   格式：public     interface    接口名<泛型类型>

                        符号：

                                T（type）     V（value）     E（element）      K（key）

2019-9-3

    1.collection

    2.list集合

    3.set集合

    4.map集合

        复习    当需要在程序中记录单个数据，则声明一个变量记录

                    当需要在程序中记录多个类型相同的数据，就使用数组

                    当需要在程序中记录多个不同类型，则可以使用构造对象

                    当需要在程序中记录多个类型不同的对象的时候，我们可以使用集合

数组与集合的比较

        1.数组的特点

                a.本质上时一段连续的内存空间，用于记录多个类型相同的数据

                b.数据一旦声明完毕，则内存空间固定不变

                c.执行插入或者删除操作的时候不方便，可能会移动大量的元素，从而导致效率太低

                d.数组支持下标访问

                e.数组元素可以是基本数据类型 也可以是 引用数据类型

    2.集合的特点

                a.内存空间可以不连续，数据类型可以不相同

                b.集合的内存空间可以进行动态调整

                c.集合的插入删除操作可以不移动大量元素

                d.部分支持下标访问，部分不支持

                e.集合中必须是引用数据类型

什么是集合类：

            是在计算机中存储一种或多种引用类型，并且长度可变的容器

            容器就是用来存储和组织其他对象的对象

Collection集合：

        JAVA语言中集合框架的顶层是： Collection集合    Map集合

        其中Collection集合操作的元素基本单位是：单个元素

            其中Map集合操作元素的基本单位是：单对元素

集合常用方法

                1.add（E e） 将指定对象存储到容器中

                2.addAll( )  降指定集合中的元素添加到调用该方法的集合中

                3. size()  返回集合中的元素数

                4.contains( Object O)判断集合中是否包含参数指定的单个元素

                5.containsAll(Collection<?> c) 判断集合中是否包含指定元素的整体

                6.remove(int index)  移除列表指定位置的元素

                7.removeAll（conllection<?> c）从列表中移除指定collection 中包含的其他所有元素

                8.set(int index,E element)  将集合中指定位置元素进行替换

List集合

                他本来是继承自Collection接口，有序元素可重复的集合

List集合的实现类

                        ArrayList：数组查找比较快，增加删除慢，由于是数组实现，

                                            再增加删除的时候可能会牵扯到数据的扩容，以及拷贝元素。

                                            数组可以直接按照索引查找，所以查找速度快。

                        linkedlist：链表实现，增加删除快，但是查找慢，由于是链表实现，

                                                增加的时候只要让前一个元素即可，

                                            但是查询的时候我们需要一个一个遍历

                            Vector：是基于数组实现的，线程同步的的遗留集合类，

                                                  和ArrayList原理相同，但是线程安全，效率低。

                            Stack：后进先出

队列 Queue

    add 和 remove 在失败的时候会抛出异常（不推荐使用）

                        1.offer()  添加元素

                        2.poll（）  返回第一个元素，并在队列中删除

                        3.element()    返回第一个元素

                        4.peek（）    返回第一个元素

2019-9-4

Set集合

                        set集合是用于无序存取不可重复的元素集合。

                        set集合的实现：

                                                        1.HashSet

                                                        2.LinkedHashSet

                                                        3.TreeSet

                    （1）HashSet

                                    HashSet是基于哈希表的set集合

                                    1.需要使用hashCode算法计算元素的hash值。

                                    2.基于哈希表做实现

                                    3.实现了Set接口

                    HashSet集合存储步骤

                                1.使用哈希算法计算元素对应的哈希值，使用此哈希值作为地址存储

                                2.判断此哈希值对应的位置上是否已经存有元素

                                3.若没有就将元素存储在该位置上

                                4.若有则使用equals方法判断两个对象是否相等，相等就不存储，不相等则与上一个元素存在一起

                                    笑死了哈啊哈哈，男生女生不一样，女生和女生就更是不一样的离谱了，就像个万花筒，

                                   什么性格的都有，哈哈哈，有意思，也是，这也算是造物主的机智之处，不然千篇一律，

                                    生活该有多么的枯燥无味，哈哈哈，永远朝向生活的向阳面，原我们永远年轻，愿我们永远热泪盈眶。

                          （2）LinkedHashSet

                                        是基于双向链表和哈希表，继承自HashSet和Set集合

                                        特点:  元素  有序  而且  不重复

                          （3）TreeSet

                                            是基于红黑树，实现了set集合，具有排序功能的set集合

                                            树的相关概念： 根节点，枝节点，叶子节点

排序接口

                        Comparble

                                    使实现类自身具备某种比较规则以便对其对象进行自然排序的接口

                        自然排序：是要求自定义类实现Comparable接口并重写其compareTo(T o) 方法，在此方法中依据xx属性进行排序的算法

                        Comparator比较器

                                    在外部自定义比较规则以便容器对其存储数据进行定制排序的对象

                                     定制排序：是要求自定义类实现Comparator接口并重写其compara(T o1, T o2)方法，

                                                        在此方法中依据XX属性进行排序的算法，也称为比较器排序。

                        Comparable接口

                                    实现该接口的类具有排序功能

                                    需要重写ComparaTo方法，使用当前对象和参数对象进行比较

Comparator接口

                                    不会对集合z中的元素进行修饰

                                    需要自定义比较器类s实现该接口重写compara方法，比较两个参数对象

                                    需要将比较器对象以参数形式传入集合的构造器中

集合的选择

                        List

                                        如果需要保留存储顺序，保留重复元素，推荐使用List集合

                                                         ArrayList：查询多 用它

                                                        LinkedList：存取多 用它

                                                        Vector：若需要线程安全 用它

                        Set

                                                  如果不需要保留存储顺序并需要去除重复的元素，推荐用Set

                                                        TreeSet：元素需要排序，用它

                                                        HashSet：无需排序，用它  他的效率比treeSet高

                                                         LinkedHashSet：若需要保留存储顺序，有需要去除重复元素，就用它。

2019-9-5

Maps集合

                键 ---------------  映射 ----------------值

                Maps集合存储元素的特点是以键值对形式存储元素，容器框架

                实现类： HashMap ---  LinkedMap --- TreeMap  -- HashTable

                (1) HashMap

                                    基于哈希表实现的，线程不安全的Map容器

                                       特点：

                                                  1.基于哈希表实现

                                                   2.key不允许重复

                                                   3.底层是 数组 + 链表 结构

                                                    4.允许 null 键和 null 值

                                                    5.线程不安全

                    HashMap的常用方法

                                    ->V put （k key,v value） 添加数据，如果先前包含该键的映射，则替换旧值

                                    ->V get （Object key）返回指定键所映射的值

                                    ->Set<Map.Entry<k,v>> entrySet() 返回此地址中包含的映射的Set集合

                                    ->Set<k> keySet() 返回集合中包含的键的Set集合

                                    ->v remove (Object key) 从该集合中删除指定键的映射

                                    ->Collection<V> values() 返回集合中包含的值的Collection集合

                    （2） LinkedHashMap

                                        继承自HashMap，基于双向链表，存取有序的Map容器。

                     （3） HashTable

                                        基于散列表实现，线程安全的Map容器

                                        特点：不允许null键和 null值

                                                            线程安全

                      Hashtable 和 HashMap 的区别

                                            1. 继承的父类不同

                                            2.线程安全性不同

                                            3.是否允许null键

                                            4.遍历内容实现不同

                        （4）TreeMap

                                            基于红黑树实现，具有排序功能的Map容器

                                            特点：

                                                            1.底层是红黑树

                                                             2.不允许Null值和null键

                                                             3.针对键进行排序的

                                                              4.线程不安全的类

注意：类名不能和需要导入的包同名

2019-9-6

集合工具类

                Collections 用于操作集合的工具类

                                    注意：使用Collection工具类之前，要导入java.util包

                 Collections类的常用方法

                                        ->void sort() 对集合中存储的元素进行排序

                                        ->shuffle() 对集合中存储的元素随机排列

                                        ->reverse() 将集合中存储的元素位置进行反转

                                        ->max() 获取集合中最大元素

                                        ->min() 获取集合中最小元素

                                        ->indexOfSubList() 获取指定子列表在整个列表中第一次出现的位置

                                        ->lastIndexOfSubList() 获取指定子列表在整个列表中最后一次出现的位置

                                        ->binarySearch()二分查找法：

                                        注意：所有的方法都是使用static 修饰的，所以我们直接使用Collections.xxx()的方式进行调用

2019-9-16

线程：

                    1.原子性操作意思好像是 要么一起成功 要么一起失败，有点同生共死的味道

                    2. ->同步方法锁对象是 锁对象就是this

                        ->静态方法锁对象     锁对象是类类型

                    3.同步锁 synchronized  和 Lock锁

                    4.死锁问题

                                ->是指两个活两个以上线程在执行的过程中，因争夺资源产生的相互等待的情况

                    5.线程组：ThreadGroup用于方便用户对多个线程进行管理操作

                    6.线程池：Executors  提高系统性能，线程用完仍然循环使用

                    7.定时器 Timer 和  TimerTask

                    8.为什么wait , notify , notifyAll方法都定义在Object类中？

                            ->这些方法存在同步中

                            ->使用这些方法必须要标识所属的同步锁

                            ->锁可以是任意对象，所以任意对象调用方法一定在Object类中

JAVA网络编程：

                        1.网络通信软件：QQ , 微信 ,MSN.... 

                        2.网络模型： OSI（开放系统互联）（七层协议）

                                                                    ->应用层   表示层    会话层    传输层     网络层     数据链路层     物理层

                                                TCP/IP参考模型

                                                                    ->应用层    传输层      网际层    主机至网络层

                        3.常见协议：

                                        http  -   超文本传输协议，浏览网站的时候使用该协议

                                        ftp    -   文件传输协议，上传下载文件时候使用该协议

                                        tcp    -   传输控制协议，是一种面向连接的协议，类似于打电话，网络通信需要使用该协议

                                        udp   -    用户数据报协议，是一种非面向连接的协议，类似于写信，网络通信使用该协议

                                        ip     -    互联网协议，是上述协议的底层协议

                                        协议：就是一种约定/规则，是通信双方需要遵循的一种机制

                            4.网络通信三要素

                                        ->IP地址：InetAddress                网络中设备的标识  

                                        ->端口号：用于标识进程的逻辑地址，可以定位进程

                                        ->传输协议：通讯的规则

                                注意：网络编程中，我们需要提供：IP地址 和 端口号