一、前言
SPI(Service Provider Interface)是Java提供的一种动态服务发现机制。通过SPI机制，我们可以直接跨模块查找到想要的接口实现类,从而避免不必要的模块间依赖，降低模块之间的耦合性。这对Android组件间通信非常重要的意义。试想一下如果有一个组件能提供这样一种能力,我们的组件通信是否会变得很容易: 通过一个接口，我可以很容易的查找到这个接口在任意模块下的任意一个或多个实现类的对象;而且，可以按你自己想要的方式缓存对象(简单对象、单例、强弱引用、自定义等);接口实现类对象的每个方法执行时都可以被自定义拦截策略和拦截器拦截; 如果这个接口有多个实现类，可以自由选择具体使用哪一个、多个实现类,这个组件就是本文要跟大家介绍的Service Pool for Android。(有点抽象, 往后看)
如此循环到倒数第二个数和最后一个数比较为止。
- 实例：第零次最小的是0，第一次最小是1，第二次最小是2 …
- 用Java实现
public void selectSort() {
int[] a = new int[]{9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
printArray("数 组: ", a);
int position; // 当前位置
for (int i = 0; i < a.length; i++) {
int j = i + 1;
position = i; // position是最小值的索引位置
int temp = a[i]; // temp用来存放最小值的值
// 遍历剩余的数，找出最小值
for (; j < a.length; j++) {
if (a[j] < temp) {
temp = a[j];
position = j;
}
}
// 最小的一个数与第一个位置的数交换
a[position] = a[i];
a[i] = temp;
printArray(“第” + i + “步：”, a);
}
printArray("选择排序结果: ", a);
}
五、堆排序
-
基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。
-
堆的定义：具有n个元素的序列 （h1,h2,…,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1） (i=1,2,…,n/2)时称之为堆。
由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。
堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个 堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。
依此类推，直到只有两个节点的堆，并对 它们作交换，最后得到有n个节点的有序序列。
从算法描述来看，堆排序需要两个过程，
-
一是建立堆
-
二是堆顶与堆的最后一个元素交换位置。
所以堆排序有两个函数组成。
-
是建堆的渗透函数，
-
二是反复调用渗透函数实现排序的函数。
- 介绍
初始序列：46,79,56,38,40,84
建堆：
交换，从堆中踢出最大数：
依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。
- 实例
- 用Java实现
import java.util.Arrays;
public class HeapSort {
public void printArray(String msg, int[] a) {
System.out.print(msg); // 打印提示
// 打印数组
int len = a.length;
for (int i = 0; i < len; i++) {
System.out.print(a[i] + " ");
}
System.out.println(“”); // 换行
}
// 构造函数
public HeapSort () {
int a[] = {46, 79, 56, 38, 40, 84};
printArray(“\n排序前：”, a);
heapSort(a);
printArray(“排序后：”, a);
}
public void heapSort(int[] a) {
int arrayLength = a.length;
//循环建堆
for (int i = 0; i < arrayLength - 1; i++) {
//建堆
buildMaxHeap(a, arrayLength - 1 - i);
//交换堆顶和最后一个元素
swap(a, 0, arrayLength - 1 - i);
printArray(" ",a);
}
}
private void swap(int[] data, int i, int j) {
int tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
//对data数组从0到lastIndex建大顶堆
private void buildMaxHeap(int[] data, int lastIndex) {
//从lastIndex处节点（最后一个节点）的父节点开始
for (int i = (lastIndex - 1) / 2; i >= 0; i–) {
//k保存正在判断的节点
int k = i;
//如果当前k节点的子节点存在
while (k * 2 + 1 <= lastIndex) {
//k节点的左子节点的索引
int biggerIndex = 2 * k + 1;
//如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
if (biggerIndex < lastIndex) {
//若果右子节点的值较大
if (data[biggerIndex] < data[biggerIndex + 1]) {
//biggerIndex总是记录较大子节点的索引
biggerIndex++;
}
}
//如果k节点的值小于其较大的子节点的值
if (data[k] < data[biggerIndex]) {
//交换他们
swap(data, k, biggerIndex);
//将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
k = biggerIndex;
} else {
break;
}
}
}
}
public static void main(String[] args) {
HeapSort hs = new HeapSort ();
}
}
六、冒泡排序
- 基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，
自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。
即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
- 实例：第0次下沉的数是9，第1次下沉的数是8 …
- 用Java实现
public void bubbleSort() {
int[] a = new int[]{9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
printArray("数 组: ", a);
int temp;
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j < a.length - 1 - i; j++) {
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
printArray(“第” + i + “步：”, a);
}
printArray("冒泡排序结果: ", a);
}
七、快速排序
- 基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,
通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,
此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
- 实例
- 用Java实现
public class QuickSort {
public void execute() {
int[] a = {5, 2, 3, 6, 1, 8, 0, 9, 7, 4};
printArray("\n排序前 ", a);
quick(a);
printArray("排序后 ", a);
}
// 分成两断后返回中轴的位置
public int getMiddle(int[] list, int low, int high) {
int tmp = list[low]; //数组的第一个作为中轴
while (low < high) {
while (low < high && list[high] >= tmp) {
high–;
}
list[low] = list[high]; //比中轴小的记录移到低端
while (low < high && list[low] <= tmp) {
low++;
}
list[high] = list[low]; //比中轴大的记录移到高端
}
list[low] = tmp; //中轴记录到尾
printArray(" ",list);
return low; //返回中轴的位置
}
public void _quickSort(int[] b, int low, int high) {
if (low < high) {
int middle = getMiddle(b, low, high); //将list数组进行一分为二
_quickSort(b, low, middle - 1); //对低字表进行递归排序
_quickSort(b, middle + 1, high); //对高字表进行递归排序
}
}
public void quick(int[] a) {
if (a.length > 0) { //查看数组是否为空
_quickSort(a, 0, a.length - 1);
}
}
public static void main(String[] args) {
QuickSort qs = new QuickSort();
qs.execute();
}
}
八、归并排序
- 基本思想：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，
即把待排序序列分为若干个子序列，每个子序列是有序的。
然后再把有序子序列合并为整体有序序列。
- 实例
- 用Java实现
public class MergeSort {
public void execute() {
int a[] = {5, 2, 3, 6, 1, 8, 0, 9, 7, 4};
printArray(“\n排序前：”, a);
sort(a, 0, a.length - 1);
printArray(“排序后：”, a);
}
public void sort(int[] data, int left, int right) {
if (left < right) {
//找出中间索引
int center = (left + right) / 2;
//对左边数组进行递归
sort(data, left, center);
//对右边数组进行递归
sort(data, center + 1, right);
//合并
merge(data, left, center, right);
}
}
public void merge(int[] data, int left, int center, int right) {
int[] tmpArr = new int[data.length];
int mid = center + 1;
//third记录中间数组的索引
int third = left;
int tmp = left;
while (left <= center && mid <= right) {
//从两个数组中取出最小的放入中间数组
if (data[left] <= data[mid]) {
tmpArr[third++] = data[left++];
} else {
tmpArr[third++] = data[mid++];
}
}
//剩余部分依次放入中间数组
while (mid <= right) {
tmpArr[third++] = data[mid++];
}
while (left <= center) {
最后
写到这里也结束了，在文章最后放上一个小小的福利，以下为小编自己在学习过程中整理出的一个学习思路及方向，从事互联网开发，最主要的是要学好技术，而学习技术是一条慢长而艰苦的道路，不能靠一时激情，也不是熬几天几夜就能学好的，必须养成平时努力学习的习惯，更加需要准确的学习方向达到有效的学习效果。
int third = left;
int tmp = left;
while (left <= center && mid <= right) {
//从两个数组中取出最小的放入中间数组
if (data[left] <= data[mid]) {
tmpArr[third++] = data[left++];
} else {
tmpArr[third++] = data[mid++];
}
}
//剩余部分依次放入中间数组
while (mid <= right) {
tmpArr[third++] = data[mid++];
}
while (left <= center) {
最后
写到这里也结束了，在文章最后放上一个小小的福利，以下为小编自己在学习过程中整理出的一个学习思路及方向，从事互联网开发，最主要的是要学好技术，而学习技术是一条慢长而艰苦的道路，不能靠一时激情，也不是熬几天几夜就能学好的，必须养成平时努力学习的习惯，更加需要准确的学习方向达到有效的学习效果。
[外链图片转存中…(img-doKZAs05-1649753948348)]
Android开发不会这些？如何面试拿高薪！
