Java 根底 2

1.Java 的安全性

语言档次的安全性次要体现在：
Java 勾销了弱小但又危险的指针，而代之以援用 。因为指针可进行挪动运算，指针可 轻易指向 一个内存区域，而 不论 这个区域 是否可用 ，这样做是危险的，因为原来这个内存地址可能存储着重要数据或者是其余程序运行所占用的，并且应用指针也 容易数组越界 。
垃圾回收机制：
不须要程序员间接管制内存回收，由垃圾回收器在后盾主动回收不再应用的内存。防止程序遗记及时回收，导致内存泄露。防止程序谬误回收程序外围类库的内存，导致系统解体。
异样解决机制：
Java 异样机制次要依赖于 try、catch、finally、throw、throws 五个关键字。
强制类型转换：

• 只有在满足强制转换规则的状况下能力强转胜利。

• 底层的安全性能够从以下方面来阐明:

  • Java 在字节码的传输过程中应用了 公开密钥加密机制(PKC)。
  • 在运行环境提供了四级安全性保障机制：
    字节码校验器 - 类装载器 - 运行时内存布局 - 文件拜访限度

2.Java 三大版本

Java2 平台包含 标准版（J2SE）、企业版（J2EE）和 微缩版（J2ME）三个版本：
Standard Edition(标准版) J2SE 蕴含那些形成 Java 语言 外围的类 。
比方：数据库连贯、接口定义、输出 / 输入、网络编程
Enterprise Edition(企业版) J2EE 蕴含J2SE 中的类，并且 还蕴含用于开发企业级利用的类 。
比方 servlet、JSP、XML、事务管制
Micro Edition(微缩版) J2ME 蕴含J2SE 中一部分类，用于消费类电子产品的软件开发。
比方：呼机、智能卡、手机、PDA、机顶盒
他们的范畴是：
J2SE 蕴含于 J2EE 中，J2ME 蕴含了 J2SE 的外围类，但新增加了一些专有类利用场合，API 的覆盖范围各不相同。

3. 八种根本数据类型及其字节数

4. 大 O 符号(big-O notation)

大 O 符号形容了当数据结构外面的 元素减少的时候 ，算法的 规模 或者是 性能 在最坏 的场景下 有如许好 。
大 O 符号也可用来形容其余的行为，比方：内存耗费 。因为汇合类实际上是数据结构，咱们个别应用大 O 符号基于 工夫，内存和性能 来抉择最好的实现。大 O 符号能够对大量数据的性能给出一个很好的阐明。

同时，大 O 符号示意一个程序运行时所须要的 渐进工夫复杂度上界。

其函数示意是：

对于函数 f(n),g(n), 如果存在一个 常数 c ，使得f(n)<=c*g(n), 则f(n)=O(g(n));

5. 数组 (Array) 和列表(ArrayList)

Array 和 ArrayList 的不同点：

1. Array能够蕴含 根本类型 和对象类型 ，ArrayList 只能 蕴含 对象类型。
2. Array 大小 是固定 的，ArrayList的大小是 动态变化 的。
3. ArrayList提供了 更多的办法和个性 ，比方：addAll()，removeAll()，iterator() 等等。
4. 对于根本类型数据，汇合应用主动装箱来缩小编码工作量。然而，当解决 固定大小的根本数据类型 的时候，这种形式绝对比较慢。

6. 值传递和援用传递

值传递 是对 基本型变量 而言的, 传递的是该 变量的一个正本 , 扭转正本不影响原变量 .
援用传递 个别是对于 对象型变量 而言的, 传递的是该 对象地址的一个正本 , 并 不是原对象 自身。所以 对援用对象 进行操作会 同时扭转原对象.

个别认为,java 内的传递都是值传递.

7. 根本数据类型的类型转换规定

根本类型转换分为 主动转换 和强制转换 。
主动转换规则：
容量小 的数据类型 能够 主动转换成容量大 的数据类型，也能够说 低级主动向高级 转换。这儿的容量指的 不是字节数 ，而是指 类型表述的范畴 。

红色可能损失精度

强制转换规则：
高级变为低级须要强制转换。
如何转换：
（1）赋值运算符“=”左边的转换，先 主动转换成表达式中级别最高的数据类型 ，再进行运算。
（2）赋值运算符“=”两侧的转换，若 右边级别 > 左边级别，会主动转换 ；若 右边级别 == 左边级别，不必转换 ；若 右边级别 < 左边级别，需强制转换 。
（3）能够将 整型常量间接赋值给 byte, short, char等类型变量，而不须要进行强制类型转换，前提是不超出其表述范畴，否则必须进行强制转换。

8. 最有效率的办法算出 2 乘以 8

应用 位运算 来实现效率最高。位运算符是对操作数以二进制比特位为单位进行操作和运算，操作数和后果都是整型数。
对于位运算符“<<”, 是将一个数 左移 n 位，就相当于乘以了 2 的 n 次方 ，那么，一个数乘以 8 只有将其左移 3 位即可， 位运算 cpu 间接反对的，效率最高。所以，2 乘以 8 等于几的最效率的办法是 2 << 3

9. if 和 switch

相同之处：

都是 分支 语句，多超过一种的状况进行判断解决。

不同之处：

switch 更适宜用于多分支状况 ，就是有很多种状况须要判断解决， 判断条件类型繁多，只有一个入口 ，在分支执行完后（如果没有 break 跳出），不加判断地执行上来; 而if—elseif—else 多分枝次要实用于分支较少的分支构造，判断 类型不是繁多，只有一个分支被执行后，后边的分支不再执行 。
switch 为等值 判断（不容许比方 >= <=），而 if 为等值和区间都能够，if 的应用范畴大。

10. 递归的定义和优缺点

递归算法是一种间接或者间接地调用本身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是非常无效的，它往往使算法的形容简洁而且易于了解。

递归算法解决问题的特点：
(1) 递归就是在过程或函数里调用本身。
(2) 在应用递归策略时，必须有一个明确的递归完结条件，称为递归进口。
(3) 递归算法解题通常显得很简洁，但 运行效率较低 。所以个别不提倡用递归算法设计程序。
(4) 在递归调用的过程当中零碎为 每一层的返回点、部分量等开拓了栈来存储 。递归次数过多容易造成 栈溢出 等。所以个别不提倡用递归算法设计程序。

11. 数组

• 数组是 雷同类型数据 的有序汇合
• 数组会在内存中 开拓一块间断的空间 ， 每个空间 相当于之前的 一个变量，称为数组的元素 element
• 索引从 0 开始，每个数组元素有默认值 double 0.0; boolean false; int 0
• 数组元素有序的，不是大小程序，是索引的程序
• 数组中能够存储根本数据类型，能够存储援用数据类型；然而对于一个数组而言，数组的类型是固定的，只能是一个
• length: 数组的长度数组的长度是固定的，一经定义，不能再发生变化（数组的扩容）

12. 主动拆装箱

主动装箱是 Java 编译器在根本数据类型和对应的对象包装类型之间做的一个转化。比方：把 int 转化成 Integer，double 转化成 Double，等等。反之就是主动拆箱。

13. 为什么会呈现 4.0-3.6=0.40000001

起因简略来说是这样：2 进制的小数无奈准确的表白 10 进制小数，计算机在计算 10 进制小数的过程中要先转换为 2 进制进行计算，这个过程中呈现了误差。

14.Lamda 表达式的优缺点

长处：

1. 简洁。
2. 非常容易并行计算.
3. 可能代表将来的编程趋势。

毛病:

1. 若不必并行计算，很多时候计算速度没有比传统的 for 循环快。（并行计算有时须要预热才显示出效率劣势）
2. 不容易调试。
3. 若其余程序员没有学过 lambda 表达式，代码不容易让其余语言的程序员看懂。

15.java8 的新个性

• Lambda 表达式 − Lambda 容许把函数作为一个办法的参数（函数作为参数传递进办法中。
• 办法援用− 办法援用提供了十分有用的语法，能够间接援用已有 Java 类或对象（实例）的办法或结构器。与 lambda 联结应用，办法援用能够使语言的结构更紧凑简洁，缩小冗余代码。
• 默认办法− 默认办法就是一个在接口外面有了一个实现的办法。
• 新工具− 新的编译工具，如：Nashorn 引擎 jjs、类依赖分析器 jdeps。
• Stream API −新增加的 Stream API（java.util.stream）把真正的函数式编程格调引入到 Java 中。
• Date Time API − 增强对日期与工夫的解决。
• Optional 类 − Optional 类曾经成为 Java 8 类库的一部分，用来解决空指针异样。
• Nashorn, JavaScript 引擎 − Java 8 提供了一个新的 Nashorn javascript 引擎，它容许咱们在 JVM 上运行特定的 javascript 利用.

16. 符号“==”比拟

“==”比照 两个对象基于内存援用 ，如果两个对象的 援用完全相同（指向同一个对象）时 ，“==”操作将返回 true，否则返回 false。“==”如果两边是 根本类型，就是比拟数值 是否相等。

17.Object 若不重写 hashCode()的话，hashCode()如何计算

Object 的 hashcode 办法是 本地办法 ，也就是用 c 语言或 c++ 实现的，该办法间接 返回对象的内存地址。

18. 为什么重写 equals 还要重写 hashcode

HashMap 中 ，如果要 比拟 key 是否相等 ，要 同时应用这两个函数 ！因为自定义的类的hashcode() 办法继承于 Object 类 ，其hashcode 码为默认的内存地址，这样即使有 雷同含意的两个对象，比拟也是不相等的。

HashMap 中的比拟 key 是这样的，先求出 key 的 hashcode(), 比拟其值是否相等，若相等再比拟 equals(), 若相等则认为他们是相等的。若 equals()不相等则认为他们不相等。如果只重写 hashcode()不重写 equals()办法，当比拟 equals()时只是看他们是否为同一对象（即进行内存地址的比拟）, 所以必然要两个办法一起重写。HashMap 用来判断 key 是否相等的办法，其实是调用了 HashSet 判断退出元素是否相等。重载 hashCode()是为了对 同一个 key，能失去 雷同的 HashCode，这样 HashMap 就能够定位到咱们指定的 key 上。重载 equals()是为了 向 HashMap 表明以后对象和 key 上所保留的对象是相等的，这样咱们才真正地取得了这个 key 所对应的这个键值对。

19.map 的分类和常见的状况

java 为数据结构中的映射定义了一个接口 java.util.Map; 它有四个实现类, 别离是HashMap Hashtable LinkedHashMap 和 TreeMap.

Map 次要用于存储健值对，依据键失去值，因而 不容许键反复 (反复了笼罩了), 但 允许值反复。

Hashmap 是一个最罕用的 Map, 它 依据键的 HashCode 值存储数据 , 依据键能够间接获取它的值，具备很快的访问速度，遍历时，获得数据的 程序是齐全随机的。

• HashMap 最多只 容许一条记录的键 为Null;
• 容许 多条记录的值为 Null;
• HashMap不反对线程的同步，即任一时刻能够有多个线程同时写 HashMap; 可能会导致数据的不统一。如果须要同步，能够用 Collections 的 synchronizedMap 办法使 HashMap 具备同步的能力，或者应用 ConcurrentHashMap。

Hashtable 与 HashMap 相似, 它继承自 Dictionary 类，不同的是: 它不容许记录的键或者值为空; 它反对线程的同步，即任一时刻只有一个线程能写 Hashtable, 因而也导致了 Hashtable 在写入时会比较慢。

LinkedHashMap 是 HashMap 的一个子类 ，保留了记录的插入程序，在用 Iterator 遍历 LinkedHashMap 时， 先失去的记录必定是先插入的 . 也能够在结构时用带参数，依照利用次数排序。在遍历的时候会比 HashMap 慢，不过有种状况例外，当 HashMap 容量很大，理论数据较少时，遍历起来可能会比 LinkedHashMap 慢，因为 LinkedHashMap 的 遍历速度只和理论数据无关 ， 和容量无关，而 HashMap 的遍历速度和他的容量无关。

reeMap 实现 SortMap 接口 ，可能把它保留的记录依据键排序, 默认是按 键值的升序 排序，也能够指定排序的比拟器，当用 Iterator 遍历 TreeMap 时，失去的记录是排过序的。

个别状况下，咱们用的最多的是 HashMap, 在 Map 中插入、删除和定位元素，HashMap 是最好的抉择。但如果您要按 天然程序或自定义程序遍历键 ，那么TreeMap 会更好。如果须要 输入的程序和输出的雷同, 那么用 LinkedHashMap 能够实现, 它还能够按读取程序来排列.

20. 冒泡排序

冒泡排序算法的原理如下：

1. 比拟相邻的元素。如果第一个比第二个大，就替换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最初一对。在这一点，最初的元素应该会是最大的数。
3. 针对所有的元素反复以上的步骤，除了最初一个。
4. 继续每次对越来越少的元素反复下面的步骤，直到没有任何一对数字须要比拟。

public class Bubble {public int[] sort(int[] array) { 
        int temp = 0; 
        // 外层循环，它决定一共走几趟 //- 1 为了避免溢出 
        for (int i = 0; i < array.length - 1; i++) { 
            int flag = 0; 
        // 通过符号位能够缩小无谓的比拟，如果曾经有序了，就退出循环             
        // 内层循环，它决定每趟走一次 
            for (int j = 0; j < array.length - i - 1; j++) {              // 如果后一个大于前一个, 则换位 
                if (array[j + 1] > array[j]) {temp = array[j];
                 array[j] = array[j + 1];
                 array[j + 1] = temp; flag = 1; 
                }
             }
        if(flag == 0){break;} 
        }
        return array; 
    }

    public static void main(String[] args) {Bubble bubble = new Bubble();
        int[] array = {2,5,1,6,4,9,8,5,3,1,2,0}; 
        int[] sort = bubble.sort(array); 
        for (int num:sort){System.out.print(num+"\t");     
        } 
    } 
}