1 基本语法
l 基本类型
n 字面值规则（5条）
n 运算规则（5条）
u 3/2, 1
u byte,short,char
byte a = 3;
a << 24
u Integer.MAX_VALUE+1
u 2-1.9, 0.10000000000009
u Infinity
NaN
l 运算符
n +-*/
n %
n == != > >= < <=
n && || !
n & | ^ ~
n >> >>> <<
n ++ --
n ? :
n =
n += >>= ^= ...
n ()
n instanceof
l 流程控制
n swtich 只能判断byte,short,char,int
n enum
n jdk1.7，String
l 数组
n int[] a = new int[5];
n int[] a = {3,7,3,1};
n a = new int[]{2,6,8,23,67};
f(a);
print(a[0]);//0
g(a);
print(a[0]);//0
...
void f(int[] a) {
a[0] = 0
}
void g(int[] a) {
a = new int[]{99,88,77};
}
n Arrays
u Arrays.sort()
l 基本类型，优化的快速排序
l 引用类型，优化的合并排序
u Arrays.binarySearch()
u Arrays.toString()
u Arrays.copyOf()
2 面向对象
l 什么是面向对象
n 封装、继承、多态
l 封装
n 类
n 对象
n 引用
n 构造方法
n this
n 重载
n 隐藏 private
l 继承
n 作用：代码重用、代码复用
n 单继承
n 子类对象
u 由父类对象和子类对象绑定，整体作为一个对象
u 调用成员时，先找子类，再找父类
n 重写
n 父类构造方法
u 默认值 super()
u 手动调用 super(参数)
n super
u super.xxxx()
l 一般重写时，调用父类同一个方法代码
u super()
l 多态
n 作用：一致的类型
所有子类型对象，都可被当做一致的父类型进行处理
n 向上转型，向下转型
n instanceof
运行期类型识别
l 抽象类，半成品
l final
n 常量
n 方法，不能重写
n 类，不能继承
l static
n 属于类，不属于对象
n 保存在方法区
n static {
}
l 访问控制
n public,protected,[default],private
l 对象创建过程（10步）
l 接口
n 作用：结构设计工具，解耦合、隔离实现
l 内部类
n 匿名内部类
3 基础API
l Object
n toString()
n equals()
n hashCode()
n wait()
n notify()
n notifyAll()
n getClass()
l String
n 常量池
//编译器优化成："aaabbbccc"
String s1 = "aaa"+"bbb"+"ccc";
String s2 = "aaabbbccc";
s1 == s2 //true
s1 + s2 + s3 + s4
u 字符串连接的运算过程：
s1 + s2
sb = new StringBuffer(s1);
sb.append(s2);
sb.toString()
l StringBuilder/StringBuffer
n StringBuilder 线程不安全，效率高
n StringBuffer 线程安全
l 正则表达式
n 百度“正则表达式大全”
l 基本类型包装类
n Integer.valueOf()
256个缓存对象，-128到127
l BigDecimal,BigInteger
n 精确浮点数运算，超大整数运算
n BigDecimal.valueOf(2)
l Date
l SimpleDateFormat
4 集合
l ArrayList
n 访问任意位置效率高
n 增删数据效率可能低
n 默认容量10, 1.5倍增长
l LinkedList
n 两端效率高
n 数据量小时，频繁增删数据效率高
l HashMap
n key.hashCode()
n 哈希值计算下标 i
n 新建Entry对象，放入i位置
u 空位置，直接放入
u 有数据，依次用equals()比较是否相等
l 有相等的，覆盖值
l 没有相等的，链表连接在一起
u 负载率，加载因子 0.75
l 新建翻倍长度新数组
l 所有数据，重新执行哈希运算，放入新数组
u jdk1.8
l 链表长度到8，转成红黑树
l 红黑树减少到6，转回链表
l HashSet
n 内部用HashMap的键存放数据
l HashTable
n 旧版本的哈希表
n 线程安全
l TreeMap
n 红黑树
n 键：不重复，有序
n 键比较大小，使用Comparable或Comparator
l TreeSet
l ConcurrentHashMap
l ConsurrentHashSet
n 添加线程同步锁，保证多线程并发访问安全
n 对内部数据，进行分段，每一段单独加锁
l LinedHashMap
n 有序的HashMap
n 哈希表
n 存放的数据，形成双向链表结构
n 从第一个数据，依次向后访问每个数据
n 可以用键迅速定位查找数据
5 异常
6 io
l 序列化
n ObjectInputStream/ObjectOutputStream
n 被序列化对象必须实现 Serializable
n readObject()
n writeObject()
l NIO
n new IO
n 非阻塞的io操作模型
n 频道，区分不同客户端的数据
7 线程
l 线程创建
n 继承 Thread
n 实现 Runnable
l 方法
n Thread.sleep() 不释放锁
n join() 不释放锁
l wait() 释放锁
l 同步synchronized
n synchronized(对象) {
}
n synchronized void f() {
}
n static synchronized void f() {
}
l 生产者、消费者
n 线程之间、进程之间的通信模型
l 等待通知
n wait()
n notify()
n notifyAll()
n 必须在synchronied 代码内调用
n 等待通知的对象，必须是加锁的对象
l 线程池
n ExecutorService/Executors
n Executors.createCachedThreadPool()
n Executors.createFixedThreadPool(5)
l Callable/Future
n 在线程执行结束后，自动运行一段代码
8 网络
9 反射
l 类对象
n A.class
n Class.forName("类名")
n 对象.getClass()
l 创建实例
n c.newInstance()
10 注解
11 JVM优化
l 垃圾对象
n 从根对象出发，所有被引用的对象，都是存活对象
n 其他对象，都是垃圾
n 根对象：
u 栈中的引用变量，所引用的对象
u 方法区经静态变量所引用的对象
l 标记-清除
n 标记存活对象，清理其他垃圾对象
n 优点：效率高
n 缺点：产生碎片
l 标记-整理
n 优点：没有碎片
n 缺点：效率低
l 复制
n 优点：效率高
n 缺点：浪费内存
l 内存分区
n 新生代
n 老年代
n 永久代（方法区）
l 新生代
n 伊甸园
n 生存区
u from
u to
n 新建对象，在伊甸园分配内存
n 伊甸园存满，复制到from
n from存满，复制到to，并交换角色
n 对象在from，to之间复制15次，晋升到老年代
l 老年代
n 标记-清除、标记-整理
n 间隔一段时间，会执行一次小范围垃圾回收
n 当老年代空间占用到一定比例 0.85，会执行full-gc
l 垃圾回收器
n CMS
n G1
l CMS - 并发的标记-清除
n STW(Stop The World)时间非常短暂
n 初始标记(stw)
u 只标记根对象
n 并发标记
u 垃圾回收器，与其他java程序并行执行
n 重新标记(stw)
n 并发清除
u 与其他java程序并行执行
n 配置参数过多，使用过于复杂
l G1 - Garbage First
n 内存被划分成几千个内存块
n 有伊甸园、生存区、老年代
n 用复制算法
n G1会找到垃圾最多的内存块，优先回收
n 配置参数非常简单，只需要配置目标停顿时间(stw)，G1自动调整其他参数，来达到预期的停顿时间
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
