Java 根底 3

1. 抉择排序

抉择排序（Selection sort）是一种简略直观的排序算法。它的工作原理是 每一次 从待排序的数据元素中 选出最小（或最大）的 一个元素，寄存在 序列的 起始地位 ，而后， 再从残余未排序元素中持续寻找最小（大）元素，而后放到已排序序列的开端 。以此类推，直到全副待排序的数据元素排完。抉择排序是 不稳固 的排序办法。

public class SelectSort {public int[] sort(int arr[]) {
    int temp = 0;
    for (int i = 0; i < arr.length - 1; i++) {
      // 认为目前的数就是最小的, 记录最小数的下标
      int minIndex = i;
      for (int j = i + 1; j < arr.length; j++) {if (arr[minIndex] > arr[j]) {
          // 批改最小值的下标
          minIndex = j;
       }
     }
      // 当退出 for 就找到这次的最小值, 就须要替换地位了
      if (i != minIndex) {
        // 替换以后值和找到的最小值的地位
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
     }
   }
    return arr;
 }
  public static void main(String[] args) {SelectSort selectSort = new SelectSort();
    int[] array = {2,5,1,6,4,9,8,5,3,1,2,0};
    int[] sort = selectSort.sort(array);
    for (int num:sort){System.out.print(num+"\t");
   }
 }
}

2. 插入排序

有一个曾经有序的数据序列，要求在这个曾经排好的数据序列中插入一个数，但要求插入后此数据序列依然有序，这个时候就要用到一种新的排序办法——插入排序法, 插入排序的基本操作就是 将一个数据插入到曾经排好序的有序数据中 ，从而失去一个新的、个数加一的有序数据，算法实用于大量数据的排序，工夫复杂度为 O(n^2)。是 稳固的排序 办法。插入算法把要排序的数组分成两局部：第一局部蕴含了这个数组的所有元素，但将最初一个元素除外（让数组多一个空间才有插入的地位），而第二局部就只蕴含这一个元素（即待插入元素）。在第一局部排序实现后，再将这个最初元素插入到已排好序的第一局部中。
插入排序的根本思维是：每步将一个待排序的记录，按其关键码值的大小插入后面曾经排序的文件中适当地位上，直到全副插入完为止。
包含：间接插入排序 ， 二分插入排序（又称折半插入排序），链表插入排序 ， 希尔排序（又称放大增量排序）。属于 稳固排序的一种（艰深地讲，就是两个相等的数不会替换地位）。
一般来说，插入排序都采纳 in-place 在数组上实现。具体算法形容如下：⒈ 从第一个元素开始，该元素能够认为曾经被排序 ⒉ 取出下一个元素，在曾经排序的元素序列中从后向前扫描 ⒊ 如果该元素（已排序）大于新元素，将该元素移到下一地位 ⒋ 反复步骤 3，直到找到已排序的元素小于或者等于新元素的地位 ⒌ 将新元素插入到次元素前 ⒍反复步骤 2~5
如果比拟操作的代价比替换操作大的话，能够采纳二分查找法来缩小比拟操作的数目。该算法能够认为是插入排序的一个变种，称为二分查找排序。

public class InsertSort {private int[] sort(int[]arr){
    // 如果传入的数组为空或者只有一个值, 就间接返回
    if(arr == null || arr.length < 2){return arr;}
    // 不为空则进循环判断
    // 外层循环管制总数量
    for(int i=1;i<arr.length;i++){
      // 内层循环顺次缩小并提出后果
      for(int j=i;j>0;j--){
        // 如果以后数字小于前一个, 则替换, 否则不变
        if(arr[j]<arr[j-1]){int temp=arr[j];
          arr[j]=arr[j-1];
          arr[j-1]=temp;
       }else{break;}
     }
   }
    return arr;
 }
  public static void main(String[] args) {InsertSort insertSort = new InsertSort();
    int[] array = {2,5,1,6,4,9,8,5,3,1,2,0};
    int[] sort = insertSort.sort(array);
    for (int num:sort){System.out.print(num+"\t");
   }
 }

关键字

4.final 关键字

当用 final 润饰一个类时，表明这个 类不能被继承。也就是说，如果一个类你永远不会让他被继承，就能够用 final 进行润饰。final 类中的成员变量能够依据须要设为 final，然而要留神final 类中的所有成员办法都会被隐式地指定为 final 办法。

“应用 final 办法的起因有两个。第一个起因是把 办法锁定，以防任何继承类批改它的含意；第二个起因是效率。在晚期的 Java 实现版本中，会将 final 办法转为内嵌调用。然而如果办法过于宏大，可能看不到内嵌调用带来的任何性能晋升。在最近的 Java 版本中，不须要应用 final 办法进行这些优化了。“

对于一个 final 变量，如果是 根本数据类型 的变量，则其数值 一旦在初始化之后便不能更改 ；如果是 援用类型 的变量，则在对其 初始化之后便不能再让其指向另一个对象。

5.Synchronized 和 lock

synchronized 是 Java 的关键字，当它用来润饰一个办法或者一个代码块的时候，可能保障在 同一时刻最多只有一个线程执行该段代码。JDK1.5 当前引入了自旋锁、锁粗化、轻量级锁，偏差锁来有优化关键字的性能。

• Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言实现；
• synchronized 在产生异样时，会主动开释线程占有的锁，因而不会导致死锁景象产生；而 Lock 在产生异样时，如果没有被动通过 unLock()去开释锁，则很可能造成死锁景象，因而应用 Lock 时须要在 finally 块中开释锁；
• Lock 能够让期待锁的线程响应中断，而 synchronized 却不行，应用 synchronized 时，期待的线程会始终期待上来，不可能响应中断；
• 通过 Lock 能够晓得有没有胜利获取锁，而 synchronized 却无奈办到。

6.volatile

volatile 关键字是用来保障 有序性和可见性 的。这跟 Java 内存模型无关。比方咱们所写的代码，不肯定是依照咱们本人书写的程序来执行的，编译器会做重排序，CPU 也会做重排序的，这样的重排序是为了缩小流水线的阻塞的，引起流水阻塞，比方数据相关性，进步 CPU 的执行效率。须要有肯定的程序和规定来保障，不然程序员本人写的代码都不晓得对不对了，所以有 happens-before 规定，其中有条就是 volatile 变量规定：对一个变量的写操作后行产生于前面对这个变量的读操作；有序性实现的是通过插入内存屏障来保障的。可见性：首先 Java 内存模型分为，主内存，工作内存。比方线程 A 从主内存把变量从主内存读到了本人的工作内存中，做了加 1 的操作，然而此时没有将 i 的最新值刷新会主内存中，线程 B 此时读到的还是 i 的旧值。加了 volatile 关键字的代码生成的汇编代码发现，会多出一个 lock 前缀指令。Lock 指令对 Intel 平台的 CPU，晚期是锁总线，这样代价太高了，前面提出了缓存一致性协定，MESI，来保障了多核之间数据不一致性问题。

7.Syncronized 锁，如果用这个关键字润饰一个静态方法，锁住了什么？如果润饰成员办法，锁住了什么？

synchronized 润饰 静态方法 以及同步代码块的 synchronized (类.class)用法 锁的是类 ，线程想要执行对应同步代码，须要取得 类锁 。
synchronized 润饰 成员办法 ，线程获取的是以后调用该办法的 对象实例的对象锁。

8. 封装 继承 多态

封装
封装把一个 对象的属性私有化 ，同时 提供一些能够被外界拜访的属性的办法 ，
如果属性不想被外界拜访，咱们大可不必提供办法给外界拜访。然而如果一个
类没有提供给外界拜访的办法，那么这个类也没有什么意义了。

继承
继承是应用已存在的类的定义作为根底建设新类的技术，新类的定义能够减少
新的数据或新的性能，也能够用父类的性能，但不能选择性地继承父类。通过
应用继承咱们可能十分不便地复用以前的代码。
对于继承如下 3 点请记住：

1. 子类领有父类 非 private 的属性和办法。
2. 子类能够领有本人属性和办法，即子类能够对父类进行扩大。
3. 子类能够用本人的形式实现父类的办法。（当前介绍）。

多态
所谓多态就是指程序中定义的援用变量所指向的具体类型和通过该援用变量发
出的办法调用在编程时并不确定，而是在程序运行期间才确定，即 一个援用变量倒底会指向哪个类的实例对象，该援用变量收回的办法调用到底是哪个类中实现的办法，必须在由程序运行期间能力决定 。在 Java 中有两种模式能够实现多态： 继承（多个子类对同一办法的重写）和接口（实现接口并笼罩接口中同一办法）。

9. 空参构造方法作用

Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因而，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法，则编译时将产生谬误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。

10. 接口和抽象类的区别

1. 接口的办法默认是 public，所有 办法在接口中不能有实现 (Java 8 开始接口办法能够有默认实现）， 抽象类能够有非形象的办法
2. 接口中的实例变量默认是 final 类型的，而抽象类中则不肯定
3. 一个类能够实现多个接口，但最多只能实现一个抽象类
4. 一个 类实现接口的话要实现接口的所有办法，而抽象类不肯定
5. 接口不能用 new 实例化，但能够申明，然而必须援用一个实现该接口的对象从设计层面来说，形象是对类的形象，是一种模板设计，接口是行为的形象，是一种行为的标准。

11. 成员变量与局部变量的区别

1. 从语法模式上看 成员变量是属于类的 ，而 局部变量是在办法中定义的变量或是办法的参数 ；成员变量能够被 public,private,static 等修饰符所润饰，而 局部变量不能被访问控制修饰符及 static 所润饰 ；然而，成员变量和局部变量 都能被 final 所润饰；
2. 从变量在内存中的存储形式来看，成员变量是对象的一部分，而对象存在于堆内存 ， 局部变量存在于栈内存
3. 从变量在内存中的生存工夫上看，成员变量是对象的一部分，它随着对象的创立而存在 ，而 局部变量随着办法的调用而主动隐没。
4. 成员变量 如果没有被赋初值，则会主动以类型的 默认值 而赋值（一种状况例外被 final 润饰的成员变量也必须显示地赋值）；而 局部变量则不会主动赋值。

12. 线程，程序、过程的基本概念及关系

过程是程序的一次执行过程，是零碎运行程序的根本单位 ，因而过程是动静的。零碎 运行一个程序即是一个过程从创立，运行到沦亡的过程。简略来说，一个过程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个过程还占有某些系统资源如 CPU 工夫，内存空间，文件，文件，输入输出设施的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。

线程与过程类似，但 线程是一个比过程更小的执行单位 。一个过程在其执行的过程中能够产生多个线程。与过程不同的是 同类的多个线程共享同一块内存空间和一组系统资源，所以零碎在产生一个线程，或是在各个线程之间作切换工作时，累赘要比过程小得多，也正因为如此，线程也被称为轻量级过程。程序是含有指令和数据的文件，被存储在磁盘或其余的数据存储设备中，也就是说程序是动态的代码。

线程是过程划分成的更小的运行单位 。线程和过程最大的不同在于基本上各 过程是独立的，而各线程则不肯定 ，因为同一过程中的线程极有可能会相互影响。从另一角度来说，过程属于操作系统的领域，次要是同一段
工夫内，能够同时执行一个以上的程序，而线程则是在同一程序内简直同时执
行一个以上的程序段。

13. 可变参数的作用和特点

总结 1：可变参数

1. 可变参数的模式 …
2. 可变参数只能是办法的形参
3. 可变参数对应的实参能够 0,1,2…..n 个，也能够是一个数组
4. 在可变参数的办法中，将可变参数当做数组来解决
5. 可变参数最多有一个，只能是最初一个
6. 可变参数益处：不便 简略 缩小重载办法的数量
7. 如果定义了可变参数的办法，不容许同时定义雷同类型数组参数的办法
   总结 2：数组做形参和可变参数做形参分割和区别
   分割：
8. 实参都能够是数组；
9. 办法体中，可变参数实质就是当做数组来解决
   区别：
10. 个数不同 可变参数只能有一个数组参数能够多个
11. 地位不同 可变参数只能是最初一个 数组参数地位任意

12. 实参不同 可变参数实参能够 0,1,2….. 个，也能够是一个数组，数组的实参只能是数组

    private static int sum(int... values) {
      int sum = 0;
      for (int i = 0; i < values.length; i++) {sum += values[i];
     }
      return sum;
    }