Java基础知识介绍

数组的定义及初始化方式

• 数组对象创建没有()
• 一维数组
  • 静态初始化：
    • String[] books = {"Thinking in Java","Effective Java"};
    • String[] books = new String[] { "Thinking in Java","Effective Java" };
  • 动态初始化：
    • String[] books = new String[2]; //必须指定长度，然后单独赋值
• 二维数组
  • String[][] str = {{"a","b","c",},{"d","e","f",},{"g","h","i"}};
  • String[][] str1 = new String[][]{{"a","b","c",},{"d","e","f",},{"g","h","i"}};
  • String[][] arr = new String[3][4];

Java内存分配图

• 构造方法不能被继承
• this和super指的是同一个对象（当前对象自动含有的对本类和父类对象的引用）
• 方法的重载也是多态的一种形式
• final类可以被实例化
• abstract类不能被实例化，但是可以有构造方法

静态初始化只会在必要时刻才会进行

• 并非启动项目时就会加载所有的class类（static域初始化），而是仅加载启动程序所需要的基础的class，在程序上进行操作时会用到新的类，才会去加载类的class文件（类在初次使用时才会加载），若此对象有静态域，则会在此时进行加载（加载类时才会初始化静态域），然后初始化这个类对象。（构造器默认也是static方法，因此可以说，类是在其任何static成员被访问时加载的）

java对象创建过程

1. 首先JVM查找CLASSPATH下类名称所在的路径，定位class文件。
2. 加载class文件，执行静态数据对象初始化工作（只在class对象首次加载时初始化一次）。
3. 使用 new 创建对象，首先在堆内存上为此对象分配足够的内存空间。
4. 清空内存空间，执行对象的自动初始化。
5. 执行所有出现在字段定义处的初始化。
6. 执行构造器。

继承中的对象初始化过程

1. 基类的静态属性、代码块（按代码的先后顺序）
2. 导出类的类静态属性、代码块
3. 基类的普通属性、代码块
4. 基类的构造方法
5. 导出类的普通属性、代码块
6. 导出类的构造方法

• 类加载完成后（静态域初始化完成后）才会去调用方法如main()，才会创建对象，初始化普通域。

OOP

• 封装：

  • 为数据、属性和方法设置适当的访问权限以隐藏具体实现细节，然后包装到一个类中。
  • 封装的结果是产生一个带有特征和行为的数据类型。

• 继承（或实现）：

• 多态：

• 抽象：

容器

一张图

三个知识点:

1. 迭代器

   • 使用Iterator遍历，最安全：所有实现了 Collection 接口的容器类都有一个 iterator() 方法用以返回一个实现了 Iterator 接口的对象

   • foreach 使用foreach遍历的集合必须实现 java.lang.Iterable 接口，必须重写 iterator 方法，返回一个实现了 Iterator 接口的对象

2. 比较器：

   • 实现实体对象的排序：需要实现Comparable接口
   • 排序比较器（解耦，多种排序规则）：实现 Comparator 接口
   • List + Collections.sort()；
   • Tree
   • Arrays

3. 泛型：

   • 泛型类：不能用在静态方法及属性上，不能用在catch语句块中
   • 泛型方法：方法声明中加上“”表示这是一个泛型方法
   • 泛型与继承的关系：若类 A 是类 B 的子类，则 List<A> 就不是 List<B> 的子类
   • 通配符：
     • ？，可以是任意类型
     • ？ extends A : 可以存放 A 及其子类
     • ？ super A : 可以存放 A 及其父类
     • 可以读取声明为通配符的集合类的对象，不允许写入（null除外）

六个接口：

1. Collection：是高度抽象出来的集合，它包含了集合的基本操作和属性.

2. List：元素有序可重复，相当于动态数组，添加进List集合中的元素（或对象）所在的类一定要重写equals()方法，这里所说的顺序是指：元素插入的顺序与输出的顺序不一致.

3. Set：元素无序不可重复，底层是Map(Set 的不可重复就是利用了 Map 中键对象的不可重复性！)，相当于数学中的集合，添加进Set集合中的元素所在的类要求重写equals() 和 hashCode()方法.

• 无序性：无序性！= 随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
• 不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。

1. Map：数组中的链表，存储“键-值”对的数据，key使用Set存放，不允许重复 。value可以重复的，使用Collection来存放的。一个key-value对构成一个entry(Map.Entry)，entry使用Set来存放。

2. Iterator：仅用来遍历集合Collection元素。

3. Comparable && Comparator

九个具体实现类：

1. ArrayList：查询数据较快，效率高，底层是数组实现，数组元素相当于对象的成员变量，默认值与成员变量一样
2. LinkedList：更适用于频繁的插入、删除操作
3. HashSet：当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
4. LinkedHashSet：使用链表维护了一个添加进集合中的顺序，能够按照添加顺序遍历，但并不代表有序（适用于频繁遍历的情况）
5. TreeSet：有序，只能添加同一类型的元素，可以按照添加进集合中的元素的指定属性进行排序，排序是在添加数据时进行的，更改数据不会影响原来的顺序，不要修改数据，否则可能重复，解决办法是将属性修改为final类型，禁止修改。
6. Collections：操作Collection及Map的工具类，大部分为static的方法。使用Collections.addAll(list, T...)要比list.addAll()效率高。
7. HashMap：可以添加null键，null值。HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。
8. LinkedHashMap：原理同LinkedHashSet
9. TreeMap：原理同TreeSet

• Hashtable与HashMap的区别（面试）：

  • 主要：Hashtable是线程安全的，同步，效率相对较低
  • 父类不同：Hashtable 是 Dictionary的子类，HashMap 是 AbstractMap 的子类
  • null：Hashtable键值都不能为null，HashMap键最多一个null， 值可以有多个null

• Properties：Hashtable的子类，（读写资源配置文件，键与值只能为字符串）

  • 配置文件：
    • properties：存储store(), 读取load()
    • xml : 存储storeToXML(), 读取loadFromXML()

  类路径加载资源文件：

// "/"表示bin目录
pro.loadFromXML(类.class.getResourceAsStream("/"));
//  ""代表bin目录
pro.loadFromXML(Thread.currentThread().getContextClassLoader().getResourceAsStream(""));     

容器的两种排序方式

1. 自然排序：
   • 要求添加进TreeSet中的元素所在的类实现Comparable接口
   • 重写compareTo(Object obj)，在此方法内指明按照元素的哪个属性进行排序
   • 向TreeSet中添加元素即可。若不实现此接口，会报运行时异常
   • 内置类:
     • 整数、小数：直接比较基本数据类型的大小 （Integer，Double）
     • 字符：比较 unicode 编码之差
     • 字符串：
       • 如果其中一个字符串 是另外一个字符串的起始子串，返回长度之差
       • 否则返回第一个不相等的 unicode 码之差
     • java.util.Date : 根据日期的 long 形数比较
2. 定制排序：
   1. 创建一个实现Comparator接口的实现类的对象并重写compare(Object o1,Object o2)方法
   2. 在此compare()方法中指明按照元素所在类的哪个属性进行排序
   3. 将此实现Comparator接口的实现类的对象作为形参传递给TreeSet的构造器中
   4. 向TreeSet中添加元素即可。若不实现此接口，会报运行时异常
3. java.util.Arrays，asList() 方法返回的是一个自己的内部类 java.util.Arrays.ArrayList 产生的固定大小的特殊的数组。
4. 排序时属性相同(return 0)对象也就相同了，因要求重写的compareTo()或者compare()方法与equals()和hashCode()方法保持一致。

IO流

多线程与并发

程序、进程与线程

程序：Program，静态概念

进程：Process 动态概念，作为资源分配的单位。

• 正在运行的程序，其实就是一个应用程序运行时的内存分配空间，占用特定的地址空间，每个进程都是独立的，由3部分组成：CPU，DATA，CODE
• 缺点：内存的浪费，CPU的负担

线程：Thread，调度和执行的单位，是进程中一个“单一的连续控制流程”（a single sequential flow of control）的执行路径，又被称为轻量级进程（lightweighht process），负责的是应用程序的执行顺序。

• Threads run at the same time, independently of one another;
• 一个进程可以拥有多个并行的（concurrent）线程（至少一个）；
• 一个进程中的线程共享相同的内存单元/内存地址空间--->可以访问相同的变量和对象，而且他们从同一堆中分配对象--->通信、数据交换、同步操作
• 由于线程间的通信实在同意地址空间上进行的，所以不需要额外的通信机制，这就使得通信更简单而且信息传递的速度也更快。

实现

• 继承 Thread 类：重写run()，直接new当前对象调用start()，无法再继承其他类

• 实现 Runnable 接口：实现run()，使用 new Thread(Runnable obj).start() 可以同时实现继承，方便共享资源

• 静态代理模式
  1. 创建真实角色
  2. 创建代理角色并持有真实角色的引用 + Thread(引用) + 代理角色 .start()
  3. 两个角色实现同一接口

线程状态（声明周期）

• 新生状态
• 就绪状态
• 运行状态
• 阻塞状态
• 死亡状态

线程终止

1. 自然终止：线程体正常执行完毕
2. 外部干涉：
   • 线程类中定义线程体使用的标识
   • 线程体使用该标识
   • 提供对外的方法改变该标识
   • 外部根据条件调用该方法即可

阻塞

• join：合并线程
• yield：暂停自己的线程 static 并不绝对
• sleep
• 优先级：代表概率

同步（并发 ）

多个线程访问同一份资源，确保资源安全，又称线程安全

• 同步块：synchronized(引用类型||this||类.class){}，锁的是对象
• 同步方法：方法声明中加入synchronized

死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁，死锁是我们在使用同步时才可能产生的。

并发常见问题

1. 生产者-消费者模型

2. 信号灯法

3. 读者-作者模型

4. 宴席的哲学家