内存区域

Java虚拟机在运行时的数据区可以分为：程序计数器、虚拟机栈、本地方法栈、方法区、堆区

程序计数器

什么是程序计数器？

当前线程正在执行字节码的行号指示器，就是说记录着当前线程正在执行的是哪一条字节码指令的地址。

作用

1. 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制(顺序执行，选择，循环等等)
2. 如果是在多线程的情形下，程序计数器会记录下当前线程执行到什么位置，当线程切换回来的时候就可以知道之前的线程执行到什么地方了。

特点

1. 程序计数器记录的是正在执行的虚拟机字节码指令的地址
2. 线程私有，也就意味着生命周期随着线程创建而创建，死亡而死亡
3. Java虚拟机中唯一一个不会出现OOM的内存区域

题目描述

大家都知道斐波那契数列(0,1,1,2,3,5,8,13….)，现在要求输入一个整数n，请你输出斐波那契数列的第n项。
n<=39

解题思路

1. 第一项和第二项没有任何规律，设为初始0,1
2. 第三项 = 第二项 + 第一项
3. 第四项 = 第三项 + 第二项
4. ….
5. f(n) = f(n-1) + f(n-2)

介绍Service

1. Service是Android中应用程序后台运行的解决方案，适合在执行一些不需要用户交互但是还需要长时间运行的任务上。
2. Service运行在UI线程上，所以不建议在服务中进行耗时操作，当然你还是可以再服务中开辟一个子线程进行一些耗时操作
3. Service不依赖于用户界面，当程序被切换到后台的话，依然是可以正常运行。当程序被杀死的时候，服务也会停止运行

介绍

Android上的每一个应用程序都可以对自己感兴趣的广播进行注册，这样这个程序就可以接收到自己感兴趣的广播，广播可以是来自于系统或者来自于其他应用程序。
发送广播需要借助于Intent，接受广播则借助于BroadCastReceiver.

广播分类

1. 标准广播
   异步进行，广播发出之后，所有的广播接收器几乎在同一时间接收到广播，无法被截断
2. 有序广播
   同步执行，广播发出之后，优先级高的广播先接收到广播，优先级低的广播后接收到广播。优先级高的广播可以截断正在传递的广播，这样的话后面的广播就没有办法接收到广播。

用法

添加依赖

1

implementation 'com.android.support:recyclerview-v7:27.0.2'

布局文件

1
2
3
4

<android.support.v7.widget.RecyclerView
        android:id="@+id/recyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

介绍

1. Android四大组件(Activity、Service、BroadcastReceiver、Content Provider)
2. Android使用栈来对Activity来进行管理，所有的Activity会按照启动顺序排序进入一个叫做返回栈的里面。

3. Android中activity有四种启动模式standard、singleTop、singleTask、singleInstance

   • standard:默认模式，每当新建一个activity的时候就会将这个activity压入返回栈中
   • singleTop:如果新建一个Activity A，但是现在发现返回栈的栈顶就是Activity A，那么就直接使用栈顶的Activity A，不用新键
   • singleTask:如果现在新建一个Activity A，但是发现返回栈中出现了Activity A，那么就将返回栈中Activity A之上的所有Activity pop，且不用新建
   • singleInstance:全局单例，无论是在哪一个返回栈中启动目标Activity，都只会创建一个目标Activity实例而且这个时候还会使用一个新键的任务栈装载这个Activity的实例
     阅读全文 »

题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

解题思路

1. 直接排序完事，输出第一个元素
2. 找到第一个出现左>右，然后输出右边的元素

编码实现

1
2
3
4
5
6
7
8
9
10
11

import java.util.Arrays;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        
        if (array.length == 0){
            return 0;
        }
        Arrays.sort(array);
        return array[0];
    }
}

题目描述

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

解题思路

1. push操作：栈1用来push
2. pop操作：栈1 pop–>栈2push–>栈2pop

编码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        if (stack2.empty()){
            if (stack1.empty()){
                System.out.println("空队列");
                return -1;
            }else {
                while (!stack1.empty()){
                    stack2.push(stack1.pop());
                }
            }
        }
        return stack2.pop();
    }
}

题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

解题思路

1. 前序遍历的第一个是根节点
2. 在中序遍历中找到根节点，左边为左子树，右边为右子树
3. 前序遍历中找到左子树根节点
4. 在中序遍历中找到左子树根节点，左边为左子树，右边为右子树
5. 一直递归

编码实现

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

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
        return root;
    }
    //前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
    private TreeNode reConstructBinaryTree(int [] pre,int startPre,int endPre,int [] in,int startIn,int endIn) {
         
        if(startPre>endPre||startIn>endIn)
            return null;
        TreeNode root=new TreeNode(pre[startPre]);
         
        for(int i=startIn;i<=endIn;i++)
            if(in[i]==pre[startPre]){
                root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
                root.right=reConstructBinaryTree(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
                break;
            }
                 
        return root;
    }
}

内存模型以及分区