发表于

第一步 创建新工程

选择默认配置即可

第二步 加载源码文件

这里有三个Add选项

  • Add : 添加指定文件
  • Add All: 将选中目录的所有文件加入到工程中
  • Add Tree: 递归加入所有文件，它采用了部分打开文件的方式，没有用到的文件不会打开，所以，加入数千个文件也不用担心加入的文件超出程序的所能容忍的最大值 推荐使用这种

源码加载完成后关闭该窗口

第三步 熟悉主界面和源码搜索

第四步 更改字体大小

面板字体设置

代码显示窗口字体设置

常用快捷键介绍

各工具栏命令如下：

img对应的文件菜单的功能

New（快捷键ctrl+N） 新建一个文件

Open（快捷键ctrl+O） 打开一个文件

Save（快捷键ctrl+S） 保存当前打开的文件

Save As（快捷键ctrl+shift+S） 将当前打开的文件保存为其它名子的文件

Save All（快捷键ctrl+A） 保存所有打开的和修改过的文件

Print 打印当前打开的文件

img对应的编辑菜单功能

Cut（快捷键ctrl+X）

Copy（快捷键ctrl+C）

Paste(快捷键ctrl+V)

Undo(快捷键ctrl+Z)

Redo(快捷键ctrl+Y)

img对应查找菜单功能

Search（快捷键ctrl+F） 在当前打开的文件中查找

Search Backward(快捷键F3) 在当前光标位置进行向后查找

Search Forward(快捷键F4) 在当前光标位置进行向前查找

Search Files(快捷键ctrl+shift+F) 在多文件（Source Insight工程中）中查找

Replace(快捷键ctrl+H) 在当前文件中进行查找和替代

img

对应于窗口功能，与普通的多文档编辑器相同，用来设置打开多个文件时窗口显示方式和规则。

img

用来设置Project窗口、Context窗口、Relation窗口和Clip窗口的显示或关闭。当快捷键点亮时，所对应的窗口显示。

img

Jump To Definition(快捷键ctrl+=) 跳转到当前光标所在位置的函数或变量的定义处（并打开文件）

Symbol Info 弹出一个窗口来显示当前光标位置的函数或变量的定义原型

Browse Project Symbols(快捷键F7) 在整个工程中查找一个函数或变量的出现位置

Lookup Reference(快捷键ctrl+/) 建立一个Reference链接，所对应的链接处会出现一个链接标志，通过链接标志可以方便的进行函数的查看。

img

Go To Previous Link 跳转到前一个Reference链接（此功能必须先建立一个Reference链接）

Go To Next Link(shift+F9) 跳转到前一个Reference链接（同上）

Go Back(Alt+)) 光标调转到前一个历史操作位置

Go Forward(Alt+.) 光标调转到后一个历史操作位置

Go To Line(F5) 跳转到指定的行位置

Bookmark(ctrl+M) 书签

img

帮助功能

本帖附件

点击下载

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

Android系统架构师安卓系统的体系机构，Android的系统架构和其他操作系统一样，采用了分层的架构，共分为4层，从高到低分别是Android应用层，Android应用架构层，Android系统运行层和Linux内核层。

1. 应用程序

顶层中有所有的Android应用程序，包括通讯录、浏览器等，你写的应用程序也被安装在这层；所有的的应用程序都是使用Java语言编写的。

2. 应用框架层

这一层主要提供构建应用程序是可能用到的各种API，Android自带的一些核心应用就是使用这些API完成的，开发者也可以通过使用API来构建自己的应用程序

活动管理者（Activity Manager）：控制应用程序生命周期和活动栈的所有方面

内容提供器（Content Providers）：允许程序之间发布和分享数据。

资源管理器（Resource Manager）：提供对非代码嵌入资源的访问，如字符串、颜色设置和用户界面布局。

通知管理器（Notification Manager）：允许应用程序显示对话框或者通知给用户

视图系统（View System）：一个可拓展的视图集合，用于创建应用程序用户界面

3. 系统运行库层

1） 程序库

Android包含一些C/C++库，这些库能被Android系统中不同的组件使用。他们通过Android应用程序框架为开发者提供服务，以下是一些核心库：

  • 系统C库（libc）:一个从BSD继承来的标准C系统函数库，他是专门为基于embedded linux的设备定制的媒体库（Media Framework）：基于Packet Video opencore; 该库支持多种常用的音频、视频格式回放和录制，同时支持静态图像文件。编码格式包括 MPEG4。H264、MP3、AAC、AMR、JPG、PNG。
  • Surface Manager：对显示子系统的管理，并且为多个应用程序提供了2D和3D图层的无缝融合。
  • SGL：底层的2D图形引擎
  • 3D libraries：基于OpenFLES1.0 APLs实现，该库可以使用硬件3D加速或者使用高度优化3D软加速
  • FreeType：位图（bitmap）和矢量（vector）字体显示
  • SQLite：一个对于所有应用程序可用，功能强劲的轻型关系型数据库引擎。

2） Android运行库

Android包括了一个核心库，该核心库提供了Java编程语言核心库的大多数功能。

每一个Android应用程序都在它自己的进程中运行，都拥有一个独立的Dalvik虚拟机实例。Dalvik被设计成一个设备可以同时高效地运行多个虚拟系统。Dalvik虚拟机执行（.dex）的Dalvik可执行文件，该个税文件针对小内存使用做了优化。同时虚拟机是基于寄存器的，所有的类都经由java编译器编译，然后通过SDK中的”dx”工具转化成 .dex格式由虚拟机执行

Dalvik虚拟机依赖于linux内核的一些功能，比如线程机制和底层内存管理机制。

4. Linux内核层

Android系统基于Linux2.6内核，这一层为Android设备各种硬件提供了底层驱动，如显示驱动，音频驱动，照相机驱动，蓝牙驱动，WIFI驱动，电源管理等

区别DVM与JVM

  1. 首要差别

1Dalvik：基于寄存器，编译和运行都会更快些

JVM：基于栈，编译和运行都会慢一些

  1. 字节码的区别

Dalvik：执行.dex格式的字节码，是对.class文件进行压缩后产生的，文件变小

JVM：执行.class格式的字节码

  1. 运行环境的区别

Dalvik： 一个应用启动都运行一个单独的虚拟机运行在一个单独的进程中

JVM：只能运行一个实例，也就是所有应用都运行在同一个JVM中

本帖附件

点击下载

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

安卓手机从开机到桌面显示的这个过程,即为Android系统启动过程,那么在这个过程中, Android系统内部都做了哪些操作呢?

首先咱们来看一张Android系统架构图:

Android系统的启动是由下往上进行的

从系统核心库Init.c的main函数开始执行—>Android Runtime—>执行init1函数初始化native也就是Libraries层—>执行init2函数初始化Framework层—>最后是Application层

具体流程图如下:

具体时序图如下:

当然 还有详细的思维导图供大家参考

本帖附件

点击下载

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

目前可用框架

  • MUI
  • ReactNative
  • Weex
  • Cordova
  • Ionic
  • Flutter

1.MUI

mui是最接近原生App体验的前端框架。

体积极小：100k的js文件，60k的css文件。

原生编写，不依赖任何三方框架

极强：xcode和Android studio里所有原生控件都具备

高性能：精练的代码、适时的5+原生动画调用，达到原生应用的体验

多端发布：编写一套代码，iOS、Android、浏览器、微信App、百度直达号、流应用全覆盖

2 . ReactNative

Facebook出品

文档全

社区成熟

组件丰富

劣势

需要维护两套代码，即 iOS，Android 各一套。并且开发调试 iOS 只能使用 Mac 设备

对开发设备有要求，调试不方便

3.Weex

iOS, android, H5 共用一套代码，

基于vue

但是

社区极度不成熟

文档不全

组件有限

资料少

4.Cordova

前身是PhoneGap,后被Adobe公司收购, 目前已经捐赠给Apache开源

优势

集成方便

文档全

组件丰富

劣势

流畅度欠缺

5.ionic

优势

基于Angular语法,简单易学

开发效率高(如果熟悉Angular的话)

劣势

受限于Angular

流畅度一般

可定制性差

6.Flutter

google出品

性能强

组件丰富

跨平台

但是

开发门槛稍高 需要学习Dart语言

本帖附件

点击下载

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

Source Insight4.0简介

Source Insight 4.0是一款功能强大的程序编辑器和代码浏览器，只要你拥有相应的程序语言包就能够进行程序分析， 比如说目前最好的开源语言java

作为一个android开发人员, 如果你想在windows平台上阅读程序源码, 那么Source Insight是你的布尔首选

Source Insight4.0 下载地址

如果您已经安装了sourceinsight4.0，只是需要破解，则直接下载以下资源:

链接: https://pan.baidu.com/s/1dFWD4YX 密码: icjm

解压密码: biu 因可能被检测版权问题，故必须加密打包分享。

如果需要全部重新安装，请下载 完全安装包+破解exe+lisence 压缩包：

链接: https://pan.baidu.com/s/1eSZtsbw 密码: 3kjj

解压密码: biu 因可能被检测版权问题，故必须加密打包分享。

备用破解版下载:

https://545c.com/f/21042697-503735264-7eb2bc
（访问密码：312306）

Source Insight4.0破解方法

第一步 安装Source Insight4.0

第二步 替换Source Insight.exe文件

第三步 加载lic注册文件

第四步 点击“Next”破解成功！

附录二：

如果安装或者安装后提示有问题，请进行完全卸载后，再重装一遍即可。

完全卸载方式：

1、清除注册表信息：

  • “win ”+ R 或者 “开始” -> “运行”，输入“regedit”，回车；
  • 在弹出的注册表管理器中，选择“编辑”-> “查找”->“source insight”，或按照下述路径展开：HKEY_CURRENT_USER -> software -> Source Dynamics -> Source Insight;
  • 将该项下面的source insight 需要清除的对应版本项目选中，右键“删除“。

2、删除全局配置信息：

  • 在 ./user/document/source insight 3.0/4.0 下的所有文件及该文件夹
  • 注意此处的路径可能不同 也可能是:“库”->“用户”(也可能是你的名字) -> 文档 -> source insight3.0/4.0
  • 或者 你上次安装的时候所指定的其他位置

本帖附件

点击下载

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

为什么会内存泄漏

内部类持有外部类对象引用,导致外部类无法被回收

如何解决内存泄露

  • 使用静态内部类
  • Activity销毁时handler.removeCallback()
  • 使用弱引用

本帖附件

点击下载

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。

这两个方法都 可以启动Service，但是它们的使用场合有所不同。

  • 使用startService()方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服 务仍然运行。

  • 使用bindService()方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的 特点。

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

一.冒泡排序介绍

冒泡排序是我们得最多的排序方式之一，原因是简单易实现，且原理易懂。顾名思义，冒泡排序，它的排序过程就像水中的气泡一样，一个一个上浮到水面。
img

二.冒泡排序原理分析

img

三.冒泡排序代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/**
 * @Author {LearnAndGet}
 * @Time 2019年1月8日
 * @Discription:
 */
package com.sort;

import java.util.Arrays;

public class MaopaoSort {
    
    static int[] array = {3,2,4,1,5,0};
    
    public static void maopaoSort(int[] a) 
    {
        //外层循环，是需要进行比较的轮数，一共进行5次即可
        for(int i=0;i<a.length-1;i++) 
        {
            //内存循环，是每一轮中进行的两两比较
            for(int j=0;j<a.length-1;j++) 
            {
                if(a[j] > a[j+1]) 
                {
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp; 
                }
            }
            System.out.println("第"+(i+1)+"轮排序后的数组为: "+Arrays.toString(a));
        }
    }
    
    public static void main(String[] args) {
        maopaoSort(array);
    }
}

输出结果

1
2
3
4
5
第1轮排序后的数组为: [2, 3, 1, 4, 0, 5]
第2轮排序后的数组为: [2, 1, 3, 0, 4, 5]
第3轮排序后的数组为: [1, 2, 0, 3, 4, 5]
第4轮排序后的数组为: [1, 0, 2, 3, 4, 5]
第5轮排序后的数组为: [0, 1, 2, 3, 4, 5]

四.冒泡排序的优化

1 .观察上述代码和运行结果，我们可以发现，当第一轮结束后，最后一个数字一定是数组中最大的元素，那么我们在进行第二趟的两两比较时，实际上是没有必要再对第5个和第6个进行比较的。那么我们可以修改代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void maopaoSort(int[] a) 
{
    //外层循环，是需要进行比较的轮数，一共进行5次即可
    for(int i=0;i<a.length-1;i++) 
    {
        //内存循环，是每一轮中进行的两两比较
        //并且每一轮结束后，下一次的两两比较中可以少比较一次
        for(int j=0;j<a.length-i-1;j++) 
        {
            if(a[j] > a[j+1]) 
            {
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp; 
            }
        }
        System.out.println("第"+(i+1)+"轮排序后的数组为: "+Arrays.toString(a));
    }
}

继续运行后，可以发现运行结果是一样的。

2 .当我们用数组：{1,2,0,3,5,4}来测试上述冒泡排序时，运行结果如下：

1
2
3
4
5
第1轮排序后的数组为: [1, 0, 2, 3, 4, 5]
第2轮排序后的数组为: [0, 1, 2, 3, 4, 5]
第3轮排序后的数组为: [0, 1, 2, 3, 4, 5]
第4轮排序后的数组为: [0, 1, 2, 3, 4, 5]
第5轮排序后的数组为: [0, 1, 2, 3, 4, 5]

可以看到，在第2轮排序完成后，其实我们就已经的到了排好序的数组，但是我们的程序并不知道，仍然进行了后续的无用工作。那么，我们如何来让程序知道已经完成好排序了呢？

这里可以想到，当某一轮的两两比较中，如果都没有发生数组元素的互换，那么其实排序工作已经完成了，所以我们可以考虑在程序中加入一个flag，默认为false，含义是该轮比较中是否发生了元素互换，当程序中执行到元素互换时，将该flag置为true，当该轮比较结束时，若flag为flase，则说明该轮比较未发生元素互换，那么排序完成，若flag为true，说明本轮比较仍然有元素互换，需要继续进行下轮排序。代码实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**
 * @Author {LearnAndGet}
 * @Time 2019年1月8日
 * @Discription:
 */
package com.sort;

import java.util.Arrays;

public class MaopaoSort {
    
    static int[] array = {1,2,0,3,5,4};
    
    public static void maopaoSort(int[] a) 
    {
        //外层循环，是需要进行比较的轮数，一共进行5次即可
        for(int i=0;i<a.length-1;i++) 
        {
            boolean flag = false;
            //内存循环，是每一轮中进行的两两比较
            for(int j=0;j<a.length-i-1;j++) 
            {
                if(a[j] > a[j+1]) 
                {
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    flag = true;
                }
            }
            System.out.println("第"+(i+1)+"轮排序后的数组为: "+Arrays.toString(a));
            if(flag == false)
            {
                System.out.println("本轮中的两两比较未发生元素互换，排序已经完成啦");
                return;
            }
        }
    }
    
    public static void main(String[] args) {
        maopaoSort(array);
    }
}

运行结果：

1
2
3
4
第1轮排序后的数组为: [1, 0, 2, 3, 4, 5]
第2轮排序后的数组为: [0, 1, 2, 3, 4, 5]
第3轮排序后的数组为: [0, 1, 2, 3, 4, 5]
本轮中的两两比较未发生元素互换，排序已经完成啦

五.冒泡排序的时间复杂度

冒泡排序是一种用时间换空间的排序方法，最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序。在这种情况下，每一次比较都需要进行交换运算。举个例子来说，一个数列 5 4 3 2 1 进行冒泡升序排列

第一轮的两两比较，需要比较4次；得到 4 3 2 1 5
第二轮的两两比较，需要比较3次；得到 3 2 1 4 5
第三轮的两两比较，需要比较2次；得到 2 1 3 4 5
第四轮的两两比较，需要比较1次；得到 1 2 3 4 5

所以总的比较次数为 4 + 3 + 2 + 1 = 10次
对于n位的数列则有比较次数为 (n-1) + (n-2) + … + 1 = n * (n - 1) / 2，这就得到了最大的比较次数。
而O(N^2)表示的是复杂度的数量级。举个例子来说，如果n = 10000，那么 n(n-1)/2 = (n^2 - n) / 2 = (100000000 - 10000) / 2，相对10^8来说，10000小的可以忽略不计了，所以总计算次数约为0.5 * N^2。用O(N^2)就表示了其数量级（忽略前面系数0.5）。

综上所述，冒泡排序的时间复杂度为：O(n²)

本帖附件

点击下载

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

0%