Android中的算法

算法是思想的体现形式,常见的算法做一些总结

算法简介

算法—Algorithm

解题方案的准确而完整的描述,是一系列解决问题的清晰指令

特征

有穷性,确切性,输入项,输出项,可行性

算法运算要素

算术运算:加减乘除等运算

逻辑运算:或、且、非等运算

关系运算:大于、小于、等于、不等于等运算

数据传输:输入、输出、赋值等运算

算法优劣评定

时间复杂度,空间复杂度,正确性,可读性,健壮性

LogN

二分法查找最坏的情况:对于N个元素的数组,第一次查找未找到则舍弃 N/2 个元素,剩下 N/2,同理第二次剩 N/4 ···,一直到最后剩 N/2^k >= 1,所以二分法查找的次数 k 满足 N/2^k = 1,于是

2 ^ k = N

k = log2N

所以二分法查找的最坏时间复杂度是O(logN)

NLogN

首先决策树是一颗二叉树,每个节点表示元素之间一组可能的排序

先来说明一些二叉树的性质,令T是深度为d的二叉树,则T最多有2^片树叶

具有L片树叶的二叉树的深度至少是logL

所以,对n个元素排序的决策树必然有n!片树叶(因为n个数有n!种不同的大小关系),所以决策树的深度至少是log(n!),即至少需要log(n!)次比较,而

log(n!) = logn + log(n-1) + log(n-2) +...+ log2 + log1
>= logn + log(n-1) + log(n-2) +...+ log(n/2)
>= (n/2)log(n/2)
>= (n/2)logn - n/2
= O(nlogn)

算法分析方法

递归法:汉诺塔

穷举法:暴力密码破解法

贪心算法:加勒比海盗偷宝藏

分治法:乐毅连下齐72城 二分搜索

动态规划法:导弹拦截

迭代法:超能生的兔子

回溯法:八皇后

排序

由于前面已经对排序进行过总结了,这里不再赘述其思想,直接贴出示例代码

前面使用的是C语言,这里使用Java,原理在前面已经说明,推荐看前面的,包括代码

由于下面的排序涉及到交换的比较多,这里直接先定义一个交换的方法

private void swap(int[] array, int i, int j) {
    int temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

交换排序

冒泡排序

public void bubbleSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array.length - 1 - i; j++) {
            if(array[j] > array[j + 1]) {
                swap(array, j, j + 1);
            }
        }
    }
}

快速排序

private void quickSort(int[] array, int left, int right) {
    if(left < right) {
        int mid = getMid(array, left, right);
        quickSort(array, 0, mid -1);
        quickSort(array, mid + 1, right);
    }
}

private int getMid(int[] array, int left, int right) {
    int temp = array[left];
    while(left < right) {
        while(left < right && array[right] >= temp) {
            right--;
        }
        array[left] = array[right];
        while(left < right && array[left] <= temp) {
            left++;
        }
        array[right] = array[left];
    }
    array[left] = temp;
    return left;
}

选择排序

简单选择排序

public void selectSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        int key = i;
        for (int j = i; j < array.length; j++) {
            if(array[key] > array[j]) {
                key = j;
            }
        }
        if(key != i) {
            swap(array, key, i);
        }
    }
}

堆排序

public void heapSort(int[] array) {
    if(array == null || array.length <= 1) {
        return;
    }
    //构建大堆
    buildMaxHeap(array);
    for (int i = array.length - 1; i > 0; i--) {
        swap(array, 0, i);
        adjustHeap(array, i, 0);
    }
}

private void buildMaxHeap(int[] array) {
    int half = (array.length - 1) / 2;
    for (int i = half; i >= 0 ; i--) {
        adjustHeap(array,array.length,i);
    }
}

private void adjustHeap(int[] array, int length, int i) {
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    int largest = i;
    if(left < length && array[left] > array[largest]) {
        largest = left;
    }
    if(right < length && array[right] > array[largest]) {
        largest = right;
    }
    if(i != largest) {
        swap(array,i,largest);
        adjustHeap(array, length, largest);
    }
}

插入排序

直接插入排序

public void insertSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        int temp = array[i];
        int j;
        for (j = i - 1; j >= 0; j--) {
            if(array[j] > temp) {
                array[j + 1] = array[j];
            }else {
                break;
            }
        }
        array[j + 1] = temp;
    }
}

二分插入排序

public void binaryInsertSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        int temp = array[i];
        int left = 0;
        int right = i - 1;
        int mid = 0;
        while(left <= right) {
            mid = (left + right) / 2;
            if(temp < array[mid]) {
                right = mid - 1;
            }else {
                left = mid + 1;
            }
        }
        for (int j = i - 1; j >= left; j--) {
            array[j + 1] = array[j];
        }
        if(left != i) {
            array[left] = temp;
        }
    }
}

希尔排序

public void heerSort(int[] array) {
    int k = -1;
    int temp = -1;
    int gap = array.length;
    while(gap > 1) {
        gap = gap / 3 + 1; //通常取3 O(n 1.3)
        for (int i = gap; i < array.length; i += gap)
        {
            k = i;
            temp = array[k];
            for (int j = i - gap; (j >= 0) && (array[j] > temp); j -= gap)
            {
                array[j + gap] = array[j];
                k = j;
            }
            array[k] = temp;
        }
    }
}

归并排序

public void mergeSort(int[] array) {
    mergeSort(array,0,array.length - 1);
}

private void mergeSort(int[] array, int left, int right) {
    if(left < right) {
        int mid = (left + right) / 2;
        mergeSort(array, left, mid);
        mergeSort(array, mid + 1, right);
        mergeSort(array, left, mid, right);
    }
}

private void mergeSort(int[] array, int left, int mid, int right) {
    int[] temp = new int[array.length];
    int rightStart = mid + 1;
    int leftStart = left;
    int tempIndex = left;
    while(leftStart <= mid && rightStart <= right) {
        if(array[leftStart] <= array[rightStart]) {
            temp[tempIndex++] = array[leftStart++];
        }else {
            temp[tempIndex++] = array[rightStart++];
        }
    }
    while(leftStart <= mid) {
        temp[tempIndex++] = array[leftStart++];
    }
    while(rightStart <= right) {
        temp[tempIndex++] = array[rightStart++];
    }
    tempIndex = left;
    while(tempIndex <= right) {
        array[tempIndex] = temp[tempIndex];
        tempIndex++;
    }
}

基数排序

基数排序原理:由于数字都是由0~9组成,所以在排序的时候可以按照0~9排序

这里只考虑了正数,这是体现其思想实现,负数的话处理一下就可以了

public void basicSort(int[] array) {
    int maxNum = 0; //记录最大值
    int count = 0; //记录最大值位数
    for (int i = 0; i < array.length; i++) {
        if(maxNum < array[i]) {
            maxNum = array[i];
        }
    }
    while(maxNum > 0) {
        maxNum /= 10;
        count++;
    }
    List<ArrayList> list = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        ArrayList arrayList = new ArrayList<>();
        list.add(arrayList);
    }
    for (int i = 0; i < count; i++) {
        for (int j = 0; j < array.length; j++) {
            int x = array[j] % (int)Math.pow(10, i + 1) / (int)Math.pow(10, i);
            ArrayList aList = list.get(x);
            aList.add(array[j]);
            list.set(x, aList);
        }
        int index = 0;
        for (int j = 0; j < 10; j++) {
            while(list.get(j).size() > 0) {
                ArrayList<Integer> aList = list.get(j);
                array[index] = aList.get(0);
                aList.remove(0);
                index++;
            }
        }
    }
}

排序的java源代码:链接:https://pan.baidu.com/s/1mmiJV6k4vIAS53u2eNf63g 密码:q6rq

递归

递归在程序中很常见,那么接下来就用一些经典的递归来探索递归的运用吧

二分法查找

public int binarySearch(int[] array, int elem, int low, int high) {
    if(low > high) {
        return -1;
    }
    int mid = (low + high) / 2;
    if(array[mid] == elem) {
        return mid;
    }
    if(array[mid] < elem) {
        return binarySearch(array, elem, mid + 1, high);
    }
    if(array[mid] > elem) {
        return binarySearch(array, elem, low, mid - 1);
    }
    return -1;
}

汉诺塔

有三根柱子,在一根柱子上从下往上按照大小顺序摞着圆盘,把圆盘按大小顺序重新摆放在另一根柱子上,并且规定,在小圆盘上不能放大圆盘,在三根柱子之间一次只能移动一个圆盘

实现思路:

  1. 将1针上n-1个盘借助3针移动到2针上
  2. 将1针上剩下的一个盘移动到3针上
  3. 将n-1个盘从2针借助1针移动到3针上

    那么这里用C语言来描述应该是这个样子

void hanoi(int n, int one, int two, int three)
{
    if (n == 1)
        printf("%d->%d\n", one, three);
    else
    {
        hanoi(n - 1, one, three, two);
        printf("%d->%d\n", one, three);
        hanoi(n - 1, two, one, three);
    }
}

用Java也是一样

public void hanoi(int n, int one, int two, int three) {
    if (n == 1) {
        System.out.println(one + "->" + three);
    } else {
        hanoi(n - 1, one, three, two);
        System.out.println(one + "->" + three);
        hanoi(n - 1, two, one, three);
    }
}

这里可以得出一个结论,n个盘子需要移动zn-1次

欧几里得扩展算法

定理:两个整数的最大公约数等于其中较小的那个数和两数相除余数的最大公约数。最大公约数(Greatest Common Divisor)缩写为GCD。

gcd(a,b) = gcd(b,a mod b)(不妨设a>b 且r=a mod b ,r不为0)

证明:

第一步:令c = gcd(a,b),则设a = mc,b = nc

第二步:可知r = a - kb = mc - knc = (m - kn)c

第三步:根据第二步结果可知c也是r的因数

第四步:可以断定m - knn互素【否则,可设m - kn = xd, n = yd, (d > 1),则m = kn + xd = kyd + xd = (ky + x)d,则a = mc = (ky + x)dcb = nc = ycd,故a与b最大公约数≥cd,而非c,与前面结论矛盾】

从而可知gcd(b,r) = c,继而gcd(a,b) = gcd(b,r),得证

下面来实现

public int gcd(int m, int n) {
    if(n == 0) {
        return m;
    }else {
        return gcd(n, m % n);
    }
}

阶乘求解算法

public int factorial(int num) {
    if(num == 1) {
        return 1;
    }else {
        return num * factorial(num - 1);
    }
}

穷举

泊松分酒

在多个不同容积的杯子里,通过反复倒酒,得到规定的酒量

例如:

有3个容器,容量分别为12升,8升,5升。其中12升中装满,另外两个空着。要求你只用3个容器操作,最后使得某个容器中正好有6升

这里制定一个规则,倒酒顺序:12 -> 8 -> 5 -> 12,防止错乱

private int b1 = 12;
private int b2 = 8;
private int b3 = 5;
private int target = 6;

public void backBottle(int cup1, int cup2, int cup3) {
    System.out.println("cup1:" + cup1 + ",cup2:" + cup2 + ",cup3:" + cup3);
    if(cup1 == target || cup2 == target || cup3 == target) {
        System.out.println("success");
        return;
    }
    if(cup2 != 0 && cup3 != b3) {
        if(cup2 + cup3 <= b3) {
            backBottle(cup1, 0, cup2 + cup3);
        }else {
            backBottle(cup1, cup2 - (b3 - cup3), b3);
        }
    }else if(cup3 == b3){
        if(cup1 + cup3 <= b1) {
            backBottle(cup1 + cup3, cup2, 0);
        }else {
            backBottle(b1, cup2, cup3 - (b1 - cup1));
        }
    }else if(cup2 == 0){
        if(cup1 >= b2) {
            backBottle(cup1 - b2, b2, cup3);
        }else {
            backBottle(0, cup1, cup3);
        }
    }
}

贪心

背包算法

public void packageGreedy(int capacity,int weights[],int[] values){
    int num = weights.length;
    double[] priceRatio = new double[num];
    int[] index = new int[num];
    for(int i = 0;i < num; i++){
        priceRatio[i] = (double)values[i] / weights[i];
        index[i] = i;
    }

    double temp = 0;//对性价比进行排序
    for(int i = 0; i < num - 1; i++){
        for(int j = i + 1; j < num; j++){
            if(priceRatio[i] < priceRatio[j]){
                temp = priceRatio[i];
                priceRatio[i] = priceRatio[j];
                priceRatio[j] = temp;
                int x = index[i];
                index[i] = index[j];
                index[j] = x;
            }
        }
    }
    //排序好的重量和价值分别存到数组
    int[] w1 = new int[num];
    int[] v1 = new int[num];
    for(int i = 0;i < num; i++){
        w1[i] = weights[index[i]];
        v1[i] = values[index[i]];
    }
    int[] x = new int[num];
    int maxValue = 0;
    for(int i = 0;i<num;i++){
        if(w1[i] < capacity){
            //还可以装得下
            x[i] = 1;//表示该物品被装了
            maxValue += v1[i];
            System.out.println("装入物品:" + w1[i]);
            capacity = capacity - w1[i];
        }
    }
    System.out.println("放下物品数量:" + Arrays.toString(x));
    System.out.println("最大价值:" + maxValue);
}

测试

public static void main(String[] args) {
    int maxWeight = 150;
    int[] weights = {10, 20, 30, 40, 50};
    int[] values = {30, 50, 60, 60, 60};
    GreedyBackPack backPack = new GreedyBackPack();
    backPack.packageGreedy(maxWeight, weights, values);
}

分治

分治法的设计思想是:

  1. 分–将问题分解为规模更小的子问题
  2. 治–将这些规模更小的子问题逐个击破
  3. 合–将已解决的子问题合并,最终得出问题的解

循环赛日程表

n个队伍,n-1天完成比赛

一个先自顶向下,再自底向上的过程

public void scheduleTable(int[][] table, int n) {
    if(n == 1) {
        table[0][0] = 1;
    }else {
        //填充左上区域矩阵
        int m = n / 2;
        scheduleTable(table, m);
        //填充左下区域矩阵
        for (int i = 0; i < m; i++) {
            for (int j = m; j < n; j++) {
                table[i][j] = table[i][j - m] + m;
            }
        }
        //填充右上区域矩阵
        for (int i = m; i < n; i++) {
            for (int j = 0; j < m; j++) {
                table[i][j] = table[i - m][j] + m;
            }
        }
        //填充右下区域矩阵
        for (int i = m; i < n; i++) {
            for (int j = m; j < n; j++) {
                table[i][j] = table[i - m][j - m];
            }
        }
    }
}

输出

[1, 2, 3, 4, 5, 6, 7, 8]
[2, 1, 4, 3, 6, 5, 8, 7]
[3, 4, 1, 2, 7, 8, 5, 6]
[4, 3, 2, 1, 8, 7, 6, 5]
[5, 6, 7, 8, 1, 2, 3, 4]
[6, 5, 8, 7, 2, 1, 4, 3]
[7, 8, 5, 6, 3, 4, 1, 2]
[8, 7, 6, 5, 4, 3, 2, 1]

棋盘问题

在一个2^k×2^k(k≥0)个方格组成的棋盘中,恰有一个方格与其他方格不同,称该方格为特殊方格

private int[][] board; // 棋盘
private int sRow; // 特殊点的行下标
private int sCol; // 特殊点的列下标
private int size;
private int type = 0;

public ChessBoard(int[][] borad, int sRow, int sCol) {
    this.board = borad;
    this.sRow = sRow;
    this.sCol = sCol;
    size = borad.length;
    System.out.println(size);
}

public void chessBoard() {
    chessBoard(sRow, sCol, 0, 0, size);
}

private void chessBoard(int sRow, int sCol, int leftRow, int leftCol, int size) {
    if (size == 1) {
        return;
    }
    int subSize = size / 2;
    type = type % 4 + 1;
    int n = type;
    // 特殊点在左上角
    if (sRow < leftRow + subSize && sCol < leftCol + subSize) {
        chessBoard(sRow, sCol, leftRow, leftCol, subSize);
    } else {
        board[leftRow + subSize - 1][leftCol + subSize - 1] = n;
        chessBoard(leftRow + subSize - 1, leftCol + subSize - 1, leftRow, leftCol, subSize);
    }
    // 特殊点在右上角
    if (sRow < leftRow + subSize && sCol >= leftCol + subSize) {
        chessBoard(sRow, sCol, leftRow, leftCol + subSize, subSize);
    } else {
        board[leftRow + subSize - 1][leftCol + subSize] = n;
        chessBoard(leftRow + subSize - 1, leftCol + subSize, leftRow, leftCol + subSize, subSize);
    }
    // 特殊点在左下角
    if (sRow >= leftRow + subSize && sCol < leftCol + subSize) {
        chessBoard(sRow, sCol, leftRow + subSize, leftCol, subSize);
    } else {
        board[leftRow + subSize][leftCol + subSize - 1] = n;
        chessBoard(leftRow + subSize, leftCol + subSize - 1, leftRow + subSize, leftCol, subSize);
    }
    // 特殊点在右下角
    if (sRow >= leftRow + subSize && sCol >= leftCol + subSize) {
        chessBoard(sRow, sCol, leftRow + subSize, leftCol + subSize, subSize);
    } else {
        board[leftRow + subSize][leftCol + subSize] = n;
        chessBoard(leftRow + subSize, leftCol + subSize, leftRow + subSize, leftCol + subSize, subSize);
    }
}

动态规划

最长公共子序列

public int findLCS(String A, String B) {
    int n = A.length();
    int m = B.length();
    char[] a = A.toCharArray();
    char[] b = B.toCharArray();
    int[][] dp = new int[n][m];
    //第一列判断
    for (int i = 0; i < n; i++) {
        if(a[i] == b[0]) {
            dp[i][0] = 1;
            for (int j = i + 1; j < n; j++) {
                dp[j][0] = 1;
            }
            break;
        }
    }
    //第一行判断
    for (int i = 0; i < m; i++) {
        if(a[0] == b[i]) {
            dp[0][i] = 1;
            for (int j = i + 1; j < m; j++) {
                dp[0][j] = 1;
            }
            break;
        }
    }
    //遍历内部
    for (int i = 1; i < n; i++) {
        for (int j = 1; j < m; j++) {
            if(a[i] == b[j]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            }else {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
    return dp[n -1][m - 1];
}

回溯

八皇后问题

public class Queen {
    public static int num = 0; // 累计方案
    public static final int MAX_QUEEN = 8;
    public static int[] cols = new int[MAX_QUEEN]; // 表示8列棋子摆放的位置

    public void getCount(int n) {
        boolean[] rows = new boolean[MAX_QUEEN]; // 记录列方格是否可以放
        for (int m = 0; m < n; m++) {
            rows[cols[m]] = true;
            int d = n - m;
            if (cols[m] - d >= 0) {
                rows[cols[m] - d] = true;
            }
            if (cols[m] + d <= MAX_QUEEN - 1) {
                rows[cols[m] + d] = true;
            }
        }

        for (int i = 0; i < MAX_QUEEN; i++) {
            if (rows[i]) {
                continue;
            }
            cols[n] = i;
            if (n < MAX_QUEEN - 1) {
                getCount(n + 1);
            } else {
                num++;
                printQueen();
            }
        }
    }

    private void printQueen() {
        System.out.println("第" + num + "种方案");
        for (int i = 0; i < MAX_QUEEN; i++) {
            for (int j = 0; j < MAX_QUEEN; j++) {
                if (i == cols[j]) {
                    System.out.print("0 ");
                } else {
                    System.out.print("+ ");
                }
            }
            System.out.println();
        }
    }
}

约瑟夫问题

public class Joseph {
    private static int COUNT = 20;
    private static int NUM = 5;

    public void killNode() {
        Node header = new Node(1);
        Node xNode = header;
        for (int i = 2; i <= COUNT; i++) {
            xNode = (xNode.next = new Node(i));
        }
        xNode.next = header;
        while(xNode != xNode.next) {
            for (int i = 1; i < NUM; i++) {
                xNode = xNode.next;
            }
            System.out.println("剔除节点:" + xNode.next.val);
            xNode.next = xNode.next.next;
        }
        System.out.println("剩下的节点为:" + xNode.val);
    }

    class Node{
        int val;
        Node next;
        public Node(int val) {
            this.val = val;
        }
    }
}

原文地址:https://www.cnblogs.com/cj5785/p/9893181.html

时间: 2024-10-09 17:35:32

Android中的算法的相关文章

Android中锁屏密码算法解析以及破解方案

一.前言 最近玩王者荣耀,下载了一个辅助样本,结果被锁机了,当然破解它很简单,这个后面会详细分析这个样本,但是因为这个样本引发出的欲望就是解析Android中锁屏密码算法,然后用一种高效的方式制作锁机恶意样本.现在的锁机样本原理强制性太过于复杂,没意义.所以本文就先来介绍一下android中的锁屏密码算法原理. 二.锁屏密码方式 我们知道Android中现结单支持的锁屏密码主要有两种: 一种是手势密码,也就是我们常见的九宫格密码图 一种是输入密码,这个也分为PIN密码和复杂字符密码,而PIN密码

(转)Android中实现区域平均算法在图片缩放里的应用(缩放图片抗锯齿)

摘要:Android图片缩放效果较差,尤其是将大尺寸的图片缩放成小尺寸的图片时,即便是加了抗锯齿,锯齿现象也比较严重:而java sdk里的区域平均算法缩放图片,效果就比较完美了,因为jdk不能直接用于安卓项目中(类冲突),也没找到可以使用的替代的library,最终只好自己写,在此分享! 正文: 目前我知道的Android API中的传统的图片抗锯齿优化处理无非就是以下相关的设置: //缩放抗锯齿Bitmap.createScaledBitmap(bitmap, width, height,

Android中微信抢红包插件原理解析和开发实现

一.前言 自从去年中微信添加抢红包的功能,微信的电商之旅算是正式开始正式火爆起来.但是作为Android开发者来说,我们在抢红包的同时意识到了很多问题,就是手动去抢红包的速度慢了,当然这些有很多原因导致了.或许是网络的原因,而且这个也是最大的原因.但是其他的不可忽略的因素也是要考虑到进去的,比如在手机充电锁屏的时候,我们并不知道有人已经开始发红包了,那么这时候也是让我们丧失了一大批红包的原因.那么关于网络的问题,我们开发者可能用相关技术无法解决(当然在Google和Facebook看来的话,他们

Android基础入门教程——8.1.1 Android中的13种Drawable小结 Part 1

Android基础入门教程--8.1.1 Android中的13种Drawable小结 Part 1 标签(空格分隔): Android基础入门教程 本节引言: 从本节开始我们来学习Android中绘图与动画中的一些基础知识,为我们进阶部分的自定义 打下基础!而第一节我们来扣下Android中的Drawable!Android中给我们提供了多达13种的 Drawable,本节我们就来一个个撸一遍! Drawable资源使用注意事项 Drawable分为两种: 一种是我们普通的图片资源,在Andr

关于Android中SparseArray比HashMap性能好的深入研究

由于网上有朋友对于这个问题已经有了很详细的研究,所以我就不班门弄斧了: 转载于:http://android-performance.com/android/2014/02/10/android-sparsearray-vs-hashmap.html http://liuzhichao.com/p/832.html SparseArray是Android框架独有的类,在标准的JDK中不存在这个类.它要比 HashMap 节省内存,某些情况下比HashMap性能更好,按照官方问答的解释,主要是因为

android中使用jni对字符串加解密实现分析

android中使用jni对字符串加解密实现分析 最近项目有个需求,就是要对用户的敏感信息进行加密处理,比如用户的账户密码,手机号等私密信息.在java中,就对字符串的加解密我们可以使用AES算法加密字符串,使用它的好处就不必多说了,但我们又知道android的源代码是可以被反编译的,所以使用纯Java方式的AES加密是不安全的,所以想到了使用android中的jni来对字符串加解密处理,它会产生一个.so文件,更重要的是它通过C/C++代码实现,所以安全行比较高,它可以被反编译成机器码,但几乎

[Android]GOF23种设计模式 &amp; Android中的设计模式

GOF23种设计模式 设计原则: 1. 单一职责原则(SRP):就一个类而言,应该仅有一个引起它变化的原因 2. 开放-封闭原则(OCP):软件实体(类.模块.函数等)应该可以扩展,但是不可修改.即对于扩展是开放的, 对于修改是封闭的. 3. 依赖倒转原则: A. 高层模块不应该依赖低层模块,两个都应该依赖抽象.B.抽象不应该依赖细节,细节应该依赖抽象.说白了,就是要针对接口编程,不要对实现编程. 4. 迪米特法则(LoD):如果两个类不必彼此直接通信,那么这两个类就不应该发生直接的相互作用.如

框架模式 MVC 在Android中的使用

算来学习Android开发已有2年的历史了,在这2年的学习当中,基本掌握了Android的基础知识.越到后面的学习越感觉困难,一来是自认为android没啥可学的了(自认为的,其实还有很多知识科学),二来网络上的很多框架已经帮我们做了太多的事情了,我们只需要画画UI就可以了,感觉Android开发没有太多的技术含金量.最近闲来无事,开始总结之前学过的知识点,想着是否应该学点其他的东西呢?总不能局限于Android基础知识吧.慢慢的探索发现在大的项目工程中,一个好的框架,好的设计模式,能减少很大的

那些Android中的性能优化

性能优化是一个大的范畴,如果有人问你在Android中如何做性能优化的,也许都不知道从哪开始说起. 首先要明白的是,为什么我们的App需要优化,最显而易见的时刻:用户say,什么狗屎,刷这么久都没反应,取关卸载算了. 这跟什么有关,我们先苍白的反驳下,尼玛用户设备老旧网又烂,关我屁事,根本不用优化.可是,老板拍板了,施压给CTO,然后CTO又来找你:Y的今天必须给我想办法优化了,不然不准回家. 好吧,为什么从UI的表象上看,App又卡又慢而且还错乱.我们试着来剖析下吧. 题外话:把minSDK改