JavaSE基础

JavaSE基础

Java语言概述

一、计算机语言概述

• 软件 & 开发
• 人机交互 & 计算机语言
• 概述 & 架构

二、JVM

• Java虚拟机，将字节码解析成具体平台上的机器语言。

三、JRE & JDK

• JDK包含JRE，JRE包含JVM。

四、JDK

• 下载与安装
• JDK命令行工具
• dos命令行工具

五、环境配置

• 配置
• 配置技巧
• 临时配置方式
• classpath

六、HelloWorld

• 语法
• 细节：javac & java
• 常见问题：找不到类 / 方法

Java语言基础

一、学习语言

• 表现形式
• 什么时候用

二、关键字

• Java自定义的能代表一定意义的符号

三、标识符

• 由数字、字母、下划线和美元符号组成
• 不能由数字开头、不能是关键字
• 严格区分大小写

四、注释

•   注释
  单行注释 //，多行注释 /* */，文档注释 /** */
  包含关系：单行注释可以包含单行注释和多行注释，多行注释只可包含单行注释。
  可以用于调试
  注释没解析近字节码文件
•   应用
  需求、思路、步骤

五、常量

• 常量：整型、浮点型、布尔型、字符型、字符串、null
• 进制：二进制、八进制、十进制、十六进制
• 进制转换：二进制转八进制：三位为一位；二进制转十六进制：四位为一位；十进制转二进制：除二倒数取余。
• 负数的二进制：正数的二进制取反加一

六、变量

• 变量
  可以重复使用
  内存中的一个存储区域
  格式：数据类型 变量 = 初始化值
  作用范围：{} 之间
  数据类型
      基础数据类型
          整型：byte、short、int、long
          浮点型：float、double
          字符型：char
          布尔型：boolean
      引用数据类型
          类：class
          接口：interface
          数组：[]
• 使用
  变量使用前要有初始化值且有范围
• 类型提升和强制转换
  小范围转大范围自动类型提升
  大范围转小范围强制类型转换
• 字符类型 
  unicode 编码表，让每个字符都有二进制数与之对应
• 类型运算细节
  两个 byte 类型的变量（常量行）相加的值赋给 byte 类型的变量，不行，精度丢失。
  两个 int 类型的变量相加的值赋给 int 类型的变量，行，但可能溢出。

七、运算符

1. 算数运算符
   +、-、*、/、%、+
   ++、--
2. 赋值运算符
   =
   +=、-=、*=、/=、%=
   赋值运算符计算时都会在底层做强制类型转换
       short a = 1; a += 1; 行
       short a = 1; a = a + 1; 不行
3. 比较运算符
   >、>=、<、<=、==、!=、instanceof
4. 逻辑运算符
   &、|、!、^、&&、||
5. 位运算符
   位运算符
       &：取后四位
       |
       ~
       ^：连续亦或一个数还是这个数，可加密解密。
       练习：交换两个数值：a / b / a = a ^ b
   移位运算符
       <<：乘以 2 的 n 次幂
       >>：除于 2 的 n 次幂
       >>>：除于 2 的 n 次幂，高位补零
       练习：最有效计算 2 * 8：2 << 3
6. 三元运算符
   格式：? : 
   练习：获取两 / 三个值的最大值

八、语句

1.   条件语句
   if 语句
       if 格式，只有一条语句可省略后面的括号。
       if else 格式，如果表达式有返回值等于 ? : 运算符。
       if else if else 格式，还有嵌套，括号后可直接加分号。
       局部代码块：决定了局部变量的生命周期
       练习：星期、季度
       与 switch 语句的区别
           判断具体的值
           判断值的范围
           判断 boolean 表达式的值
   switch 语句
       格式
           switch 格式
           表达式：byte、short、int、char
           default：位置可变
           break：不可省略，省略将继续执行下去；最后可省略。
       练习
           星期、季度
       与 if 语句区别
           判断具体的值
           几个具体的值，效率高。
2. 循环语句
   while / do while 语句
       while / do while 格式
       区别：do while 先执行一遍
       练习：累加思想、计数思想
       和 for 的区别
           可以互换
           定义的变量后续可用
   for 语句
       for 格式
       练习：累加思想
       和 while / do while 的区别
           可以互换
           简洁
       使用场景：多次判断时
       循环嵌套
           大圈套小圈思想
           练习
               向下 / 向上直角三角形
               向下直角三角形，输出y，大到小；向上直角三角形，输出x。
               九九乘法表，转义字符
               向下等腰三角形
           break / continue
               break，跳出 switch、loop，可指定标志。
               continu，跳出 loop，可指定标志。
   循环语句与 if 语句的区别
       一次判断用 if 语句，多次判断用循环语句。

九、函数

• 概述
• 函数格式
  修饰符 返回值 函数名(类型 参数名, ...) { }
• 细节
  代码封装和复用
  void：return 可省略
  定义思想错误：有返回值要返回，不要直接输出。
• 两个明确
  明确返回值和参数列表
  练习
      两个数的和，画矩形，两个数大小，两个数取大。
      九九乘法表，判断成绩等级。
• 函数-内存加载过程
• 重载
  方法名一致，参数列表不一致。
  练习：九九乘法表

十、数组

• 概述
  一类相同的数的容器，自动编号从零开始。
• 定义
  类型 [ ] 数组名= new 类型 [长度];
• 内存空间
  内存空间划分：寄存器、本地方法区、方法区、栈、堆。
  栈：存储局部变量，限定其生命周期。
  堆：有初始地址值，有默认值，有垃圾回收机制。
  内存图解
• 问题
  空指针，下标越界，查找数据类型。
• 第二种定义格式
  类型 [ ] 数组名= new 类型 []{值1,...};
• 二维数组
  定义方式：int [ ] [ ] = new int [3][2];
  内存图解
  另一种定义方式：int [ ] [ ] = {{1,2},{2,3},{3,4}};
  应用场景

十一、数组算法

• 遍历
• 找最值
• 排序
      选择排序
      冒泡排序
      置换代码提取
      性能问题
• 查找
      遍历查找
      折半查找
      插入值的角标：-1-x
• 进制转换
      十六进制转换：& 15再不带符号右移4位
      查码表：定义对应关系表
      进制整合
      查码表：星期对应

Java面向对象

一、面向对象

• 概述
      概述
          符合习惯
          复杂的问题简单化
          事件的执行者变成指挥者
      专业的人做专业的事
      万物皆对象
      特征：封装、继承、多态
• 类与对象
      关系：类是描述，对象是实体。
      体现
          new 类  () ; 对象名.成员
          细节：成员变量、成员方法
      对象内存体现
• 成员变量和局部变量
      不同：位置、默认值、生命周期、内存位置
      同名，显式初始化
• 传递
      类类型变量
      匿名对象
• 类型参数传递图解
      基本类型
      引用类型

二、封装

• 代码举例
• 思想：{ } 封装起来，属性隐藏起来，提供 getter & setter 方法访问。

三、构造函数

• 概述
      名字跟类名一样，无返回值 return，初始化对象。
• 默认构造函数
      有有参构造函数，则没有默认无参构造函数。
      没有有参构造函数，则有默认无参构造函数。
• 构造函数与一般函数区别
      构造函数是创建对象时用来创建对象的，会调用只调用一次；
      一般函数是创建对象后需要函数功能时调用的，可调用多次。
• 重载
      在描述事物时，该事物一存在就具备的内容，这些内容都定义在构造函数中。
• 内存图解
• 细节
      需要 getter & setter；
      构造函数可以调用一般函数；
      一般函数名称可以跟构造函数一样；
      构造函数可以有 return。

四、this

• 应用场景1 & 图解
      当成员变量和局部变量同名时，this.成员变量，谁调用谁就是 this。
• 应用场景2 & 图解
      构造函数引用其它构造函数，放在构造函数第一行。
• this 应用
      自身与其它对象的比较

五、static

• 数据共享
• 特点：修饰成员；所有对象共享；随着类加载而加载；类名.成员变量；共享数据。
• 与成员变量区别：生命周期不同；调用方式不同；别名不同；数据存储位置不同。
• 注意事项：静态方法只能调用静态成员；静态方法不能使用 this 或 super；main 方法是静态的。
• main 方法
• 内存图解
• 什么时候用：如果变量是共享数据用 static 修饰；如果方法调用非静态成员，用非静态修饰，反之。
• 静态代码块：修饰类；随着类的加载而加载，只执行一次。
• 构造代码块：修饰所有对象；ps 构造函数修饰某个对象。

六、数组工具

• 对象的建立
• 类中静态的使用
      静态的
      构造方法私有化
• 文档注释
      /** */ @author @version @param @return
      javadoc -d... -author -version 类名

七、单例模式

• 概述
      必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。
• 特点
      构造函数私有化；变量私有化；方法公开化。
• 例子
      懒汉 & 恶汉
• 内存图解

八、继承

• 概述
      变量复用；类之间产生关系。
• 单继承、多继承、多重继承
• 定义继承
      子类 extends 父类
• 子父类
      成员变量
          特点
              this 代表子类对象；super 代表父类空间。
          子类不能直接访问父类私有成员变量
          内存图解
      成员方法覆盖
          注意事项
              子类方法比父类方法权限大等于；静态只能继承静态，或被静态继承。
          内存图解
          应用
              子类要保留父类内容，又要定义自己特有内容。
      构造函数
          子类的实例化过程
              super( )；空参 super( ) 对父类初始化；有参需指定；有 this 无 super。
          细节
              第一行；
          内存图解
          final
              修饰的类不可以被继承；修饰的方法不可以被覆盖；修饰的变量是一个常量。
      创建对象过程
          加载进内存；
          开辟堆空间；
          默认初始化；
          构造函数初始化；父类先初始化；子类再初始化；子类显式初始化；子类构造函数初始化；
          赋值给变量。

九、抽象类

• 概述
      向上抽取
• 特点
      abstract 修饰类和方法；不能实例化；抽象方法被实现。
• 细节
      有构造函数，由子类初始化。
      可以没有抽象方法
      不能和 private、static、final 一起使用
      与类异同点
          同：都定义了成员
          异：抽象类 描述事物的信息可能不足；定义了抽象方法；不能实例化。
      是父类
• 练习
      父类抽象子类方法
• 与接口的区别
      单继承；定义一般方法和抽象方法；is a 关系。

十、接口

• 定义
      public static final 变量名;
      public abstract 方法名();
• 实现
      接口不能实例化
• 多实现
• 细节
      多实现；多继承；弥补了类单继承的局限性。
• 特点
      对外暴露；功能扩展；降低耦合。
• 与抽象类的区别
      多继承；只定义抽象方法；like a 关系。
• 应用
      定义规则-暴露规则；实现规则-降低耦合性；使用规则-功能扩展。

十一、多态

• 多态
      概述
          一个对象，两种形态。
          父类或者接口的引用指向其子类的对象。
      好处 & 弊端
          好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。
          弊端：前期定义的内容不能使用（调用）后期子类的特有内容。
      前提
          1、必须有关系：继承，实现。
          2、必须有覆盖
• 转型
      向上转型：作用就是限制对特有功能的访问
      向下转型：目的就是为了使用子类中的特有方法
      注意：对于转型，至始至终都是子类对象在做着类型的变化。
      向上转型后，可以调用父类的方法，其实就是子类继承父类的。
      instanceof，用于判断对象的具体类型，只能用于引用类型判断。通常在向下转型时用于健壮性的判断。
• 成员
      成员变量
          编译和运行都参考等号的左边
      成员函数
          编译看左边；运行看右边。
      静态函数
          编译和运行都参考等号的左边

十二、内部类

• 概述
      1、内部类可以直接访问外部类中的成员。
      2、外部类要访问内部类，必须建立内部类的对象。
• 修饰符
      直接访问外部类中的内部类中的成员：Outer.Inner in = new Outer().new Inner();
      如果内部类是静态的，相当于一个外部类：Outer.Inner in = new Outer.Inner();
      如果内部类是静态的，成员是静态的：Outer.Inner.function();
• 细节
      因为内部类持有了外部类的引用。外部类.this.成员
• 局部内部类
      内部类在局部位置上只能访问局部中被 final 修饰的局部变量。
• 匿名内部类
      概述
          必须有前提：内部类必须继承或者实现一个外部类或者接口。
      应用
          通常的使用场景之一：当函数参数是接口类型时，而且接口中的方法不超过三个。
      细节
          因为匿名内部类这个子类对象被向上转型为了 Object 类型。这样就不能再使用子类特有的方法了。
• 对象初始化过程
      1、默认初始化；
      2、super() 初始化；
      3、显示初始化；
      4、构造代码块初始化；
      5、构造函数初始化。

十三、异常

• 概述
      异常就是java通过面向对象的思想将问题封装成了对象。
• 体系：Throwable
      Error
      Exception
• 抛出
      throw
          原理：方法抛给调用者，再抛给 jvm。
          throw
          与 throws 区别
              使用在函数内
              抛出异常对象
      throws
          自定义异常类
          throws
          与 throw 区别
              使用在函数上
              抛出异常类，可以抛出多个。
• 异常类型
      编译时异常
          希望在编译时就进行检测，让这种问题有对应的处理方式。
      运行时异常
          更多是因为调用者的原因导致的或者引发了内部状态的改变导致的。
• 捕获
      格式
          格式
          什么时候用：能捕获的时候就捕获
          调用方法
      多 catch
          父类异常放在最下面
      finally
          一定会执行的代码
          代码块组合特点
              try catch finally
              try catch 当没有必要资源进行释放时，可以不用定义 finally。
              try finally 异常无法直接 catch 处理，但是资源需要关闭。
• 异常处理原则
      函数内容如果抛出需要检测的异常，要么抛出要么捕获。
      如果调用了声明异常的函数，要么抛出要么捕获。
      功能内容可以解决，用 catch；解决不了，用 throws 告诉调用者，让调用者解决。
      内部有几个需要检测的异常，就抛出几个，抛出几个，就 catch 几个。
• 应用
      封装转换：调用者能处理就直接处理，不能处理需要封装转换。
• 注意事项
      子类覆盖父类，只能抛出父类的异常或者子类或者子集。

十四、Object

• equals 方法
      equals 方法
      equals 方法覆盖
• hashCode 方法
• getClass 方法
• toString 方法

十五、包

• 概述
      编译：加 -d .
      执行：加 包名.
• 包之间的访问
      public、protected、default、private
• 导入 import
      导入类、导入所有类、导入原则、简化书写。
• jar 包
      压缩：jar -cf / -cvf xxx.jar 包
      解压缩：jar -xvf xxx.jar
      set classpath

Java多线程

一、多线程、同步

• 概述
      进程，至少有一个线程。
      线程
      多线程
• 好处与弊端
      同时执行
      不断切换，效率降低。
• JVM 多线程解析
      main 线程，object.finalize( );
      垃圾回收器线程，System.gc( );
• main 线程
      单个线程
• 线程的创建
      继承 Thread 类
          步骤
              1、继承 Thread 类；
              2、覆盖 run( ) 方法；
              3、new 一个线程；
              4、调用 start( )方法。
          Thread 的方法：super( );Thread.currentThread( ).getName( );
          图解
      实现 Runnable 接口
          步骤
              1、实现 Runnable 接口；
              2、覆盖 run( )方法；
              3、new 一个线程，实现为参数；
              4、调用 start( )方法。
          细节
              调用 run( )方法流程
          好处
              1、将线程的任务从线程的子类中分离出来，进行了单独的封装。
              2、避免了 java 单继承的局限性。
• 线程的状态及相互转换
• 买票示例
      图解
      线程安全问题现象图解
      线程安全问题原因
          1、多个线程操作共享数据；
          2、操作共享数据的代码不止一行。
• 同步代码块
      格式
      好处与弊端
          好处：解决了安全问题
          弊端：降低效率
      前提
          使用同一个锁
      与同步函数的区别
          同步代码块的锁是任意的对象
• 同步函数
      格式
      验证同步函数的锁
          同步函数使用的锁是 this
          与同步代码块的区别：同步函数的锁是固定的 this
      验证静态同步函数的锁
          该函数所属字节码文件对象
• 单例模式设计的多线程问题
• 死锁示例
• 郁闷解答图解

二、生产者消费者、多生产者多消费者

• 线程间通讯
      示例
          多个线程在处理同一资源，但是任务却不同。
      等待唤醒机制
          wait、notify、notifyAll
      代码优化
          在资源中整合不同任务访问资源的不同方法。
• 多生产者多消费者
      问题
          if-连续生产或者连续消费；
          while-死锁。
      解决
          if-->while-->notifyAll
• jdk 5.0 新特征
      锁：
          Lock lock = ReenTrantLock();
          lock.lock();lock.unlock();
      监听器
          Condition con = lock.newCondition();
          con.await();con.signal();con.signalAll();
• 新特征对多生产者多消费者的解决办法
      两个监视器
          一个监听生产者；一个监听消费者。
      范例
• wait 和 sleep 区别
      while 可以指定时间也可以不指定，sleep 必须指定时间。
      对 cpu 的执行权和锁不同，wait：释放执行权，释放锁；sleep：释放执行权，不释放锁。
• 停止线程
      定义标志：控制循环通常就通过定义标志来完成。
      可以使用interrupt( )方法将线程从冻结状态强制恢复到运行状态中来。
• 守护进程
• 其他方法
      join：临时加入一个线程运算时可以使用join方法。
      toString：字符串表现形式
      setPriority：设置优先级
      yield：暂停线程对象
• 面试题
      没有实现接口方法的类是抽象类
      先执行子类方法，再执行接口方法，最后执行本类方法。

Java常用对象API

一、String

• 特点
      字符串常量池概念
      String str = "abc";创建一个字符串对象在常量池中。
      String str = new String("abc");创建两个对象，一个new，一个字符串对象在堆内存中。
• 构造函数
      String() // 等效于""
      String(byte[] byte)
      String(char[] char)
      String(char[] char, 开始角标, 结束角标)
• 获取
      获取字符串中字符的个数（长度）
          int length()
      根据位置获取字符
          char charAt(int index)
      根据字符/字符串获取角标，角标是否为-1判断是否存在。
          int indexOf(int ch)
          int indexOf(int ch, int fromIndex)
          int indexOf(String str)
          int indexOf(String str, int fromIndex)
          int lastIndexOf(int ch)
          int lastIndexOf(int ch, int fromIndex)
          int lastIndexOf(String str)
          int lastIndexOf(String str, int fromIndex)
      获取字符串中一部分字符串。也叫子串。
          String substring(int beginIndex, int endIndex)，包含begin，不包含end。
          String substring(int beginIndex)
• 转换
      将字符串变成字符串数组（字符串的切割）
          String[] split(String regex)，涉及到正则表达式。
      将字符串变成字符数组
          char[] toCharArray()
      将字符串变成字节数组
          byte[] getBytes()
      将字符串中的字母转换成大小写
          String toUpperCase()
          String toLowerCase()
      将字符串中的内容进行替换
          String replace(char oldch, char newch)
          String replace(String s1, String s2)
      将字符串两端的空格去除
          String trim()
      将字符串进行连接
          String concat(string)
      将其他类型转换成字符串
          String valueOf(其他类型)
• 判断
      两个字符串内容是否相同
          boolean equals(Object obj)
          boolean equalsIgnoreCase(string str)
      字符串中是否包含指定字符串
          boolean contains(String str)
      字符串是否以指定字符串开头，是否以指定字符串结尾
          boolean starsWith(String str)
          boolean endWith(String str)
• 比较
      两个字符串比较
          int compareTo(String anotherString)
• interns 方法
      常量池有就直接用，无就生成一个。
• 练习
      字符串数组排序：compareTo
      子串的次数：1、字符串不断截断；2、下标不断后移。
      最大相同子串：1、嵌套循环；2、contains。
      去除两端空白：charAt

二、StringBuffer

• 特点
      长度可变
      可以存储不同类型数据
      最终要转成字符串进行使用
      可以对字符串进行修改
• 添加
      StringBuffer append(data)
      StringBuffer insert(index,data)
• 删除
      StringBuffer delete(start, end)
      StringBuffer deleteChartAt(int index)
• 修改
      StringBuffer replace(start, end, string)
      void setChartAt(index,char)
• 查找
      char charAt(index)
      int indexOf(string)
      int lastIndexOf(string)

三、StringBuider

• 与StringBuffer的区别：
      StringBuffer是线程同步的。通常用于多线程。
      StringBuilder是线程不同步的。通常用于单线程。它的出现提高效率。
• jdk升级：
      简化书写
      提高效率
      增加安全性

四、基本数据类型 包装类

• 定义了属性和行为丰富了该数据的操作 8个基本数据类型对象包装类
• 基本类型和字符串之间的转换
      基本类型-->字符串
          1、基本类型数值+""
          2、用String类中的静态方法valueOf(基本类型数值)
      字符串-->基本类型
          1、使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串")
          2、如果字符串被Integer进行对象的封装可以使用intValue()
• 进制转换
      十进制-->其他进制
          toBinaryString
          toOctalString
          toHexString
      其他进制-->十进制
          parseInt("stirng", radix)
• 自动拆箱装箱
      jdk1.5以后，自动装箱，如果装箱的是一个字节，那么该数据会被共享不会重新开辟空间。
• 练习
      对一个字符串中的数值进行从小到大的排序

五、System

• 获取当前时间戳
      long currentTimeMillis()
• 属性
      getProperties()
          stringPropertieNames()
          getProperties(string)
              getProperties("line/file/path.separator")
          setProperties(key, value)

六、Runtime

• Runtime r = Runtime.getRuntime();
  Process p = r.exec("notepad.exe");
  p.destroy();

七、Math

• 常用的方法
      ceil()：返回大于参数的最小整数
      floor()：返回小于参数的最大整数
      round()：返回四舍五入的整数
      pow(a, b)：a的b次方
      random()：随机数
• Romdom类
      nextDouble()
      nextInt()
      nextInt(int n)

八、Date

• 构造方法
      Date()
      Date(毫秒值)
• 日期对象和毫秒值之间的转换
      毫秒值-->日期对象
          1、通过Date对象的构造方法 new Date(timeMillis);
          2、还可以通过SetTime设置。
      日期对象-->毫秒值
          getTime方法。
• 日期对象转化为字符串
      DateFormat.getDateInstance()
      DateFormat.getDateInstance(int style)
      DateFormat.getDateTimeInstance()
      DateFormat.getDateTimeInstance(int dateStyle, int timeStyle)
      new SimpleDataFormat(yyyy-MM-dd hh:mm:ss);
      ds.format(date);
• 字符串转成日期对象：
      parse(String dateStr)方法
• 练习
      两个日期相差天数

九、Calendar

• 常用操作：
      getInstance();
      c.get(常量值);
      set(year,month,day);
      add(常量值,数值);

Java集合框架

一、Collection

• 特点：
      1、用于存储对象的容器
      2、集合的长度是可变的
      3、集合中不可以存储基本数据类型值
• 体系
      Collection
          |--List        有序，有索引，可以重复。
              |--Vector        数组数据结构，同步，增删，查找慢。
              |--ArrayList    数组数据结构，不同步，代替Vector，增删慢，查找快。
              |--LinkedList    链表数据结构，不同步，增删快，查找慢。
          |--Set        无序，不可重复。
              |--HashSet        哈希表数据结构，不同步。
                  |--LinkedSet    有序
              |--TreeSet        可排序，也可有序，不同步。
• 共性方法
      1、添加
          boolean add(Object obj)
          boolean addAll(Collection coll)
      2、删除
          boolean remove(Object obj)
          boolean removeAll(Collection coll)
          void clear()
      3、判断
          boolean contains(Object obj)
          boolean containsAll(Collection coll)
          boolean isEmpty()
      4、获取
          int size()
          Iterator iterator()：去除元素的方式：迭代器
      5、其他
          boolean retainAll(Collection coll)：取交集
          Object[] toArray()：将集合转成数组
• Iterator
      1、使用
          hasNext()
          next()
      2、原理
          内部类

二、List

• 常见方法
      1、添加
          void add(index,element)
          void add(index,collection)
      2、删除
          Object remove(index)
      3、修改
          Object set(index, element)
      4、获取
          Object get(index)
          int indexOf(object)
          int lastIndexOf(object)
          List subList(from, to)
• ListIterator
      可以实现在迭代过程中完成对元素的增删改查。
          next        向后
          privious    向前
• 数组数据结构 & 链表数据结构图解
• Vector
      个性方法：
          Enumeration en = v.elements();
          en.hasMoreElements();
          en.nextElement();
          注意：被Iterator取代。
• ArrayList
      存储自定义对象图解
• LinkedList
      1、添加
          addFirst(o)
          addLast(o)
          jdk1.6
          offerFirst(o)
          offerLast(o)
      2、删除
          removeFirst(o) // 获取并移除，如果链表为空，抛出NoSuchElementException。
          removeLast(o)
          jdk1.6
          pollFirst(o) // 获取并移除，如果链表为空，返回null。
          pollLast(o)
      3、获取
          getFirst(o) // 获取但不移除，如果链表为空，抛出NoSuchElementException。
          getLast(o)
          jdk1.6
          peekFirst(o) // 获取但不移除，如果链表为空，返回null。
          peekLast(o)
      4、遍历
          !link.isEmpty()
          removeFirst(o)
          removeLast(o)
      练习
          使用LinkedList来模拟一个堆栈或者队列数据结构

三、Set

• HashSet
      哈希表确定元素是否相同
          1、判断的是两个元素的哈希值是否相同。
              如果相同，再判断两个对象的内容是否相同。
          2、判断哈希值是否相同，其实判断的是对象的hashCode方法。
              判断内容是否相同，用的是equals方法。
      哈希表确定元素是否相同图解
      存储自定义对象
          1、重写hashCode方法
              *27
          2、重写equals方法
              判断是否是同一个对象，是返回true；
              判断是否是同一种类型，不是就抛出类型转换错误。
      练习
          1、HashSet，依据hashCode、equals方法。    延伸：哈希表数据结构
          2、ArrayList，依据equals方法。        延伸：数组数据结构
• LinkedHashSet
      有序
• TreeSet
      判断元素唯一性的方式
          就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
      TreeSet 对元素进行排序的方式一
          让元素自身具备比较功能，就需要实现 Comparable 接口。覆盖 compareTo 方法。
      TreeSet 对元素进行排序的方式二
          让集合自身具备比较功能，定义一个类实现 Comparator 接口，覆盖 compare 方法。
              将该类对象作为参数传递给 TreeSet 集合的构造函数。
      TreeSet 二叉树图解
      练习
          字符串长度排序

四、Map

• 特点
      存储的是键值对
      必须保证键的唯一性。
• 体系
      Map体系：
      |--HashTable：    内部结构是哈希表，是同步的。不允许null作为键，null作为值。
          |--Properties：    用来存储键值对型的配置文件的信息，可以和 IO 技术相结合。
      |--HashMap：    内部结构是哈希表，不是同步的。允许null作为键，null作为值。
      |--TreeMap：    内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。
• 常用方法
      1、添加
          value put(key, value)：返回前一个和key关联的值，如果没有返回null。
      2、删除
          void clear()：清空map集合
          value remove(key)：根据指定的可以返回这个键值对
      3、判断
          boolean containsKey(key)
          boolean containsValue(value)
          boolean isEmpty()
      4、获取
          value get(key)：通过键获取值，如果没有该键返回null。
          int size()：获取键值对的个数。
• KeySet 方法图解
• EntrySet 方法图解
• values 方法
• HashMap 存储自定义对象
• TreeMap 存储自定义对象
• LinkedHashMap 有序 & 关联源码
• 练习：
      记录字母次数
      查表法

五、工具类

• Collections
      1、排序
          public static > void sort(List list)
          public static void sort(List list, Comparator c)
      2、调换位置
          public static void swap(List list, int i, int j)
      3、折半
          public static int binarySearch(List> list, T key)
          public static int binarySearch(List list, T key, Comparator c)
      4、最值
          public static > T max(Collection coll)
      5、逆序
          public static Comparator reverseOrder()
          public static Comparator reverseOrder(Comparator cmp)
          public static void reverse(List list)
      6、替换
          public static boolean replaceAll(List list, T oldVal, T newVal)
      7、其他方法
          public static void fill(List list, T obj)
          public static void shuffle(List list)
          public static ArrayList list(Enumeration e)
          public static Enumeration enumeration(Collection c)
      8、将非同步集合转成同步集合的方法
          public static List synchronizedList(List list)
          public static Map synchronizedMap(Map m)
          public static Set synchronizedSet(Set s)
          public static Collection synchronizedCollection(Collection c)
• Arrays
      toString 经典实现
      asList 方法：
          1、数组长度固定；
          2、存储非基本数据类型。
      toArray 方法：
          toArray(new 数组[n])：
              n小于集合长度，那么取集合长度；
              n大于集合长度，那么取长度为n。

六、1.5特征

• forEach 循环
      格式：for(类型 变量 : Collection集合|数组) {...}
      传统 for 和高级 for 的区别：
          传统 for 定义增量和条件；
          高级 for 对数组和集合的内容进行遍历。
• 函数可变参数
      定义：newAdd(int... arr)
      调用：newAdd(1,2,3,4)
      注意事项：可变参数类型，必须定义在参数列表的结尾处。
• 静态导入
      导入静态的方法

泛型

一、泛型

• 好处：
      1、将运行时期的问题ClassCastException转到了编译时期。
      2、避免了强制转换的麻烦。
• 擦除 & 补偿：
      1、擦除
          编译时，会将泛型去掉，生成的class文件中是不带泛型的，这个称为泛型的擦除。
      2、补偿
          在运行时，通过获取元素的类型进行转换动作。不用使用者再强制转换了。
• 应用：
      1、集合中使用
      2、迭代器中使用
      3、比较器中使用
• 泛型实现
      泛型类：
          1、定义--在类后面加
          2、使用--在类后面加<具体类型>
      泛型方法：
          1、定义--在修饰符和返回值之间添加
          2、使用--在使用的地方用具体类型
      泛型接口：
          1、定义--在接口后面加
          2、使用的两种情况：
              1）在实现的时候在接口后面加<具体类型>
              2）a）实现时在类后面加,创建实现类对象的时候在类后面加<具体类型>。
• 泛型限定
      上限
          特点：
              ? extends E：接收E类型或者E的子类型对象。上限!
          体现：
              一般在取出元素的时候都使用上限
      下限
          特点：
              ? super E：接收E类型或者E的父类型。下限！
          体现：
              通常对集合中的元素进行存储操作时，可以使用下限。
      通配符：
          依赖equals方法

IO流

一、输入流

• 输入
      将外设中的数据读取到内存中

二、输出流

• 输出
      将内存中的数据写入到外设中

三、字符流

• 字节流 + 编码表
• 字符流的两个顶层父类
      Reader Writer
• FileWriter & FileReader
      FileWriter
          构造函数
              FileWriter(Strng fileStr)
          方法
              fw.write(String str)
              fw.flush()：刷新
              fw.close()：关闭，先刷新。
          换行
              System.get("line-separator");
          续写
              FileWriter(String fileStr, boolean b)
      IO 异常处理
      FileReader
          构造函数
              FileReader(String fileStr)
          方法
              fr.read()
              fr.close()
          读取方式一
              read()
          读取方式二
              read(length)
      练习
          将c盘的一个文本文件复制到d盘
              两种方式
              图解
• 缓冲区
      解释
      BufferedWriter
          构造函数
              BufferedWriter(Writer w)
          方法
              newLine()
      BufferedReader
          构造函数
              BufferedReader(Reader r)
          方法
              readLine()
          readLine 方法原理
          自定义 read 方法
          自定义 readLine 方法
      练习
          复制文本文件
      装饰模式
          装饰类和被装饰类都必须所属同一个接口或者父类。
      LineNumberReader
          方法
              getLineNumber()
              setLineNumber()

四、字节流

• 字节流的两个顶层父类
      FilterOutputStream
      FilterInputStream
• FilterOutputStream & FilterInputStream
      FilterOutputStream
          方法：
              void write(int b)
              void write(byte[] b)
      FilterInputStream
          方法
              int read()
              int read(byte[] b)
              int available()
      练习
          复制MP3
              1、一个一个复制
              2、自定义字节数组复制
              3、通过BufferedInputStream、BufferedOutputStream。
              4、通过FilterInputStream的available()方法设置数组长度。

五、转换流

• 键盘
      System.in
      System.out
      练习
• 转换流
      InputStreamReader
      OutputStreamWriter
      图解
      练习

六、流的操作基本规律-四个明确

1. 明确源和目的（汇）
       源：InputStream Reader
       目的：OutputStream Writer
2. 明确数据是否是纯文本数据
       源：是纯文本：Reader
           否：InputStream
       目的：是纯文本：Writer
           否：OutputStream
3. 明确具体的设备
       源设备
           硬盘：File
           键盘：System.in
           内存：数组
           网络：Socket流
       目的设备
           硬盘：File
           控制台：System.out
           内存：数组
           网络：Socket流
4. 是否需要其他额外功能
       是否需要高效（缓冲区）
           是，就加上buffer
       转换。

• 练习
      复制一个文本文件
      读取键盘录入信息，并写入到一个文件中。
      将一个文本文件数据显示在控制台上
      读取键盘录入数据，显示在控制台上

七、File

• 构造函数
      File(String pathname)
      File(String parent, String child)
      File(File parent, String child)
• 字段
      File.separator
      File.pathSeparator
• 获取
      getName()
      getAbsolutePath()
      getPath()
      length()
      lastModified()
• 文件创建和删除
      createNewFile()
      delete()
• 文件夹创建和删除
      mkdir()
      mkdirs()
      delete()
• 判断
      exists()
      isFile()
      isDirectory()
      isHidden()
• 重命名 & 剪切
      renameTo(File file)
• 系统根目录
      listRoots()
• 容量获取
      getFreeSpace()
      getTotalSpace()
      getUsableSpace()
• 获取目录内容
      list()
          获取的是所有文件的文件名
          调用list方法的File对象中封装的必须是目录。
      listFile()
          获取的是所有文件的对象
• 过滤器
      FileNameFilter
          文件名过滤器
      FileFilter
          文件过滤器
• 递归
      对指定目录进行所有内容的列出（包含子目录中的内容）
      图解
      注意
          递归一定明确条件。否则容易栈溢出。
          注意一下递归的次数。
      删除一个带内容的目录

八、Properties

• 特点
      该集合中的键和值都是字符串类型。
      集合中的数据可以保存到流中。或者从流获取。
• 基本功能
      getPropery()
      setProperty()
      stringPropertyNames()
• list方法
      list(PrintStream out)
• store方法
      store(OutputStream out/Writer w, "comment)
• 修改配置信息
      load(InputStream inStream/Reader reader)
• 练习
      获取一个应用程序运行的次数，如果超过5次，给出使用次数已到请注册的提示。并不要再运行程序。
      建立一个指定扩展名的文件的列表

九、打印流

• PrintStream
      特点
          1、提供了打印方法可以对多种数据类型值进行打印。并保持数据的表示形式。
          2、它不抛IOException。
      构造函数，接收三种类型的值
          1、字符串路径。
          2、File对象。
          3、字节输出流。
• PrintWriter
      构造函数，接收四种类型的值：
          1、字符串路径。
          2、File对象。
          3、字节输出流。可设置自动刷新
          4、字符输出流。可设置自动刷新

十、序列流

• 构造函数
      SequenceInputStream(Enumeration en)
• Enumeration类型对象的来源
      1、Vector
      2、实现Enumberation静态内部类，通过ArralyList的迭代器来完成对象方法。
      3、Collections的enumerations()方法。
• 文件合并和切割
      文件切割
          一个输入，多个输出。
      文件合并
          使用SequenceInputStream
      文件切割合并+配置文件
          1、文件切割合并
          2、配置文件
              配置文件名和切割后文件个数。

十一、对象的序列化

• ObjectOutputStream
      构造函数
          ObjectOutputStream(OutputStream os)
      方法
          writeObject(Object obj)
• ObjectInputStream
      构造函数
          ObjectInputStream(InputStream is)
      方法
          readObject()
      Serializable
          用于给被序列化的类加ID号的。
          用于判断类和对象是否是同一个版本。
      transient
          静态的不能被序列化。
          非静态数据不想被序列化可以使用这个关键字修饰。

十二、随机读写文件

• 特点
      1、该对象既能读，又能写。
      2、该对象内部维护了一个byte数组，并通过指针可以操作数组中的元素。
      3、可以通过getFilePoint方法获取指针的位置，通过seek方法设置指针的位置。
      4、其实该对象就是将字节输入流和输出流进行了封装。
      5、该对象的源或者目的只能是文件。通过构造函数就可以看出。
• 构造方法
      RandomAccessFile("fileName", "rw/..")
• 方法
      写 文件没有就创建；有，就覆盖内容。
          write(byte[] b)
          writeInt()
      读
          read(byte[] b)
          readInt()
• 随机写入，方法
      seek(index)
      getFilePoint()
      作用
          可以多个线程同时操作，往不同的位置写入。

十三、管道流

• PipedInputStream
      构造方法
          PipedInputStream(PipedOutputStream pos)
      方法
          connect(PipedOutputStream pos)
• PipedOutputStream
  注意
      结合多线程，输出的内容为输入的内容。

十四、基本类型数据的流对象

• DataInputStream
      构造函数
          DataInputStream(InputStream is)
      方法
          readUTF()
• DataOutputStream
      构造函数
          DataOutputStream(OutputStream os)
      方法
          writeUTF()

十五、操作数组的流

• ByteArrayInputStream
      构造函数
          ByteArrayInputStream(byte[] b)
      函数
          read()
• ByteArrayOutputStream
      构造函数
          ByteArrayOutputStream()
      函数
          write(byte[] b)

十六、编码解码

• 编码表
      ASCII、IOS8859-1、GB2312、GBK、Unicode、UTF-8
• 简单的编码解码
      字符串 --> 字节数组 编码
          str.getBytes(["utf-8"])
      字符数组 --> 字符串 解码
          String(buf[, "utf-8"])
• 编码解码问题
      问题1 解码错误还有救，一个字节的编码。
      问题2 解码错误没有救，三个字节的编码。
      联通问题 gbk 编码刚好符合 utf-8 解码规律
• 练习
      按字节截取字符串

GUI

一、概述

• 概述
      GUI
      CLI
• 布局
      图解
• 体系
      Component
          |--Container
              |--Window
                  |--Frame
                  |--Dialog
                      |--FileDialog
              |--Panel
          |--Button
          |--CheckBox
          |--TextComponent
              |--TextArea
              |--TextField

二、Frame 演示

1. 创建容器
       Frame(name)
2. 设置
       setSize(width, height)
       setLocation(x, y)
       setBounds(x, y, width, height)
       setLayout(new FlowLayout())
3. 创建配件
       Button but = new Button(name)
4. 添加配件
       add(but)
5. 设置可视
       setVisible(boolean)

三、事件监听机制

• 图解
• 事件监听机制
      f.addWindowListener(new WindowAdapter() {
          public void windowClosing(WindowEvent e) {
          }
      }

四、ActionListener 演示

•     but.addActionListener(new ActionListener() {
          public void actionPerformed(ActionEvent e) {
          }
      }

五、鼠标事件

•     but.addMouseListener(new MouseAdapter() {
          public void mouseEntered(MouseEvent e) {
          }
          public void mouseClicked(MouseEvent e) {
          }
      }

六、键盘事件

•     addKeyListener(new KeyAdapter() {
      });

网络编程

一、网络模型概述

• OSI 参考模型
      物理层、数据链路层、网络层、传输层、会话层、表示层、应用层
• TCP/IP 参考模型
      主机至网络层、网际层、传输层、应用层

二、网络三要素

• 传输协议
      UDP
          不需要建立连接
          64k以内
          不可靠
          速度快
      TCP
          需要建立连接
          大数据量
          可靠
          效率低
• IP 地址
      本机回环地址
          127.0.0.1 localhost
      InetAddress
          getLocalHost()
          getByName(主机名/ip地址)
      方法
          getHostAddress()
          getHostName()
      域名解析
• 端口号
      有效端口
          0~65535，其中0-1024系统使用或保留端口。

三、UDP 协议

• 发送端
      1）建立udp的socket服务
          DatagramSocket ds = new DatagramSocket();
      2）将要发送的数据封装到数据包中
          byte[] buf = "xxx".getBytes();
          DataGramPacket dp = new DatagramPacket(
              buf, buf.length, InetAddress.getByName("127.0.0.1"), 10000);
      3）通过udp的socket服务将数据包发送出去
          ds.send(dp);
      4）关闭socket服务。
          ds.close();
• 接收端
      1）建立udp socket服务
          DatagramSocket ds = new DatagramSocket(10000);
      2）创建数据包，用于存储接收到的数据。方便用数据包对象的方法解析这些数据。
          byte[] buf = new byte[1024];
          DatagramPacket dp = new DatagramPacket(buf, buf.length);
      3）使用socket服务的receive方法将接收的数据存储到数据包中。
          ds.receive(dp);
      4）通过数据包的方法解析数据包中的数据。
          String ip = dp.getAddress().getHostAddress();
          int port = dp.getPort();
          String text = new String(dp.getData(), 0, dp.getLength());
      5）关闭资源
          dp.close();
• 练习
      使用多线程

四、TCP / IP 协议

• 客服端
      1）创建tcp客户端socket服务。使用的是Socket对象。
          建议该对象创建就明确目的地。要连接的主机。
          Socket socket = new Socket("127.0.0.1", 10000);
      2）如果连接建立成功，说明数据传输通道已建立。
          该通道就是socket流，是底层建立好的。既然是流，说明这里既有输入，又有输出。
          想要输入或者输出流对象，可以找Socket来获取。
          可以通过getOutputStream()，和getInputStream()来获取两个字节流。
          OutputStream out = socket.getOutputStream();
      3）使用输出流，将数据写出。
          out.write("xxx".getBytes());
      4）关闭资源
          socket.close();
• 服务端
      1）创建服务端socket服务。通过ServerSocket对象。
      2）服务端必须对外提供一个端口，否则客户端无法连接。
      3）获取连接过来的客户端对象。
      4）通过客户端对象获取socket流读取客户端发来的数据。并打印在控制台上
      5）关闭资源。关客户端，关服务端。
      ServerSocket ss = new ServerSocket(10000);
      socket s = ss.accept();
      String ip = s.getInetAddress().getHostAddress();
      InputStream in = s.getInputStream();
      byte[] buf = new byte[1024];
      int len = in.read(buf);
      String text = new String(buf, 0, len);
      System.out.println(ip + ":" + text);
      s.close();
      ss.close(); // 一般不关
• 练习
      文本转换
          常见问题：两边都等待。阻塞式方法。需要换行和自行刷新。
      上传文本文件
          shutdownOutput
      上传图片
          多线程：创建每个客户端，然后传输传入多线程任务中，才操作。
• 常见客户端和服务端
      客户端
          浏览器：IE
      服务端
          tomcat
      服务端原理：
          请求行
          请求头
          请求体
      模拟客户端：
          响应行
          响应头
          响应体
• URL & URLConnection
      构造方法
          URL("str_url")
      方法
          InputStream openStream()
          URLConnection openConnection()
• 常见网络结构
      C/S client/server
          特点
              该结构的软件，客户端和服务端都需要编写。
              开发成本较高，维护较为麻烦。
          好处
              客户端在本地可以分担一部分运算。
      B/S browser/server
          特点
              该结构的软件，只开发服务器端，不开发客户端，因为客户端直接用浏览器取代。
              开发成本相对低，维护更为简单。
          缺点
              所有运算都要在服务端完成。

反射

• 概述 & 应用场景
      图解
• Class 对象
      图解
• 获取Class对象的三种方式
      1、对象.getClass()
      2、类.class
      3、Class.forName("类名")
• 获取Class中的构造函数
      1、clazz.newInstance()
      2、clazz.getConstructor(clazz...).newInstance(实参)
• 获取Class中的字段
      1、class.getDeclareField(filedName)
          class.getField(filedName)
      2、filed.setAccessible(true)
          filed.set(obj, xxx)
          filed.get(obj)
• 获取Class中的方法
      1、getMethods()
          getDeclareMethods()
      2、getMethod(methodName, class...)
          getDeclareMethod(methodName, class...)
      3、method.invoke(obj, 实参)
• 练习

正则表达式

• 概述
• 常见规则
      [n]    ：内容，只有n。
      [m-n]    ：内容，m到n。
      \d    ：内容，0-9。
      .    ：内容，任何内容。
      {n}    ：次数，只有n次。
      {m,n}    ：次数，m到n次。
      +    ：次数，1次或者多次。
      ()    ：组
      \n    ：第n组
      $n    ：replaceAll方法第二个参数引用第一个参数的内容。
      \b    ：单词边界
      \w    ：单词
• 常见功能
      匹配：
          matches
      切割：
          split
      替换
          replaceAll
      获取：
          Pattern p = Pattern.compile(regex);
          Matcher m = p.matcher(str);
          m.find();
          m.group();
• 练习
      治疗口吃
      ip 地址排序
      邮件地址校验
      爬虫