大数据预科班总结

蔚落 2022-06-08 14:13 193阅读 0赞

# 大数据预科班复习 #

### 语法部分 ###

*  java的技术结构
    
     *  J2SE--标准版
     *  J2EE--企业版
     *  J2ME--移动版--变种之后安卓--Kotlin语言
 *  java的跨平台
    
     *  基于java虚拟机，java语言是跨平台的，虚拟机不是跨平台的（不是java专属--只要java虚拟机能识别就可以）
 *  配置环境变量
 *  java命令
    
     *  javac -d 路径 java源文件 --带包编译【当java文件有package com.peng.demo;时，写入-d的作用是自动创建包结构】
     *  java -cp class的路径 类的全路径名 【cp访问指定的路径的class文件】
 *  关键字
    
     *  赋予特殊含义
     *  53（goto，const一般不用）---版本的升级，关键字也变多了
     *  小写
 *  标识符
    
     *  数字、字母、\_、$，但是$尽量少用--内部类
     *  数字不能开头
     *  不能使用关键字
     *  见名知义
     *  驼峰命名法--习惯上
 *  注释
    
     *  单行注释
     *  多行注释
     *  文档注释--javadoc -d 路径 java文件--命令的使用要求这个类必须是公共类
     *  作用：解释程序；辅助排错
 *  断言（预测）
    
     *  assert不是默认开启的--命令行中java -ea Demo【dos下】
     *  Eclipse中的断言：配置--右键run as配置 arguments--vm中加-ea【单个文件】
     *  Eclipse中的所有配置断言--build path
     *  assert i==10 : "comments";
 *  常量
    
     *  整数（常量池）
     *  小数（常量池）
     *  字符（常量池）
     *  字符串（常量池）
     *  布尔
     *  null
 *  进制
    
     *  二进制 jdk1.7开始，允许代码用0b开头表示
     *  八进制 以0开头
     *  十进制
     *  十六进制 0x开头
     *  掌握进制的转换
 *  变量
    
     *  数据类型 变量名 = 变量值；//对象也是一种变量
     *  变量必须先定义后使用
     *  变量必须先复制才能使用
 *  数据类型
    
     *  基本数据类型
        
         *  整型
            
             *  byte 一个字节【-128~127】-27~27\-1
             *  short 两个字节 【-32768~32767】-215~215\-1
             *  int 四个字节 --整数默认类型-231~231\-1
             *  long 八个字节-263~263\-1
         *  小数
            
             *  float 单精度-2127~2127\-1
             *  double双精度-21023~21023\-1
         *  字符型
            
             *  char两个字节0~65535
         *  布尔
            
             *  boolean
     *  引用数据类型
        
         *  类
         *  接口
         *  数组
     *  注：0x5p2十六进制的科学计数法5\*22
     *  数据转换
        
         *  隐式转换--小转大（小转大，整数转小数）
         *  显示转换--注意精度
 *  运算符
    
     *  算数
        
         *  算数运算完成之后类型不变
         *  byte/short运算时自动提升为
         *  注意/0
            
             *  整数报错
             *  小数/0 infinite正负无穷
             *  小数0.0/0 NaN--NaN和任何数都不相等
         *  取余看左边
         *  int i=3; i=i++;
            
            #  #
            
                计算区域：不涉及变量--结果的标记与返回
                存储区域：存储变量
                //java -c -v -s查看内存
         *  \++/--可以作用在byte，short上
     *  赋值
        
         *  优先级高
         *  可以作用在byte和short
     *  比较
        
         *  instanceof 判断对象与类的关系
     *  逻辑
        
         *  注意^运算规则
         *  注意短路&&和||特性
         *  在同一运算中，||比&&高半级
            
             *  true||(3>4)&&(5>5)
             *  true&&(3>4)||(5>5)
     *  位
        
         *  针对整数
         *  位运算--补码进行运算
            
             *  正数：原反补码一致
             *  负数：反码（高位1不变，其他取反），补码（在补码基础上+1）
         *  异或运算--整数
     *  三目
        
         *  运算完之后一定会有一个运算结果
         *  两个表达式的结果要相容（类型）
 *  流程控制
    
     *  判断
        
         *  if
         *  if-else
         *  if --if eles
     *  选择
        
         *  switch-case
            
             *  表达式byte 、short、char、int、枚举、String（效率低）
             *  【byte、short、char】->int
             *  case都有一个break，互不影响会执行完才结束
     *  循环
        
         *  while--不确定次数的时候
         *  do-while
         *  for--确定次数的时候
         *  break结束一层循环和选择结构
         *  continue跳过一层循环
         *  标记
 *  数组
    
     *  用于存储同一类数据的容器
     *  大小固定
     *  三种方式
     *  数组的存储问题--存到堆内存--自动赋予初始值
     *  数组的应用
        
         *  数组元素的排序--冒泡O(n2)---（n-1）（n-i）趋向n2
         *  数组元素的排序--选择(n2)
     *  元素的查找--折半查找（二分查找）O（log2n）-----2x=n
     *  数组的反转
     *  数组的扩容--产生一个新的数组
 *  函数
    
     *  提高复用性、降低冗余度
     *  定义了返回值类型，就要保证函数一定有返回值
     *  函数的重载
        
         *  一个类中：函数名一致，参数不同；编译时多态；和修饰符，返回值类型以及异常无关
     *  函数的重写
        
         *  继承（父子类）
         *  方法签名一致
         *  两等两小一大
         *  运行时多态--向上造型
     *  函数的递归
        
         *  方法自己调用自己本身
         *  控制条件（递归结束）--栈溢出------递归的效率比循环低（开辟新的内存）
     *  函数作用
        
         *  复用性
         *  代码结构更加清晰
         *  便于模块化开发

### 面向对象 ###

*  面向对象和面向过程
    
     *  面向过程--注重过程---适用于业务相对简单的场景
     *  面向对象--只要找到对象，就有了对象身上的方法和属性
 *  类与对象的关系
    
     *  类是对象的概括
     *  对象是类具体化
 *  构造函数
    
     *  与类同名
     *  没有返回值类型
     *  可以重载，但是不能被继承（private，代码块，构造方法--不能被继承）
     *  创建对象，初始化操作-----对象已经创建了，标记对象的开始
 *  this
    
     *  代表对象的引用
     *  调用本类中的方法和属性
     *  this语句--本类中构造函数中首行调用其他构造函数
 *  代码块
    
     *  静态代码块
     *  局部代码块--定义在方法或语句内--限制变量的生命周期，提高内存利用率
        
         *  方法--有名字的代码块
     *  构造代码块--类内方法外--构造函数执行之前，初始化操作
 *  面向对象的特征
    
     *  封装
        
         *  体现形式：方法、属性的私有话、内部类
         *  提高复用性、提高安全性
     *  继承
        
         *  extends
         *  单继承--针对的主体是类
            
             *  多继承在提高代码的复用性要好的多，但是多继承会导致调用方法的混乱
             *  单继承复用性低，但是提高代码安全性
             *  继承结构--统一
     *  多态
        
         *  编译是多态
         *  运行时多态--基于继承
            
             *  向上造型
             *  重写
         *  作用--灵活调用（同一方法，不同功能）；解耦的关键之一、
 *  权限修饰符
    
     *  public
     *  protected
     *  包权限
     *  private
     *  本类和本类对象使用--两回事
 *  super
    
     *  在子类中指向父类的引用
     *  super（）在子类的构造函数中，调用父类的对应形式的构造函数。--子类构造函数的首行
 *  static
    
     *  属性
        
         *  静态变量--类变量--加载到方法区的静态区，自动赋予初始值，优于对象存在，通过类名调用，共享的数据；只能在类内定义。
     *  方法
        
         *  随类加载到方法区的静态区，只是存储到静态区，调用时到栈中执行，，不允许调用非静态的方法和属性
         *  可以被继承，不能重写
         *  字符类方法签名一致，要么都是static，要么都是非静态的
         *  多态------属性不存在多态，方法才有多态------【向上造型】属性父类管，方法子类管方法
     *  代码块
        
         *  类加载的时候只加载一次--第一次真正的使用的时候，第一次创建对象或调用方法
     *  内部类
 *  final
    
     *  变量--值不可变（基本类型--真实值，引用数据类型-地址不可变，属性可变）
     *  方法--可以重载，可以继承，不可以重写【类的构造函数私有化--内部类：enum】
 *  abstract
    
     *  抽象类
        
         *  不能被实例化，但是存在构造函数
         *  不一定有抽象方法
     *  抽象方法
        
         *  没有方法体
         *  可以重载
         *  不可以被static/final/private
         *  如果抽象方法默认那么子类必须同宝
 *  接口
    
     *  interface
     *  implements
     *  类与接口---多实现
     *  接口与接口
     *  接口只能定义抽象方法（jdk1.7）
     *  属性public static final
     *  方法public abstract
 *  内部类
    
     *  方法
     *  成员
     *  静态--其他内部类不能定义静态属性和静态方法，但是可以定义静态常量
     *  匿名内部类--实质实现接口或继承类
    
    #  #
    
        1. 创建内部类的格式
        2. 内部类中使用外层变量--final修饰
 *  包
    
     *  package
     *  import导包
     *  核心包java.lang程序执行自动加载
     *  分隔不同路径的同名类
 *  垃圾分代回收机制
    
     *  针对堆
     *  新生代【伊甸园区、幸存区】
     *  老生代【】
    
    #  #
    
        回收过程和扫描频率
        伊甸园区->幸存区->老生代      
        --minor初代回收--新生代
        --full 完全回收--老生代

### API ###

*  Object
    
     *  java中的顶级父类，是java中没有父类的类
     *  方法
        
         *  getClass获取对象的实际类型
         *  equals比较两个对象是否一致（默认判断地址）
         *  toString--对象的字符串形式--直接打印对象，实际调用了toString方法
 *  String
    
     *  代表字符串的类
     *  常量，定义好不可变（地址变）；字符串是被共享的；
     *  不同的方式创建，产生的对象个数不同
    
    #  #
    
        1. String s="";//栈->常量池
        2. String s=new String();
        3. String s=new String("");//栈->堆->常量池
    
     *  String的一系列方法
     *  多个字符串StringBuilder【线程不安全】或StringBuffer【线程安全】
     *  \+用StringBuilder或StringBuffer的append
 *  Pattern
    
     *  规则和指定和校验
     *  数量词--每个字符后面最多一个数量词、预定义字符
        
         *  .+\{1,2\}
     *  捕获组
        
         *  左边第一个括号开始
         *  叠字（.）\\1
         *  至少两个字符(.)\{2,\}
 *  包装类
    
     *  int-Integer
     *  char- Charactor
     *  自动封箱和拆箱--jdk1.5的特性之一
        
         *  自动封箱：valueOf
         *  自动拆箱：XXXVaule
     *  缓存类的存在-Integer（-128~128）
     *  byte---short----int------自动转化吗？
 *  数学类
    
     *  Math
        
         *  最终类
         *  构造函数私有化
         *  工具类
         *  基本的数学运算--不保证精确性
     *  BigDecimal
        
         *  精确运算
         *  方法：
         *  精确计算--参数为字符串
 *  日期类
    
     *  Date
        
         *  java.util.Date
         *  掌握字符和日期对象的转换--SimpleDateFormat
     *  Calendar
 *  异常
    
     *  Throwable顶级父类
     *  Error出现之后不用处理
     *  Exception--异常
        
         *  编译时异常--必须处理
         *  运行时异常--可处理可不处理
     *  异常的捕获
        
         *  单独
         *  同一
         *  分组处理
     *  自定异常
        
         *  继承某个异常类
     *  try-catch-finally
 *  Collection
    
     *  存储一组数据
     *  大小不固定
     *  List列表
        
         *  ArrayList
            
             *  初始容量10，扩容一半，内存连续，线程不安全，便于查询，不善于增删
         *  LinkedList
            
             *  基于链表，内存不连续，线程不安全，便于增删，不善查找
         *  Vector
            
             *  线程安全，10，一倍
             *  Stack
                
                 *  先进后出
     *  Set散列集合
        
         *  HashSet
            
             *  无序，不可重复，16，0.75f，一倍，线程不安全
     *  Queue
        
         *  先进先出
 *  迭代器
    
     *  用于迭代遍历--其中不允许增删原集合
     *  增强for循环--类实现iterable------jdk1.5
 *  计较器
    
     *  Comparator--compare--正负数确定位置
     *  没有指定规则--类实现Comparable，重写compareTo方法
 *  泛型
    
     *  参数化类型--parameterizedType--jdk1.5
     *  泛型擦除--代替--编译器
     *  了解泛型的继承--泛型的上下限
 *  Map
    
     *  映射
     *  以键值对形式来存储元素
     *  键唯一，值不唯一
     *  遍历-keySet；EntrySet
     *  HashMap16，0.75f，一倍，null可以，异步式线程不安全
     *  HashTable null不允许，11，0.75，同步式线程安全的映射
     *  Properties
        
         *  持久化保存--不允许中文--iso-8859-1
 *  File
    
     *  代表文件或者目录
     *  不一定真实存在
     *  文件的删除和提取
 *  RandomAccess
    
     *  对文件读写的双向流--可读可写
     *  把文件看成一个大字节数组
     *  权限的给定--rwd
 *  IO
    
     *  传输数据的API
     *  字符输出流的缓冲---flush
     *  异常处理
     *  序列化和反序列化流
        
         *  序列化（将对象完成保存）
         *  反序列化
 *  枚举
    
     *  enum
     *  常量首行
     *  构造函数私有化
     *  属性，方法，抽象方法
     *  java.lang.enum-----------------jdk1.5----------支持switch-case

### 内存 ###

*  虚拟机栈
    
     *  存储区域
        
         *  存储方法或语句执行过程中产生的一系列变量
     *  计算区域
        
         *  用于方法或者表达式的计算执行的
     *  栈内存的作用是计算的
     *  用完之后立即释放
 *  堆
    
     *  新生代
        
         *  伊甸园区
         *  幸存区
     *  老生代
     *  作用：堆内存用于存储对象的
     *  用完之后不定期gc回收
 *  方法区
    
     *  静态常量池
        
         *  存储一些普通信息
     *  静态区
        
         *  存储静态信息
     *  运行时常量池
        
         *  存储常量（计算机常量+自定义常量）
     *  作用：存储类信息--信息只要放进方法区--只存一份（为了节省内存），就不在释放--OutOfMemoryError
 *  本地方法栈
    
     *  存储和执行本地方法
        
         *  用native关键字修饰的方法
         *  别的语言写的：c或c++
 *  计数器
    
     *  任务调度
     *  资源管理

### jdk1.5 ###

#  #

1. 增强for
    2. enum
    3. 静态导入
        1. import static 包名.类名.方法名
        2. 只能导入静态方法
        3. 可读性不强
        4. 方法直接写
    4. 可变参数
        1. int...arr
            1...定义可变参数
        2. 本质为数组
        3. 参数个数【0，】
        4. 一个参数列表只允许定义一个可变参数，而且可变参数放末尾
        5. eg：asList
    5. 泛型