本文将告诉你学习Java的一些步骤，学习过程中可能遇到的问题，及学习路线。希望能够对你的学习有所帮助。

一、Java基础



 

 



二、Java学习七大阶段

 

阶段1、JavaSE基础



 

推荐观看教程：

 

Java零基础教程视频（适合Java 0基础，Java初学入门）

 

Java数据结构与算法：

 https://www.bilibili.com/video/BV13C4y187FT

 

阶段2、WEB前端

 



 

推荐观看教程：

 零基础学Web前端系列（二）CSS实战入门视频教程

 https://www.bilibili.com/video/BV1tt411M7Vj

 

零基础学Web前端系列（三）JavaScript从入门到精通视频教程

https://www.bilibili.com/video/BV1Ft411N7R3

 

2020最新AJAX教程-AJAX从入门到精通

https://www.bilibili.com/video/BV15k4y167XM

 

2020最新jQuery教程-jQuery从入门到精通

https://www.bilibili.com/video/BV1Jg4y1B7n4

带你快速掌握vue、Vue.js-Vue.JS从入门到实战

https://www.bilibili.com/video/BV1q54y1v7T7

 

阶段3、数据库

 



 

推荐观看教程：

MySQL基础入门-mysql教程-数据库实战（MySQL基础+MySQL高级+MySQL优化+MySQL34道作业题）

https://www.bilibili.com/video/BV1fx411X7BD

JDBC从入门到精通视频教程-JDBC实战精讲

https://www.bilibili.com/video/BV1Bt41137iB

Oracle从入门到精通教程(全套)

https://www.bilibili.com/video/BV1kx411s71n

 

阶段4、JavaWeb

 


			
Javaweb
			
			

			
XML
			
			

			
XML以及相关概念
			
		

			
dom4j+xpath
			
		

			
Servlet
			
			

			
B/S架构概论
			
		

			
Tomcat服务器安装与配置
			
		

			
怎么写一个Servlet
			
		

			
Servlet生命周期
			
		

			
ServletConfig
			
		

			
ServletContext
			
		

			
Servlet线程安全问题
			
		

			
Http协议详解&GET和POST区别与选用
			
		

			
HttpServletRequest
			
		

			
HttpServletResponse
			
		

			
Cookie
			
		

			
HttpSession
			
		

			
转发和重定向
			
		

			
Filter
			
		

			
责任链设计模式
			
		

			
Listener
			
		

			
观察者设计模式
			
		

			
JSP&FreeMarker&Velocity
			
			

			
JSP核心语法
			
		

			
EL表达式
			
		

			
JSTL标签
			
		

			
FreeMarker
			
		

			
Velocity
			
		

			
AJAX
			
			

			
AJAX核心原理
			
		

			
jQuery-AJAX
			
		

			
AJAX跨域
			
		
 

推荐观看教程：

JavaWeb教程-JavaWeb从入门到精通（Javaweb基础/Servlet/JSP/Session/Cookie/监听器/过滤器/文件上传和下载）

https://www.bilibili.com/video/BV18z411i7gh

阶段5、JavaWeb项目

 



 

推荐观看教程：

Java大型项目视频教程-EGOV项目

https://www.bilibili.com/video/BV194411c7SL

 

JavaWeb项目实战-企业级CRM项目-CRM客户管理系统

https://www.bilibili.com/video/BV1fT4y1E7a6

阶段6、流行框架

 



 

推荐观看教程：

2020最新Maven教程-Maven基础篇之Maven实战入门

https://www.bilibili.com/video/BV1dp4y1Q7Hf

SSM框架教程-SSM框架从入门到精通（Aadapter/MyBatis/Spring/SpringMVC/SSM框架整合）

https://www.bilibili.com/video/BV1Ug4y1i7W7

 

经典SSH框架全套教程-SSH框架从入门到精通（JDK动态代理/struts/Hibernate/Spring/OA系统项目）

https://www.bilibili.com/video/BV1uT4y1g7Qo

 

阶段7、前沿技术&架构师项目

 



 

推荐观看教程：

动力节点Dubbo教程(2020最新版)Dubbo项目实战

https://www.bilibili.com/video/BV1Sk4y197eD

Redis实战精讲-13小时彻底搞定Redis

https://www.bilibili.com/video/BV1Uz4y1X72A

 

2020最新Maven教程-Maven进阶篇之Maven多模块管理

https://www.bilibili.com/video/BV1kg4y187td

 

动力节点SpringBoot最新教程-SpringBoot框架实战讲解深入浅出SpringBoot

https://www.bilibili.com/video/BV1PZ4y1j7QK

 

2020最新Nginx教程-Nginx应用实战

https://www.bilibili.com/video/BV11V411C7r9

SpringSession-全网最细的SpringSession教程-springsession实战

https://www.bilibili.com/video/BV1iK411p7dZ

2020最新FastDFS教程-分布式文件系统FastDFS详解-FastDFS从基础到集群实践

https://www.bilibili.com/video/BV1ta4y1v7Kw

 

RabbitMQ实战教程-极速掌握消息中间件RabbitMQ

https://www.bilibili.com/video/BV1Ap4y1D7tU

 

动力节点SpringCloud最新教程-SpringCloud框架实战讲解深入浅出SpringCloud

https://www.bilibili.com/video/BV1aC4y1p7Qi

 

MySQL数据库企业级集群项目实战-MySQL集群实战精讲

https://www.bilibili.com/video/BV1Rg4y1i7VR

Mycat之读写分离与分库分表、

https://www.bilibili.com/video/BV1gK4y1b7iU

Shiro教程-Apache Shiro安全框架实战

https://www.bilibili.com/video/BV14T4y1g75M

 

Java项目-互联网大型电商项目实战教程

https://www.bilibili.com/video/BV1RQ4y1K7Pq

 

上述原文点击打开链接



上面图片来自原文链接



上面图片来自原文链接

数据结构与算法


数据结构是以某种形式将数据组织在一起的集合，它不仅存储数据，还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容，如有错误，欢迎指出。


为了便于描述，文中涉及到的代码部分都是用Java语言编写的，其实Java本身对常见的几种数据结构，线性表、栈、队列等都提供了较好的实现，就是我们经常用到的Java集合框架，有需要的可以阅读这篇文章。Java - 集合框架完全解析

一、线性表
  1.数组实现
  2.链表
二、栈与队列
三、树与二叉树
  1.树
  2.二叉树基本概念
  3.二叉查找树
  4.平衡二叉树
  5.红黑树
四、图
五、总结


一、线性表

线性表是最常用且最简单的一种数据结构，它是n个数据元素的有限序列。

实现线性表的方式一般有两种，一种是使用数组存储线性表的元素，即用一组连续的存储单元依次存储线性表的数据元素。另一种是使用链表存储线性表的元素，即用一组任意的存储单元存储线性表的数据元素（存储单元可以是连续的，也可以是不连续的）。


数组实现


数组是一种大小固定的数据结构，对线性表的所有操作都可以通过数组来实现。虽然数组一旦创建之后，它的大小就无法改变了，但是当数组不能再存储线性表中的新元素时，我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。

代码1 创建一个更大的数组来替换当前数组
int[] oldArray = new int[10];
        
int[] newArray = new int[20];
        
for (int i = 0; i < oldArray.length; i++) {
    newArray[i] = oldArray[i];
}

// 也可以使用System.arraycopy方法来实现数组间的复制     
// System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
        
oldArray = newArray;


代码2 在数组位置index上添加元素e
//oldArray 表示当前存储元素的数组
//size 表示当前元素个数
public void add(int index, int e) {

    if (index > size || index < 0) {
        System.out.println("位置不合法...");
    }

    //如果数组已经满了 就扩容
    if (size >= oldArray.length) {
        // 扩容函数可参考代码1
    }

    for (int i = size - 1; i >= index; i--) {
        oldArray[i + 1] = oldArray[i];
    }

    //将数组elementData从位置index的所有元素往后移一位
    // System.arraycopy(oldArray, index, oldArray, index + 1,size - index);

    oldArray[index] = e;

    size++;
}


上面简单写出了数组实现线性表的两个典型函数，具体我们可以参考Java里面的ArrayList集合类的源码。数组实现的线性表优点在于可以通过下标来访问或者修改元素，比较高效，主要缺点在于插入和删除的花费开销较大，比如当在第一个位置前插入一个元素，那么首先要把所有的元素往后移动一个位置。为了提高在任意位置添加或者删除元素的效率，可以采用链式结构来实现线性表。


链表


链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，这些节点不必在内存中相连。每个节点由数据部分Data和链部分Next，Next指向下一个节点，这样当添加或者删除时，只需要改变相关节点的Next的指向，效率很高。



单链表的结构

下面主要用代码来展示链表的一些基本操作，需要注意的是，这里主要是以单链表为例，暂时不考虑双链表和循环链表。

代码3 链表的节点
class Node<E> {

    E item;
    Node<E> next;
    
    //构造函数
    Node(E element) {
       this.item = element;
       this.next = null;
   }
}


代码4 定义好节点后，使用前一般是对头节点和尾节点进行初始化
//头节点和尾节点都为空 链表为空
Node<E> head = null;
Node<E> tail = null;


代码5 空链表创建一个新节点
//创建一个新的节点 并让head指向此节点
head = new Node("nodedata1");

//让尾节点也指向此节点
tail = head;


代码6 链表追加一个节点
//创建新节点 同时和最后一个节点连接起来
tail.next = new Node("node1data2");

//尾节点指向新的节点
tail = tail.next;


代码7 顺序遍历链表
Node<String> current = head;
while (current != null) {
    System.out.println(current.item);
    current = current.next;
}


代码8 倒序遍历链表
static void printListRev(Node<String> head) {
//倒序遍历链表主要用了递归的思想
    if (head != null) {
        printListRev(head.next);
        System.out.println(head.item);
    }
}


代码 单链表反转
//单链表反转 主要是逐一改变两个节点间的链接关系来完成
static Node<String> revList(Node<String> head) {

    if (head == null) {
        return null;
    }

    Node<String> nodeResult = null;

    Node<String> nodePre = null;
    Node<String> current = head;

    while (current != null) {

        Node<String> nodeNext = current.next;

        if (nodeNext == null) {
            nodeResult = current;
        }

        current.next = nodePre;
        nodePre = current;
        current = nodeNext;
    }

    return nodeResult;
}


上面的几段代码主要展示了链表的几个基本操作，还有很多像获取指定元素，移除元素等操作大家可以自己完成，写这些代码的时候一定要理清节点之间关系，这样才不容易出错。

链表的实现还有其它的方式，常见的有循环单链表，双向链表，循环双向链表。 循环单链表 主要是链表的最后一个节点指向第一个节点，整体构成一个链环。 双向链表 主要是节点中包含两个指针部分，一个指向前驱元，一个指向后继元，JDK中LinkedList集合类的实现就是双向链表。** 循环双向链表** 是最后一个节点指向第一个节点。

二、栈与队列

栈和队列也是比较常见的数据结构，它们是比较特殊的线性表，因为对于栈来说，访问、插入和删除元素只能在栈顶进行，对于队列来说，元素只能从队列尾插入，从队列头访问和删除。


栈


栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫作栈顶，对栈的基本操作有push(进栈)和pop(出栈)，前者相当于插入，后者相当于删除最后一个元素。栈有时又叫作LIFO(Last In First Out)表，即后进先出。



栈的模型

下面我们看一道经典题目，加深对栈的理解。



关于栈的一道经典题目

上图中的答案是C，其中的原理可以好好想一想。

因为栈也是一个表，所以任何实现表的方法都能实现栈。我们打开JDK中的类Stack的源码，可以看到它就是继承类Vector的。当然，Stack是Java2前的容器类，现在我们可以使用LinkedList来进行栈的所有操作。


队列


队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。



队列示意图

我们可以使用链表来实现队列，下面代码简单展示了利用LinkedList来实现队列类。

代码9 简单实现队列类
public class MyQueue<E> {

    private LinkedList<E> list = new LinkedList<>();

    // 入队
    public void enqueue(E e) {
        list.addLast(e);
    }

    // 出队
    public E dequeue() {
        return list.removeFirst();
    }
}


普通的队列是一种先进先出的数据结构，而优先队列中，元素都被赋予优先级。当访问元素的时候，具有最高优先级的元素最先被删除。优先队列在生活中的应用还是比较多的，比如医院的急症室为病人赋予优先级，具有最高优先级的病人最先得到治疗。在Java集合框架中，类PriorityQueue就是优先队列的实现类，具体大家可以去阅读源码。

三、树与二叉树

树型结构是一类非常重要的非线性数据结构，其中以树和二叉树最为常用。在介绍二叉树之前，我们先简单了解一下树的相关内容。


树


** 树 是由n（n>=1）个有限节点组成一个具有层次关系的集合。它具有以下特点：每个节点有零个或多个子节点；没有父节点的节点称为 根 节点；每一个非根节点有且只有一个 父节点 **；除了根节点外，每个子节点可以分为多个不相交的子树。



树的结构


二叉树基本概念


定义
二叉树是每个节点最多有两棵子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。

相关性质
二叉树的每个结点至多只有2棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。

二叉树的第i层至多有2(i-1)个结点；深度为k的二叉树至多有2k-1个结点。

一棵深度为k，且有2^k-1个节点的二叉树称之为** 满二叉树 **；

深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中，序号为1至n的节点对应时，称之为** 完全二叉树 **。



三种遍历方法
在二叉树的一些应用中，常常要求在树中查找具有某种特征的节点，或者对树中全部节点进行某种处理，这就涉及到二叉树的遍历。二叉树主要是由3个基本单元组成，根节点、左子树和右子树。如果限定先左后右，那么根据这三个部分遍历的顺序不同，可以分为先序遍历、中序遍历和后续遍历三种。

(1) 先序遍历 若二叉树为空，则空操作，否则先访问根节点，再先序遍历左子树，最后先序遍历右子树。 (2) 中序遍历 若二叉树为空，则空操作，否则先中序遍历左子树，再访问根节点，最后中序遍历右子树。(3) 后序遍历 若二叉树为空，则空操作，否则先后序遍历左子树访问根节点，再后序遍历右子树，最后访问根节点。



给定二叉树写出三种遍历结果

树和二叉树的区别
(1) 二叉树每个节点最多有2个子节点，树则无限制。 (2) 二叉树中节点的子树分为左子树和右子树，即使某节点只有一棵子树，也要指明该子树是左子树还是右子树，即二叉树是有序的。 (3) 树决不能为空，它至少有一个节点，而一棵二叉树可以是空的。

上面我们主要对二叉树的相关概念进行了介绍，下面我们将从二叉查找树开始，介绍二叉树的几种常见类型，同时将之前的理论部分用代码实现出来。


二叉查找树


定义
二叉查找树就是二叉排序树，也叫二叉搜索树。二叉查找树或者是一棵空树，或者是具有下列性质的二叉树： (1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；(2) 若右子树不空，则右子树上所有结点的值均大于它的根结点的值；(3) 左、右子树也分别为二叉排序树；(4) 没有键值相等的结点。



典型的二叉查找树的构建过程

性能分析
对于二叉查找树来说，当给定值相同但顺序不同时，所构建的二叉查找树形态是不同的，下面看一个例子。



不同形态平衡二叉树的ASL不同

可以看到，含有n个节点的二叉查找树的平均查找长度和树的形态有关。最坏情况下，当先后插入的关键字有序时，构成的二叉查找树蜕变为单支树，树的深度为n，其平均查找长度(n+1)/2(和顺序查找相同），最好的情况是二叉查找树的形态和折半查找的判定树相同，其平均查找长度和log2(n)成正比。平均情况下，二叉查找树的平均查找长度和logn是等数量级的，所以为了获得更好的性能，通常在二叉查找树的构建过程需要进行“平衡化处理”，之后我们将介绍平衡二叉树和红黑树，这些均可以使查找树的高度为O(log(n))。

代码10 二叉树的节点

class TreeNode<E> {

    E element;
    TreeNode<E> left;
    TreeNode<E> right;

    public TreeNode(E e) {
        element = e;
    }
}


二叉查找树的三种遍历都可以直接用递归的方法来实现：

代码12 先序遍历
protected void preorder(TreeNode<E> root) {

    if (root == null)
        return;

    System.out.println(root.element + " ");

    preorder(root.left);

    preorder(root.right);
}


代码13 中序遍历
protected void inorder(TreeNode<E> root) {

    if (root == null)
        return;

    inorder(root.left);

    System.out.println(root.element + " ");

    inorder(root.right);
}


代码14 后序遍历
protected void postorder(TreeNode<E> root) {

    if (root == null)
        return;

    postorder(root.left);

    postorder(root.right);

    System.out.println(root.element + " ");
}


代码15 二叉查找树的简单实现
/**
 * @author JackalTsc
 */
public class MyBinSearchTree<E extends Comparable<E>> {

    // 根
    private TreeNode<E> root;

    // 默认构造函数
    public MyBinSearchTree() {
    }

    // 二叉查找树的搜索
    public boolean search(E e) {

        TreeNode<E> current = root;

        while (current != null) {

            if (e.compareTo(current.element) < 0) {
                current = current.left;
            } else if (e.compareTo(current.element) > 0) {
                current = current.right;
            } else {
                return true;
            }
        }

        return false;
    }

    // 二叉查找树的插入
    public boolean insert(E e) {

        // 如果之前是空二叉树 插入的元素就作为根节点
        if (root == null) {
            root = createNewNode(e);
        } else {
            // 否则就从根节点开始遍历 直到找到合适的父节点
            TreeNode<E> parent = null;
            TreeNode<E> current = root;
            while (current != null) {
                if (e.compareTo(current.element) < 0) {
                    parent = current;
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    parent = current;
                    current = current.right;
                } else {
                    return false;
                }
            }
            // 插入
            if (e.compareTo(parent.element) < 0) {
                parent.left = createNewNode(e);
            } else {
                parent.right = createNewNode(e);
            }
        }
        return true;
    }

    // 创建新的节点
    protected TreeNode<E> createNewNode(E e) {
        return new TreeNode(e);
    }

}

// 二叉树的节点
class TreeNode<E extends Comparable<E>> {

    E element;
    TreeNode<E> left;
    TreeNode<E> right;

    public TreeNode(E e) {
        element = e;
    }
}



上面的代码15主要展示了一个自己实现的简单的二叉查找树，其中包括了几个常见的操作，当然更多的操作还是需要大家自己去完成。因为在二叉查找树中删除节点的操作比较复杂，所以下面我详细介绍一下这里。

二叉查找树中删除节点分析
要在二叉查找树中删除一个元素，首先需要定位包含该元素的节点，以及它的父节点。假设current指向二叉查找树中包含该元素的节点，而parent指向current节点的父节点，current节点可能是parent节点的左孩子，也可能是右孩子。这里需要考虑两种情况：

current节点没有左孩子，那么只需要将patent节点和current节点的右孩子相连。
	
current节点有一个左孩子，假设rightMost指向包含current节点的左子树中最大元素的节点，而parentOfRightMost指向rightMost节点的父节点。那么先使用rightMost节点中的元素值替换current节点中的元素值，将parentOfRightMost节点和rightMost节点的左孩子相连，然后删除rightMost节点。
    // 二叉搜索树删除节点
    public boolean delete(E e) {

        TreeNode<E> parent = null;
        TreeNode<E> current = root;

        // 找到要删除的节点的位置
        while (current != null) {
            if (e.compareTo(current.element) < 0) {
                parent = current;
                current = current.left;
            } else if (e.compareTo(current.element) > 0) {
                parent = current;
                current = current.right;
            } else {
                break;
            }
        }

        // 没找到要删除的节点
        if (current == null) {
            return false;
        }

        // 考虑第一种情况
        if (current.left == null) {
            if (parent == null) {
                root = current.right;
            } else {
                if (e.compareTo(parent.element) < 0) {
                    parent.left = current.right;
                } else {
                    parent.right = current.right;
                }
            }
        } else { // 考虑第二种情况
            TreeNode<E> parentOfRightMost = current;
            TreeNode<E> rightMost = current.left;
            // 找到左子树中最大的元素节点
            while (rightMost.right != null) {
                parentOfRightMost = rightMost;
                rightMost = rightMost.right;
            }

            // 替换
            current.element = rightMost.element;

            // parentOfRightMost和rightMost左孩子相连
            if (parentOfRightMost.right == rightMost) {
                parentOfRightMost.right = rightMost.left;
            } else {
                parentOfRightMost.left = rightMost.left;
            }
        }

        return true;
    }



平衡二叉树


平衡二叉树又称AVL树，它或者是一棵空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。



平衡二叉树

AVL树是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为1，所以它也被称为高度平衡树，n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。


红黑树


红黑树是平衡二叉树的一种，它保证在最坏情况下基本动态集合操作的事件复杂度为O(log n)。红黑树和平衡二叉树区别如下：(1) 红黑树放弃了追求完全平衡，追求大致平衡，在与平衡二叉树的时间复杂度相差不大的情况下，保证每次插入最多只需要三次旋转就能达到平衡，实现起来也更为简单。(2) 平衡二叉树追求绝对平衡，条件比较苛刻，实现起来比较麻烦，每次插入新节点之后需要旋转的次数不能预知。点击查看更多

四、图

简介
图是一种较线性表和树更为复杂的数据结构，在线性表中，数据元素之间仅有线性关系，在树形结构中，数据元素之间有着明显的层次关系，而在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。图的应用相当广泛，特别是近年来的迅速发展，已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。

相关阅读
因为图这部分的内容还是比较多的，这里就不详细介绍了，有需要的可以自己搜索相关资料。

(1) 《百度百科对图的介绍》

(2) 《数据结构之图（存储结构、遍历）》


这篇文章是常见数据结构与算法整理总结的下篇，上一篇主要是对常见的数据结构进行集中总结，这篇主要是总结一些常见的算法相关内容，文章中如有错误，欢迎指出。


一、概述
二、查找算法
三、排序算法
四、其它算法
五、常见算法题
六、总结


一、概述

以前看到这样一句话，语言只是工具，算法才是程序设计的灵魂。的确，算法在计算机科学中的地位真的很重要，在很多大公司的笔试面试中，算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升，花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。




算法简介


算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决，可能会存在着不同的算法，为了衡量一个算法的优劣，提出了空间复杂度与时间复杂度这两个概念。


时间复杂度


一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，算法的时间度量记为 ** T(n) = O(f(n)) **，它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度。这里需要重点理解这个增长率。

举个例子，看下面3个代码：

1、{++x;}

2、for(i = 1; i <= n; i++) { ++x; }

3、for(j = 1; j <= n; j++) 
        for(j = 1; j <= n; j++) 
             { ++x; }

上述含有 ++x 操作的语句的频度分别为1 、n 、n^2，

假设问题的规模扩大了n倍，3个代码的增长率分别是1 、n 、n^2

它们的时间复杂度分别为O(1)、O(n )、O(n^2)



空间复杂度


空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

二、查找算法

查找和排序是最基础也是最重要的两类算法，熟练地掌握这两类算法，并能对这些算法的性能进行分析很重要，这两类算法中主要包括二分查找、快速排序、归并排序等等。


顺序查找


顺序查找又称线性查找。它的过程为：从查找表的最后一个元素开始逐个与给定关键字比较，若某个记录的关键字和给定值比较相等，则查找成功，否则，若直至第一个记录，其关键字和给定值比较都不等，则表明表中没有所查记录查找不成功，它的缺点是效率低下。


二分查找


简介
二分查找又称折半查找，对于有序表来说，它的优点是比较次数少，查找速度快，平均性能好。

二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x，算法中止；如果x<a[n/2]，则只要在数组a的左半部分继续搜索x，如果x>a[n/2]，则只要在数组a的右半部搜索x。

二分查找的时间复杂度为O(logn)

实现
//给定有序查找表array 二分查找给定的值data
//查找成功返回下标 查找失败返回-1

static int funBinSearch(int[] array, int data) {

    int low = 0;
    int high = array.length - 1;

    while (low <= high) {

        int mid = (low + high) / 2;

        if (data == array[mid]) {
            return mid;
        } else if (data < array[mid]) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    return -1;
}


三、排序算法

排序是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个按关键字有序的序列。下面主要对一些常见的排序算法做介绍，并分析它们的时空复杂度。



常见排序算法

常见排序算法性能比较：



图片来自网络

上面这张表中有稳定性这一项，排序的稳定性是指如果在排序的序列中，存在前后相同的两个元素的话，排序前和排序后他们的相对位置不发生变化。

下面从冒泡排序开始逐一介绍。


冒泡排序


简介
冒泡排序的基本思想是：设排序序列的记录个数为n，进行n-1次遍历，每次遍历从开始位置依次往后比较前后相邻元素，这样较大的元素往后移，n-1次遍历结束后，序列有序。

例如，对序列(3,2,1,5)进行排序的过程是：共进行3次遍历，第1次遍历时先比较3和2，交换，继续比较3和1,交换，再比较3和5，不交换，这样第1次遍历结束，最大值5在最后的位置，得到序列(2,1,3,5)。第2次遍历时先比较2和1，交换，继续比较2和3，不交换，第2次遍历结束时次大值3在倒数第2的位置，得到序列(1,2,3,5)，第3次遍历时，先比较1和2，不交换，得到最终有序序列(1,2,3,5)。

需要注意的是，如果在某次遍历中没有发生交换，那么就不必进行下次遍历，因为序列已经有序。

实现
// 冒泡排序 注意 flag 的作用
static void funBubbleSort(int[] array) {

    boolean flag = true;

    for (int i = 0; i < array.length - 1 && flag; i++) {

        flag = false;

        for (int j = 0; j < array.length - 1 - i; j++) {

            if (array[j] > array[j + 1]) {

                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;

                flag = true;
            }
        }
    }

    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
}


分析
最佳情况下冒泡排序只需一次遍历就能确定数组已经排好序，不需要进行下一次遍历，所以最佳情况下，时间复杂度为** O(n) **。

最坏情况下冒泡排序需要n-1次遍历，第一次遍历需要比较n-1次，第二次遍历需要n-2次，...，最后一次需要比较1次，最差情况下时间复杂度为** O(n^2) **。


简单选择排序


简介
简单选择排序的思想是：设排序序列的记录个数为n，进行n-1次选择，每次在n-i+1(i = 1,2,...,n-1)个记录中选择关键字最小的记录作为有效序列中的第i个记录。

例如，排序序列(3,2,1,5)的过程是，进行3次选择，第1次选择在4个记录中选择最小的值为1，放在第1个位置，得到序列(1,3,2,5)，第2次选择从位置1开始的3个元素中选择最小的值2放在第2个位置，得到有序序列(1,2,3,5)，第3次选择因为最小的值3已经在第3个位置不需要操作，最后得到有序序列（1,2,3,5）。

实现
static void funSelectionSort(int[] array) {

    for (int i = 0; i < array.length - 1; i++) {

        int mink = i;

            // 每次从未排序数组中找到最小值的坐标
        for (int j = i + 1; j < array.length; j++) {

            if (array[j] < array[mink]) {
                mink = j;
            }
        }

        // 将最小值放在最前面
        if (mink != i) {
            int temp = array[mink];
            array[mink] = array[i];
            array[i] = temp;
        }
    }

    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
}


分析
简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况** 无关。当i=1时，需进行n-1次比较；当i=2时，需进行n-2次比较；依次类推，共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2，即进行比较操作的时间复杂度为 O(n^2) ，进行移动操作的时间复杂度为 O(n) 。总的时间复杂度为 O(n^2) **。

最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。最坏情况下，即待排序记录初始状态是按第一条记录最大，之后的记录从小到大顺序排列，则需要移动记录的次数最多为3（n-1）。

简单选择排序是不稳定排序。


直接插入排序


简介
直接插入的思想是：是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。

例如，排序序列(3,2,1,5)的过程是，初始时有序序列为(3)，然后从位置1开始，先访问到2，将2插入到3前面，得到有序序列(2,3)，之后访问1,找到合适的插入位置后得到有序序列(1,2,3)，最后访问5，得到最终有序序列(1,2,3,5).

实现
static void funDInsertSort(int[] array) {

    int j;

    for (int i = 1; i < array.length; i++) {

        int temp = array[i];

        j = i - 1;

        while (j > -1 && temp < array[j]) {

            array[j + 1] = array[j];

            j--;
        }

        array[j + 1] = temp;

    }

    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
}


分析
最好情况下，当待排序序列中记录已经有序时，则需要n-1次比较，不需要移动，时间复杂度为** O(n) 。最差情况下，当待排序序列中所有记录正好逆序时，则比较次数和移动次数都达到最大值，时间复杂度为 O(n^2) 。平均情况下，时间复杂度为 O(n^2) **。


希尔排序


希尔排序又称“缩小增量排序”，它是基于直接插入排序的以下两点性质而提出的一种改进：(1) 直接插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。(2) 直接插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。点击查看更多关于希尔排序的内容


归并排序


简介
归并排序是分治法的一个典型应用，它的主要思想是：将待排序序列分为两部分，对每部分递归地应用归并排序，在两部分都排好序后进行合并。

例如，排序序列(3,2,8,6,7,9,1,5)的过程是，先将序列分为两部分，(3,2,8,6)和(7,9,1,5)，然后对两部分分别应用归并排序，第1部分(3,2,8,6)，第2部分(7,9,1,5)，对两个部分分别进行归并排序，第1部分继续分为(3,2)和(8,6)，(3,2)继续分为(3)和(2)，(8,6)继续分为(8)和(6)，之后进行合并得到(2,3)，(6,8)，再合并得到(2,3,6,8)，第2部分进行归并排序得到(1,5,7,9)，最后合并两部分得到(1,2,3,5,6,7,8,9)。

实现
    //归并排序
    static void funMergeSort(int[] array) {

        if (array.length > 1) {

            int length1 = array.length / 2;
            int[] array1 = new int[length1];
            System.arraycopy(array, 0, array1, 0, length1);
            funMergeSort(array1);

            int length2 = array.length - length1;
            int[] array2 = new int[length2];
            System.arraycopy(array, length1, array2, 0, length2);
            funMergeSort(array2);

            int[] datas = merge(array1, array2);
            System.arraycopy(datas, 0, array, 0, array.length);
        }

    }

    //合并两个数组
    static int[] merge(int[] list1, int[] list2) {

        int[] list3 = new int[list1.length + list2.length];

        int count1 = 0;
        int count2 = 0;
        int count3 = 0;

        while (count1 < list1.length && count2 < list2.length) {

            if (list1[count1] < list2[count2]) {
                list3[count3++] = list1[count1++];
            } else {
                list3[count3++] = list2[count2++];
            }
        }

        while (count1 < list1.length) {
            list3[count3++] = list1[count1++];
        }

        while (count2 < list2.length) {
            list3[count3++] = list2[count2++];
        }

        return list3;
    }


分析
归并排序的时间复杂度为O(nlogn)，它是一种稳定的排序，java.util.Arrays类中的sort方法就是使用归并排序的变体来实现的。


快速排序


简介
快速排序的主要思想是：在待排序的序列中选择一个称为主元的元素，将数组分为两部分，使得第一部分中的所有元素都小于或等于主元，而第二部分中的所有元素都大于主元，然后对两部分递归地应用快速排序算法。

实现
// 快速排序
static void funQuickSort(int[] mdata, int start, int end) {
    if (end > start) {
        int pivotIndex = quickSortPartition(mdata, start, end);
        funQuickSort(mdata, start, pivotIndex - 1);
        funQuickSort(mdata, pivotIndex + 1, end);
    }
}

// 快速排序前的划分
static int quickSortPartition(int[] list, int first, int last) {

    int pivot = list[first];
    int low = first + 1;
    int high = last;

    while (high > low) {

        while (low <= high && list[low] <= pivot) {
            low++;
        }

        while (low <= high && list[high] > pivot) {
            high--;
        }

        if (high > low) {
            int temp = list[high];
            list[high] = list[low];
            list[low] = temp;
        }
    }

    while (high > first && list[high] >= pivot) {
        high--;
    }

    if (pivot > list[high]) {
        list[first] = list[high];
        list[high] = pivot;
        return high;
    } else {
        return first;
    }
}


分析
在快速排序算法中，比较关键的一个部分是主元的选择。在最差情况下，划分由n个元素构成的数组需要进行n次比较和n次移动，因此划分需要的时间是O(n)。在最差情况下，每次主元会将数组划分为一个大的子数组和一个空数组，这个大的子数组的规模是在上次划分的子数组的规模上减1，这样在最差情况下算法需要(n-1)+(n-2)+...+1= ** O(n^2) **时间。

最佳情况下，每次主元将数组划分为规模大致相等的两部分，时间复杂度为** O(nlogn) **。


堆排序


简介
在介绍堆排序之前首先需要了解堆的定义，n个关键字序列K1，K2，…，Kn称为堆，当且仅当该序列满足如下性质（简称为堆性质）：(1) ki <= k(2i）且 ki <= k(2i+1) (1 ≤ i≤ n/2），当然，这是小根堆，大根堆则换成>=号。

如果将上面满足堆性质的序列看成是一个完全二叉树，则堆的含义表明，完全二叉树中所有的非终端节点的值均不大于（或不小于）其左右孩子节点的值。

堆排序的主要思想是：给定一个待排序序列，首先经过一次调整，将序列构建成一个大顶堆，此时第一个元素是最大的元素，将其和序列的最后一个元素交换，然后对前n-1个元素调整为大顶堆，再将其第一个元素和末尾元素交换，这样最后即可得到有序序列。

实现
//堆排序
public class TestHeapSort {

    public static void main(String[] args) {
        int arr[] = { 5, 6, 1, 0, 2, 9 };
        heapsort(arr, 6);
        System.out.println(Arrays.toString(arr));
    }

    static void heapsort(int arr[], int n) {

        // 先建大顶堆
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapAdjust(arr, i, n);
        }

        for (int i = 0; i < n - 1; i++) {
            swap(arr, 0, n - i - 1);
            heapAdjust(arr, 0, n - i - 1);
        }
    }

    // 交换两个数
    static void swap(int arr[], int low, int high) {
        int temp = arr[low];
        arr[low] = arr[high];
        arr[high] = temp;
    }

    // 调整堆
    static void heapAdjust(int arr[], int index, int n) {

        int temp = arr[index];

        int child = 0;

        while (index * 2 + 1 < n) {
                        
            child = index * 2 + 1;
                        
            // child为左右孩子中较大的那个
            if (child != n - 1 && arr[child] < arr[child + 1]) {
                child++;
            }
            // 如果指定节点大于较大的孩子 不需要调整
            if (temp > arr[child]) {
                break;
            } else {
                // 否则继续往下判断孩子的孩子 直到找到合适的位置
                arr[index] = arr[child];
                index = child;
            }
        }

        arr[index] = temp;
    }
}



分析
由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。堆排序时间复杂度也为O(nlogn)，空间复杂度为O(1)。它是不稳定的排序方法。与快排和归并排序相比，堆排序在最差情况下的时间复杂度优于快排，空间效率高于归并排序。

四、其它算法

在上面的篇幅中，主要是对查找和常见的几种排序算法作了介绍，这些内容都是基础的但是必须掌握的内容，尤其是二分查找、快排、堆排、归并排序这几个更是面试高频考察点。（这里不禁想起百度一面的时候让我写二分查找和堆排序，二分查找还行，然而堆排序当时一脸懵逼...）下面主要是介绍一些常见的其它算法。


递归


简介
在平常解决一些编程或者做一些算法题的时候，经常会用到递归。程序调用自身的编程技巧称为递归。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。上面介绍的快速排序和归并排序都用到了递归的思想。

经典例子
斐波那契数列，又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）。

//斐波那契数列 递归实现
static long funFib(long index) {

    if (index == 0) {
        return 0;
    } else if (index == 1) {
        return 1;
    } else {
        return funFib(index - 1) + funFib(index - 2);
    }
}


上面代码是斐波那契数列的递归实现，然而我们不难得到它的时间复杂度是O(2^n)，递归有时候可以很方便地解决一些问题，但是它也会带来一些效率上的问题。下面的代码是求斐波那契数列的另一种方式，效率比递归方法的效率高。

static long funFib2(long index) {

    long f0 = 0;
    long f1 = 1;
    long f2 = 1;

    if (index == 0) {
        return f0;
    } else if (index == 1) {
        return f1;
    } else if (index == 2) {
        return f2;
    }

    for (int i = 3; i <= index; i++) {
        f0 = f1;
        f1 = f2;
        f2 = f0 + f1;
    }

    return f2;
}



分治算法


分治算法的思想是将待解决的问题分解为几个规模较小但类似于原问题的子问题，递归地求解这些子问题，然后合并这些子问题的解来建立最终的解。分治算法中关键地一步其实就是递归地求解子问题。关于分治算法的一个典型例子就是上面介绍的归并排序。查看更多关于分治算法的内容


动态规划


动态规划与分治方法相似，都是通过组合子问题的解来求解待解决的问题。但是，分治算法将问题划分为互不相交的子问题，递归地求解子问题，再将它们的解组合起来，而动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。动态规划方法通常用来求解最优化问题。查看更多关于动态规划的内容

动态规划典型的一个例子是最长公共子序列问题。

常见的算法还有很多，比如贪心算法，回溯算法等等，这里都不再详细介绍，想要熟练掌握，还是要靠刷题，刷题，刷题，然后总结。

五、常见算法题

下面是一些常见的算法题汇总。


不使用临时变量交换两个数


static void funSwapTwo(int a, int b) {

    a = a ^ b;
    b = b ^ a;
    a = a ^ b;

    System.out.println(a + " " + b);
}



判断一个数是否为素数


static boolean funIsPrime(int m) {

    boolean flag = true;

    if (m == 1) {
        flag = false;
    } else {

        for (int i = 2; i <= Math.sqrt(m); i++) {
            if (m % i == 0) {
                flag = false;
                break;
            }
        }
    }

    return flag;
}



其它算法题


1、15道使用频率极高的基础算法题

2、二叉树相关算法题

3、链表相关算法题

4、字符串相关算法问题

 

点击下方链接即可查看相关资料

Java 技术书籍大全本文档目前已收录 277本 Java相关领域经典技术书籍，从初级开发者到资深架构师，涵盖 Java 从业者的各个阶段，并持续更新。涵盖领域：Java入门书籍，Java基础及进阶书籍，框架与中间件，架构设计，设计模式，数学与算法，JVM周边语言，项目管理&领导力&流程，职业素养与个人成长

 

数据结构与算法原文出自简书尘语凡心常见数据结构与算法整理总结

当然作为后端也要掌握一些架构师技术图谱

阿里云学生机1年114元限时活动（24岁以下都可以购买）https://promotion.aliyun.com/ntms/act/campus2018.html?userCode=a6violqw阿里云1888元红包：https://promotion.aliyun.com/ntms/yunparter/invite.html?userCode=a6violqw

最后可以关注我的个人网站了解更多或者关注我们的公众号



优库云是一个致力于分享学习干货、实用工具、优秀博客、面试宝典、互联网资讯技术、新闻观察、热点资讯、京东淘宝好物、优惠活动的平台。不定时推送，关注置顶公众号不错过任何福利！或者直接打开链接直接关注https://mp.weixin.qq.com/s/XHMsZaQYK-PkmudA_JXLSA

引言
最近也有很多人来向我"请教"，他们大都是一些刚入门的新手，还不了解这个行业，也不知道从何学起，开始的时候非常迷茫，实在是每天回复很多人也很麻烦，所以在这里统一作个回复吧。
Java学习路线
当然，这里我只是说Java学习路线，因为自己就是学Java的，对Java理当很熟悉，对于其它方面，我也不是很了解。
基础阶段
首先是基础阶段，在基础阶段，我们必须掌握Java基础，Mysql数据库，Oracle数据库，JDBC，Linux基础，Java8新特性，数据结构和算法，设计模式。

对于基础阶段，我们所要掌握的就是基础，虽然是基础，但学起来也够呛。因为是初学者，所以基础阶段会有一点难度，但只要肯坚持，这些也没什么难的。对于Linux、数据结构、算法和设计模式我们掌握一些基础就行了，也没必要学得非常透彻。
Web基础
基础阶段过后，我们还必须要掌握一些Web方面的知识，Html，JavaScript，JQuery和AJax，同样的，对于这些知识，我们只需掌握基础，而不需要深究，否则，你将耗费大量的时间。
JavaWeb
Web阶段过后，当然就是JavaWeb了，对于JavaWeb，我们需要掌握的知识有：Servlet，JSP，MVC设计模式，Cookie，Session，JavBean组件技术，EL表达式，JSTL表达式，过滤器Filter，监听器Listener，文件的上传下载，国际化。
JavaEE
最后是JavaEE阶段，当你学到这个阶段，你对Java的程序开发已经了如指掌。然而，自己开发的过程是艰难而复杂的，所以JavaEE阶段我们需要去学习一些非常优秀的框架，来帮助我们进行程序开发。

对于框架，我们需要学习Struts2，Hibernate，Spring，SpringMVC，JPA，SpringData，MyBatis，Spring Boot，Spring Cloud，Dubbo。要学习的框架其实非常多，有些框架也十分有难度，我们在学习阶段只要能够熟练使用它们即可，有能力的话可以研究一下源码，看看框架的底层实现。当然，除了框架，我们还需要学习Maven，Git，Github，ActiveMQ，Jenkins等。

在JavaEE阶段学习的东西是最多的，但如果你经历了JavaEE阶段的学习，你的编程水平将会有质的飞跃。
其它
这里是我在写了这篇文章几天后才加上的，有人向我反映，说数据结构和算法不学好就只能当个码农，说我在文章中指出"只需学习数据结构和算法的基础即可"是误导别人。确实，这句话是没说错，我在之前的文章中也强调过数据结构和算法的重要性，它们是程序的灵魂。然而，数据结构和算法是具有一定难度的，对于新手可能非常地不友好，新手要想彻底掌握它们是很困难的，所以我只是说在基础阶段掌握基础即可，而不需要去深究。而随着学习的深入，你的知识体系将会越来越庞大，这个时候，对于数据结构和算法可不能仅仅停留在表面了，我们应该去更加深入地研究这些东西。

在这里也感谢大家给我提出的意见，只要大家说的在理，说的是对的，我都会去及时改正。金无足赤，人无完人，在写文章的过程中，难免会有一些不太严谨的地方，这里也欢迎大家批评指正。
学习资源
我知道，对于有些名词，你们可能都没有听过。没关系，按照这个路线一点一点地往下学，相信你会感受到编程的魅力所在。

下面对整条知识路线进行一个梳理，并附上对应的学习资源，需要的小伙伴们下载就好了。

基础阶段

Java基础——链接：链接：https://pan.baidu.com/s/17yh-M7LYSRsXmFeQKSrAww  提取码：mqf4  


Mysql数据库——链接：https://pan.baidu.com/s/1NfS6Q9fb_OMna608w9GYeg 提取码：94ns 


Oracle数据库——链接：https://pan.baidu.com/s/12uVSvaY4pbXRWy2DtIIf8w 	提取码：5r8p 


JDBC——链接：https://pan.baidu.com/s/1QF9S_GpucFvoLSrQqV6d0Q 	提取码：ltnh 


Linux基础——链接：https://pan.baidu.com/s/1e0ekEVjmtfNWAEO0123wDw 		提取码：pwxz


Java8新特性——链接：https://pan.baidu.com/s/103nPGgEEjbxzuy1rHRJepg 	提取码：6omt 


Java数据结构和算法——链接：https://pan.baidu.com/s/1LQ__Hp7i-TR7gRa4YJQXJg  提取码：zwwd  


Java设计模式——链接：https://pan.baidu.com/s/1ik7PRwlAVgJzhSCdthdu1A 	提取码：nr5e
Web阶段

JavaScript DOM——链接：https://pan.baidu.com/s/1_HtKFXeRm5xF7p2vYk_c7w 提取码：ks6g 


JQuery——链接：https://pan.baidu.com/s/1IPPNu2qsJ-MgLX7mGcVYbQ 提取码：umdr

AJAX——链接：https://pan.baidu.com/s/1MC1iryOq9_SSV1qWYk5P5Q 提取码：78hu
JavaWeb

JavaWeb阶段——链接：https://pan.baidu.com/s/1EJYIgAuAHhaJLv8Pp-QjgA 提取码：584f
JavaEE

JavaEE阶段全套视频——链接：https://pan.baidu.com/s/1rJ5MyvFMuN_cbDVbw-2B3A 	提取码：mdlf

课件及源代码
文章发布过后，有很多人来问我有没有源码和课件，这里当然是有的，为了方便大家，我就把源码和课件链接放在这里，也不用劳烦大家一直问了。

链接：https://pan.baidu.com/s/18fr2-Hy-0aoRr9wDIl1zbg 提取码：2zxp
关于Java学习路线上的所有资源都在这里了，欢迎大家下载！
马上就要到中秋佳节了，在这里也提前祝贺各位中秋节快乐，身体健康，阖家欢乐！
2021年01月06日更新
因为百度网盘自身的一些原因，导致这些资源经常出现失效的现象，而且资源数目比较多，维护起来比较麻烦，所以我特地将所有资源进行了一个整合，上面的所有学习资源都在这个链接里面：

链接：https://pan.baidu.com/s/1TZMtgDjxoNPa5SZm5Q6c9g

提取码：h0dm

前言

看到一篇文章中提到“最近几年国内的初级Android程序员已经很多了，但是中高级的Android技术人才仍然稀缺“，这的确不假，从我在百度所进行的一些面试来看，找一个适合的高级Android工程师的确不容易，一般需要进行大量的面试才能挑选出一个比较满意的。为什么中高级Android程序员不多呢？这是一个问题，我不好回答，但是我想写一篇文章来描述下Android的学习路线，期望可以帮助更多的Android程序员提升自己。由于我也是从一个菜鸟过来的，所以我会结合我的个人经历以及我对Android学习过程的认识来写这篇文章，这会让这篇文章更加真实，而并非纸上谈兵。



我的工作经历

前面说到，我也是从一个Android菜鸟过来的。其实这句话放在任何人的身上都是适用的，即大家都是一步步过来的，因此作为初学者也不必因为技术差而郁闷，同理，高手也不要看不起一些所谓的菜鸟，因为这不公平，技术只有在同等的工作年限上才具有一定的可比性，也许你眼中的菜鸟只是个工作半年的新手，而你已经工作5年，可想而知，这根本不具有可比性，搞不好别人5年后可以达到比你更高的技术高度。

我有若干个技术QQ群，群里（481798332）的小伙伴对我的工作经历比较感兴趣，刚好在这里我就做下介绍。我是硕士研究生毕业，我已经工作3年零3个月了，职位上从最开始的腾讯初级工程师变成了现在的百度Android资深工程师。最开始我并不是做Android的，先是做了半年的C++，接着做了3个月的Web前端，然后公司内部转岗做Android到至今，纯Android工作年限的话其实是2.5年。但是我认为我的Android工作经验（注：工作年限不等同于工作经验）不止2.5年，我投入大量的业余时间在Android开发上，并且我习惯去思考问题、总结问题并将其融会贯通，因此我的Android技术在短时间内有了很大的提升。

在Android学习过程中，初学者踩过的坑我也都踩过，我也深深地知道大家在学习过程中最棘手的问题是什么。举个例子，在3年前，我想在SlidingMenu中放入一个ListView，发现二者总是不能很好地一起工作，这肯定是由于滑动冲突的问题，我也知道，但是不知道怎么解决。我就去学校图书馆翻遍了所有的Android书籍，无果。大家肯定都知道原因，为什么我无法从书中查找到问题的答案，因为入门书不讲滑动冲突，所谓的高级编程书也不讲。还有一个问题，我曾经以为view.post(runnable)可以让runnable的run方法在线程中执行，所以我就在run方法里面去做耗时的操作，现在想想我当时是多菜啊，因此我曾经也是菜鸟。

直到若干年后的某一天，我终于琢磨透了滑动冲突的事，然后我就把解决问题的思想写在了CSDN博客上，但是好像看得人并不多，很多人并不能体会我的用心，后来我博客的访问量越来越大，这才慢慢地得到了一些人的关注。后来有一天我有了写书的契机，我想到了我最开始学习Android时所踩过的坑，想到滑动冲突对我的困扰，为了更好地传播我的技术经验，为了让更多的人少踩一些坑，为了让更多地人成为Android高级工程师，我毅然决定将Android开发中最重要的、最疑难的、最容易困扰大家的、成为高级工程师所必备的知识点和盘托出，这就是《Android开发艺术探索》存在的原因以及意义。书的反响怎么样呢？从目前读者的评价来看，内容基本无差评，我收到了很多读者的肯定以及感谢，这说明很多人能够理解我的用心。

说了那么多，言归正传，下面说下Android学习路线的话题，本文打算从4个阶段来对Android的学习过程做一个全面的分析，分别为Android初级、中级、高级以及资深工程师，具体请看下面的分析。同理，本篇学习路线仍然只针对Android应用开发，不针对Rom开发和逆向工程等。这里虚拟一位“小明”的角色，在这里小明就是Android初学者的代表。



初级工程师

小明之前完全没接触过Android开发，是个应届生，他的待遇是13k，然后小明以校招的身份进入了百度，然后小明需要怎么学习才能成为初级工程师呢？这个时候，小明对编程基础、数据结构、C语言都有一定基础，Java语法什么的也都掌握的比较好，Android才有java语言，无奈的是小明并不会搞Android。

小明首先需要购买一本Android入门的书籍，为了更快地学习Android，小明业余时间也都用来一边看书一边照着书中的例子敲代码，结果2周时间小明就把这本书学了一遍。看完这本书后，小明对Android的历史、结构、代码规范等都有了一个大概的了解，并且，小明已经可以写出一些简单的Activity了。这个时候在小明眼里，Android开发很简单很好玩，通过在xml中摆放一些按钮文本框什么的就可以做一些界面了。

小明开始跟着他的技术导师做需求，一些简单的小需求小明自然是不在话下了。突然有一天来了一个需求，该需求要求小明在Activity中为一个button加一个动画效果，小明慌了：“完全没接触过，书上也没有讲，怎么办呢？”小明冷静了下，打开了百度搜索，输入“Android 动画”，打开前几个链接，小明恍然大悟，照着网上的例子把需求给实现了。后来导师告诉他：“学好Android，官方文档是必须看的，既全面又权威”。然后小明如获至宝，花了一年时间把上面的guide和training都看了一遍，并且他还动手抄了几个小例子。

有一天，小明又需要做一个动画相关的需求，这可难不倒小明，它熟练地打开了www.baidu.com，输入“Android 动画”，突然他楞了一下：”总不能每次写动画都要百度一下吧！“，于是他在CSDN开了一个博客，把动画相关的知识点都写上去，为的是后面再写动画相关的代码就不用百度去搜了，事实如何呢？后面再写动画相关的代码，小明的确不用再去百度搜了，因为通过写一篇动画博客，他把动画相关的细节都已经记住了，这样他就可以不用再去参考任何文档了，后来小明还学会了把一些琐碎的不方便放在博客上的东西写到了印象笔记上面，什么时候忘了10秒钟以内都可以快速找回来，而不是花10分钟去再次搜索一遍。

这里总结一下，Android入门的时候，需要有一本入门书，好好学习书中的内容，同时花一年时间把Android官方文档中的training和guide看一遍，同时通过写博客和记笔记的方式来做总结，建议让自己的每篇博客都有价值些。通过一年时间的学习，相信每个人都可以达到中级工程师的水平。

技术要求： 

- 基本知识点  

比如四大组件如何使用、如何创建Service、如何进行布局、简单的自定义View、动画等常见技术 

- 书籍推荐 

《第一行代码 Android》、《疯狂Android》



中级工程师

小明经过一年的努力学习终于成为Android中级工程师了，月薪变成了17k。到了中级工程师，已经可以在公司里干很多体力活了，但是一些很重要的任务小明还不能一个人承担起来，这个时候小明需要学习的内容就很多了，如下所示： 

- AIDL：熟悉AIDL，理解其工作原理，懂transact和onTransact的区别； 

- Binder：从Java层大概理解Binder的工作原理，懂Parcel对象的使用； 

- 多进程：熟练掌握多进程的运行机制，懂Messenger、Socket等； 

- 事件分发：弹性滑动、滑动冲突等； 

- 玩转View：View的绘制原理、各种自定义View； 

- 动画系列：熟悉View动画和属性动画的不同点，懂属性动画的工作原理； 

- 懂性能优化、熟悉mat等工具 

- 懂点常见的设计模式



学习方法

阅读进阶书籍，阅读Android源码，阅读官方文档并尝试自己写相关的技术文章，需要有一定技术深度和自我思考。在这个阶段的学习过程中，有2个点是比较困扰大家的，一个是阅读源码，另一个是自定义View以及滑动冲突。

如何阅读源码呢？这是个头疼的问题，但是源码必须要读。阅读源码的时候不要深入代码细节不可自拔，要关注代码的流程并尽量挖掘出对应用层开发有用的结论。另外仔细阅读源码中对一个类或者方法的注释，在看不懂源码时，源码中的注释可以帮你更好地了解源码中的工作原理，这个过程虽然艰苦，但是别无他法。

如何玩转自定义View呢？我的建议是不要通过学习自定义view而学习自定义view。为什么这么说呢？因为自定义view的种类太多了，各式各样的绚丽的自定义效果，如何学的玩呢！我们要透过现象看本质，更多地去关注自定义view所需的知识点，这里做如下总结： 

- 搞懂view的滑动原理 

- 搞懂如何实现弹性滑动 

- 搞懂view的滑动冲突 

- 搞懂view的measure、layout和draw 

- 然后再学习几个已有的自定义view的例子 

- 最后就可以搞定自定义view了，所谓万变不离其宗

大概再需要1-2年时间，即可达到高级工程师的技术水平。我个人认为通过《Android开发艺术探索》和《Android群英传》可以缩短这个过程为0.5-1年。注意，达到高级工程师的技术水平不代表就可以立刻成为高级工程师（受机遇、是否跳槽的影响），但是技术达到了，成为高级工程师只是很简单的事。

技术要求： 

- 稍微深入的知识点 

AIDL、Messenger、Binder、多进程、动画、滑动冲突、自定义View、消息队列等 

- 书籍推荐 

《Android开发艺术探索》、《Android群英传》



高级工程师

小明成为了梦寐以求的高级工程师，月薪达到了20k，还拿到了一丢丢股票。这个时候小明的Android水平已经不错了，但是小明的目标是资深工程师，小明听说资深工程师月薪可以达到30k+。

为了成为Android资深工程师，需要学习的东西就更多了，并且有些并不是那么具体了，如下所示： 

-  继续加深理解”稍微深入的知识点“中所定义的内容 

- 了解系统核心机制： 

1.  了解SystemServer的启动过程 

2.  了解主线程的消息循环模型 

3.  了解AMS和PMS的工作原理 

4.   能够回答问题”一个应用存在多少个Window？“ 

5.  了解四大组件的大概工作流程 

6.  … 

-  基本知识点的细节 

1.  Activity的启动模式以及异常情况下不同Activity的表现 

2.  Service的onBind和onReBind的关联 

3.  onServiceDisconnected(ComponentName className)和binderDied()的区别 

4. AsyncTask在不同版本上的表现细节 

5.  线程池的细节和参数配置 

6.  … 

-  熟悉设计模式，有架构意识



学习方法

这个时候已经没有太具体的学习方法了，无非就是看书、看源码和做项目，平时多种总结，尽量将知识融会贯通从而形成一种体系化的感觉。同时这个阶段对架构是有一定要求的，架构是抽象的，但是设计模式是具体的，所以一定要加强下设计模式的学习。关于设计模式的学习，最近一本新书推荐给大家《Android 源码设计模式解析与实战》，既可以学习设计模式，又可能体会到Android源码中的设计思想，我最近也在阅读此书。

技术要求： 

- 稍微深入的知识点 

- 系统核心机制 

- 基本知识点的细节 

- 设计模式和架构 

- 书籍推荐 

《Android开发艺术探索》、《Android 源码设计模式解析与实战》、《Android内核剖析》



资深工程师

这个阶段的程序员也许并没有太具体的学习路线了。



交流方式


QQ交流群：635778578
欢迎关注我的公众号，会持续更新Android干货 


欢迎加入我的知识星球，一起学习交流 

说实话，对于学习路线这种文章我一般是不写的，大家看我的文章也知道，我是很少写建议别人怎么样怎么样的文章，更多的是，写自己的真实经历，然后供大家去参考，这样子，我内心也比较踏实，也不怕误导他人。
但是，最近好多人问我学习路线，而且很多大一大二的，说自己很迷茫，看到我那篇       普普通通，我的三年大学      之后很受激励，觉得自己也能行，（是的，别太浪，你一定能行）希望我能给他个学习路线，说实话，几乎每天都有问这种问题的，鉴于此，我就来写一篇适合普通大众的学习路线，就从大一入学那一刻开始入门说起，虽然不一定适合你，但或许能给没有明确目标的人带来一些学习的方向，那么这篇文章，我就觉得值了。
**注意：**这篇文章不是让你成为大神的，学完也不是多厉害，而是，给处于大学迷茫、不知道学啥的你，一个学习的方向，无论你是否是科班。不过我相信，当你学完了这些，你应该会有自己的学习方向了。
一、选择一门语言入门编程的世界
1、入门语言的选择
学习编程的第一件事，我觉得就是选择一门语言，不过能选择的语言实在是太多了，不知道如何选择的，可以选如下一门比较热门，也是 90% 人的选择的语言入门。分别是 C 语言，Python，Java。
那应该选哪一门呢？说实话，我觉得选哪一门都问题不大，因为等你成功入门之后，你大概率还会学习其他语言，那么我这里建议跟着学校的课程来选，因为大一基本也都会开设一门编程语言，我们学习当时开设的是 C 语言。
那么问题来了，根据读者的反馈，其实还要部分学校大一是没有开设这些语言的，而且学那些网页设计这类的语言，那该咋办？答是我这里建议你仍然选择一门语言来学习，由于你不是跟着学校的课程走的，那么我这里建议你选择 C 语言。

说实话，我觉得不论你是学哪一门语言的，如果有时间，都应该了解、学习下 C 语言，我觉得，你只要会了 C 语言，那么你入门其他语言分分钟，但会了其他语言，入门 C 语言可能会被虐。学习 C 语言，真的让人学习到挺多知识的，所以你不知道学习哪一门语言，这里我建议学习 C 吧，以后参加打ACM之类的比赛了，也一般用 C/C++。

2、书籍以及视频的介绍
这一个星期，我至少被 15 个人问过学习 C 语言要用哪一本呀？用什么编译器啊？反正我是被问哭了，不过当年我也有这样的疑问，所以就都耐心回答了。所以这里介绍下一些书籍和视频，虽然不是最好的，但我觉得还可以。这里我就以 C/Python/Java 为例子来介绍。

后面我也会出一篇汇总各类工具的文章。现在已经收集了几十个常用开发工具了，不过可没有提供破解教材哈，百度一搜一大堆破解教程或者序列码。估计在过一个星期，我就会整理出来的了

（1）、C语言
书籍推荐：书籍可以看《C语言程序设计》，谭浩强写的，适合入门学习，也是我第一本看的书。进阶可以看《C 和指针》。
视频推荐：可以看郝斌录制的视频，在 b 站搜索 C 语言就出来了，叫做《郝斌 C 语言自学教程》。说实话，对于新手，我觉得看视频还是比较不错的，可以少掉很多坑，不然你搞编译环境都搞死。
这里工具我就不介绍了，一般书籍和视频都会手把手交你们用哪个编译器。我当时用的是 codeblocks 和 vs6
（2）Java
书籍推荐：《Java核心卷1》，这个算是入门书籍吧，入门书籍我看的不多，暂时介绍这一本，因为没看过的一般我不介绍，大家可以去网上搜索。
视频推荐：这里推荐 【尚学堂】Java300集，作者是 高琪 录制的，b 站搜索就可以了。讲的是真的好，入门的话，感觉看前面 100 集就可以了。进阶可以看《Java编程思想》，这本书也很好，解决了我很多疑惑。、
Java 编译器推荐用 IntelliJ IDEA，自己百度去搜索。
（3）Python
书籍推荐：这里推荐《Python编程：从入门到实践》。
视频推荐：我看过小甲鱼是视频，还不错，如果大家要看小甲鱼的视频的话，书籍可以顺便来他的配套书籍吧。视频叫《[小甲鱼]零基础入门学习Python》，b 站搜索就可以了。书籍也是也是《[小甲鱼]零基础入门学习Python》。
开发工具我当时是用 pycharm
问题来了，很多人问，应该掌握到哪个程度才算可以呢？
说实话，我也不大清楚，，我觉得书中说的，90% 理解就可以了，注意，是理解，具体怎么写，忘记了问题不大。总之，当然是学的深点比较好了。

文章首发于公众号『苦逼的码农』，更多经常文章欢迎搜索关注，已有150多篇原创，公众号回复『电子书』送你一份精选电子书

二、数据结构与算法
大学第一学期你入门了某种语言之后，就要开始学习数据结构与算法L。当然，不一定是第一学期，对于非科班的也一样，也是建议这个学习顺序。当然，你有自己的目标，完全可以按照自己的来。
我的文章是主写数据结构与算法的，我秋招也是靠着这个优势拿到 offer 的，所以我认为数据结构与算法是非常非常重要的，可能你会听到工作都基本没用到这些知识啊，或者库函数都帮我们封装好了啊，我们干嘛要学。
如果你这样想的，那你就错了。对于想要找工作的来说，这方面的知识是必考的，所以你得学；对于已经工作的来说，这方面的知识，可以让你学习到很多设计思想，所谓 数据结构 + 算法 = 程序，而且你学了这个，你会发现学习其他知识，上手的特别快。综上，数据结构与算法必学。
好吧，上面扯了这么多，就是告诉你，数据结构与算法的重要性，好了，下面我介绍下入门数据结构必学的有哪些，不过你跟着书本的学习顺序来就是了。
1、基础数据结构的学习
1、时间复杂度、空间复杂度
2、链表、队列、栈
3、树（二叉树，查找二叉树、AVL树，红黑树等）
4、图（图有好多种算法，深度/广度搜索，最短路径、最小生存树等）
如果你是科班的，那么这些我觉得你大一第二学期都学完是最好的了，没学完也问题不大，有些人可能是先教《离散数学》这本课，为数据结构与算法做铺垫。
书籍推荐：《大话数据结构》、《数据结构与算法分析:C语言描述版》，学哪一本？都可以，问题不大，我当时学的是第二本。大家记得根据自己的语言去学，我上面列举的，都是用 c 语言来实现的。
视频：我只看过《小甲鱼的数据结构与算法》视频，你们自己看着办吧。
2、算法的学习
在大一大二，真心建议你们把算法基本功打好，后面就真的没啥时间刷题之类的了，因为无论你以后要学习哪个方向的，算法都是实用的，会一些算法，说话也都自信了。算法的学习，刷题是必须的了，但不建议盲目刷题，而是先学习一些算法思想，在找对应的题刷，要学的主要有：
1、十大排序算法
2、递归、贪心、回溯、动态规划、枚举等
推荐书籍：《阿哈算法》、《算法设计与分析基础》适合入门；《算法第四版》、《算法导论》、《编程之美》适合进阶
视频：这种还是挺建议看书，我没看过视频，，这里就不介绍了。
具体可以看我之前的文章：程序员必须掌握的算法有哪些？谈谈这这几年学过的算法
3、保持算法的学习
算法的学习，真的是靠积累的，而刷题是必须的。而且学校都会举办一些比赛，这里还是比较建议大家去参见的，这样也能让你更加有激情着去学习。当然，每年都会有很多 ACM 编程大赛，要不要参加呢？这个看你了，也不是说参加就一定好，看你自己吧，具体可以参考我之前一篇文章说的： 普普通通，我的三年大学
大家可以在 leetcode 长期保持刷题，一天一两道，或者一个星期三四道都行。

文章首发于公众号『帅地玩编程』，更多经常文章欢迎搜索关注，已有150多篇原创，公众号回复『电子书』送你一份精选电子书

三、选择一门语言深入学习
刚才我选了选择一门语言来入门，之后你可能还会学习其他语言。我当时 C 语言入门，后面深入学习 Java。
你可以学习过很多种语言，但你一定要有一门拿的出手的语言，所以把上面的学习了之后，这个时候你可能是大二，最多大三，那你就应该选择一门语言来深入学习了，一般可选的有四门：C++，Java，Python，Go，如果你想从事后端开发岗位 ，那么 C++，Java和Go相信是大多数人的选择，其中我觉得选择 Java 的人数是最多的。Go 是最近才火起的语言，也是个不错的选择。
那么问题来了，该选哪一门呢？入门你以后想从事游戏之类的开发，那么建议选择 C++，或者你以后比较想去腾讯，字节跳动这些的，可能选择 C++ 会好一点。如果你想从事Web网站开发的，或者未来想去阿里巴巴、美团这些的，那么 Java 会好点，Go 和 Python呢？其实我也不是很懂，哈哈哈哈。不过我听说，对于一些不是很大型的网站之类的，都会用 Python 或者 Go 之类的快速开发。
大家如果是面向公司编程的，可以去看看哪些公司的技术栈，来选。当然，无论你选哪一门，只要你有实力，哪个公司都会收你，只是有可能到时候要转语言，我现在好像是需要从 Java 转向 Go，不过语言只是一门工具，把基础共通的知识学好，转语言都问题不大。
四、以Java为主的后端开发学习路线
由于我是深入学习 Java 的，那我就介绍下 Java 的学习以及书籍的推荐吧，其他语言我觉得也类似。我大二开始学习 Java 的，还是看了挺多知识。入门的就不介绍了，上面介绍过。下面说的基本是深入学习必须理解的了。
1、Java进阶必学
集合模块：主要是包括各种常用集合：例如 Set（包括HashSet，TreeSet）, Map（包括 HashMap，HashTable），List(包括ArrayList，LinkedList)等等，上面列举的都得学习它的源码
多线程：synchronize，volatile，线程池，并发包（如lock等等），太多了，学了你们自然知道，我也不说的太详细了。推荐看《Java 并发编程艺术》+《Java编发编程实战》。
各种文件流：file，inputStream，outputStream等等，反正就是各种文件流，看书时你们自然会看到，不详细介绍。
虚拟机：虚拟机是必须学习的了，重点是GC部分，推荐看《深入理解Java虚拟机：JVM 高级特性与最佳实践》，一本就差不多够了，多看四五遍就行了。
其他：还有很多，如反射，注解，异常等。
2、JavaWeb 入门
学了上面那么多，啥程序、网站也没写出来，有点难受？没事，这个时候，我们就要开始撸网站了，如果是以 Java 作为开发语言的，那么 JavaWeb 是必须学的了。这个时候你可以入门学习下这些（注意，不用深入，快速找个视频入门就可以了）
1、mysql、html+css+js 、 tomcat、xml等。推荐看视频，自己去搜索 JavaWeb的视频，那么哪里不会补哪里，这些知识，几个小时就可以入门一门的了。
2、servlet+jsp 系列。

不建议直接学习框架，也是应该先学习 servlet，这些底层才是最重要滴。

3、三大框架
Servlet 写太麻烦了，只有认真学过 servlet 的人才能吹框架的好处，所以先学 servlet 在来学习框架，主要有三大框架：Spring + SpringMVC + Mybatis。
其实 SpringMVC 也是属于 Spring 吧，MVC 只是一种思想，这里学习顺序是先建议学习 Spring，直接看视频入门学习就可以了，后面在买书。视频还是那句话，B 站搜索。黑马的讲的不错，我当时也是看黑马的。
3、中间件的学习
必须中间件：redis，其他我也没学过，这学过这一门，Redis 感觉人人都得学啊，推荐书籍《Redis 设计与实现》、《Redis开发与运维》。我先看后者，感觉后者适合入门，然后在看前者的。

由于我这篇文章是给一个大致的学习方向的，我就不说的太详细了，不然得单独来一篇《Java学习路线》了。

对于 Java 的学习，我觉得你会了上面这些，我觉得可以去尝试找实习了，应该也能找的到，大二大三去体验一波学习还是挺好的。

文章首发于公众号『帅地玩编程』，更多经常文章欢迎搜索关注，已有150多篇原创，公众号回复『电子书』送你一份精选电子书

五、计算机基础的学习
看过我文章的都知道，我一直强大计算机基础的重要性，所以这里必须列举要学的有哪些。刚才说了选择一门语言深入，你在深入学习的过程中，肯定也在学习学校开设的专业课，包括：计算机网络 + 操作系统 + 数据库 +  汇编 + 计算机组成原理 + 编译原理 等等。
而这些，我认为是非常重要的，对于秋招的同学来说，只要你会这些，就算你是深入学习 Java的，然后你去应聘 C++ 岗，我觉得也问题不大，你和面试官说我不会 C++ 就可以了，大不了到时候转岗。我虽然是 Java 技术栈的，但是我面的公司，都不是 Java 技术栈的，例如 小米，Shopee，字节跳动，腾讯等。但是，这些都问题不大，你只要会这些基础 + 算法，而且，在秋招，特别是对于一些大公司，关于语言的，其实问的也不是很多，基础问的特别多，所以你会基础，面试会占很多优势。下面按照学习的优先级，给这些课程排个序。

其实给他们排优先级是不大好的，这样给他们排，感觉容易被大佬喷，不过没办法，对于小白来说，我还是想排以下顺序

1、计算机网络 + 操作系统
2、数据库 + 计算机组成原理（数据库相应你们可能已经先学过 MySQL 了）
3、汇编 + 编译原理
不过，如果你们还是在校的大一大二，那么可以根据你们课程的学习顺序来，但是，我建议有时间的可以提前学，不一定要等到学校教了才学，反正大部分老师讲的很一般，但时候你学过的话，可以当做复习，或者学其他。
书籍推荐
《计算机网络自顶向下》、《图解 http》、《深入理解计算机操作系统》、《汇编语言》（王爽写的）。具体要掌握到哪个程度可以看我之前的文章了。
【吐血整理】那些让你起飞的计算机基础知识：学什么，怎么学？

之前写过很多文章，所以这里不写的太具体了，具体的可以看我之前写过的文章。

六、总结
我觉得对于大学四年来学，上面这些是最核心的，也是必须学的。但是仅仅是上面这些还是不够的，上面的这些一两年就可以学完的。所以你还有很多其他时间，那么你可以学一些自己感兴趣的，多折腾，多豆鼓，而我上面学的，希望你都学。你也可以看我大学学过的一些核心基础知识：
我的经历/成长/经验
前两年都在折腾，特别是第一年，但是，我始终一直学习那些比较核心的课程。再次强调，这篇文章不是让你成为大神的，学完也不是多厉害，而是，给处于大学迷茫、不知道学啥的你，一个方向，无论你是否是科班,如标题所说，普普/大众。不过我相信，当你学完了这些，你应该会有自己的学习方向了。
最后，是希望各位还在校的学生，大一可以好好浪，但也要保持应有的学习时间，之后，就好好学习吧。不管你是名校还是非名校，我觉得你在只要这几年认真学，进大公司的几率，真的非常大，这绝对不是鸡汤。

上面设计到的工具以及书籍，我都提供了，可以在我的公众号『苦逼的码农』，回复『福利』即可获取。

另外，帅地把公众号的精华文章整理成了一本电子书，共 630页！目录如下

现在免费送给大家，在我的公众号帅地玩编程回复程序员内功修炼即可获取。
推荐阅读
大学四年，小白一路走来，分享一波我是如何学习、提高自己的算法

大学四年自学走来，这些私藏的实用工具/学习网站我贡献出来了

最后，给大家推荐一个 github，在这个github，有很多不错的电子书，并且分类整理了，或许你需要的可以在这里找到哦。点击前往Github

有收获？希望老铁们来个三连击，给更多的人看到这篇文章
1、给俺点个赞呗，可以让更多的人看到这篇文章，顺便激励下我，嘻嘻。
2、老铁们，关注我的原创微信公众号「帅地玩编程」，专注于写算法 + 计算机基础知识（计算机网络+ 操作系统+数据库+Linux）。
保存让你看完有所收获，不信你打我。。了。