精华内容
下载资源
问答
  • java详细学习路线及路线图

    万次阅读 多人点赞 2018-05-20 16:15:02
    java详细路线: 原文出自点击打开链接 本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢? ...

    本文将告诉你学习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节点的左孩子,也可能是右孩子。这里需要考虑两种情况:

    1. current节点没有左孩子,那么只需要将patent节点和current节点的右孩子相连。
    2. 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需要达到的30个目标,在学习之初对Java有一个整体的认识,会让你有学习的方向,起到事半功倍的效果,希望能够对你

    java详细路线:

     

     

    java详细路线:

     

    这是我最开始学习Java时,在博客中找到的大佬整理出来的Java学习路线图,路线图中可以看出学习Java需要达到的30个目标,在学习之初对Java有一个整体的认识,会让你有学习的方向,起到事半功倍的效果,希望能够对你的学习有所帮助。

    个人学习总结

    前面的内容都是copy的大佬的,对于已有的知识我们不必要过于的去纠结,学习才是我们的真正目的,在自己学习Java的过程中,发现有太多的小细节需要我们去注意,对于学习的小白来说,开发工具的获取的过程中都会遇到各种各样的问题。站在巨人的肩上看世界,借着各位大佬的经验,正在努力前行着。

    写博客的目的是为了记录自己在学习过程中遇到的各种问题,总结自己的失败,希望能给更多人带来方便。自己深有体会被一个问题卡住的那种难受,作为学习者希望与大家一起学习,共同进步。有什么问题请留言,大家一起讨论讨论,或许能帮你解决问题;后面会陆续出一些关于Java学习系列的文章,如何你有什么需要请留言给我。

    原文出自点击打开链接

    展开全文
  • 针对本书,java学习可以大致分为3个阶段。初级阶段:学习Java基础语法和类的创建与使用,基础I/0 (输入/输出)操作、各种循环控制、运算符、数组的定义、方法定义格式、方法重载等,并熟练使用一种集成开发工具(如...

    针对本书,java学习可以大致分为3个阶段。

    初级阶段:学习Java基础语法和类的创建与使用,基础I/0 (输入/输出)操作、各种循环控制、运算符、数组的定义、方法定义格式、方法重载等,并熟练使用一种集成开发工具(如Eclipse等)。

    中级阶段:掌握面向对象的封装、继承和多态,学习常用对象和工具类,深入I/0操作,异常处理、抽象类与接口等。

    高级阶段:掌握Java的反射机制、GUI开发、并发多线程、Java Web编程、数据库编程、Android开发等。

    对于读者来说, Java学习的路线在整体上需遵循:初级阶段→中级阶段一高级阶段。循序渐进地学习(见下图) ,不建议读者一开始就"越级"学习,需知"欲速则不达"。在这3个阶段各自内部的知识点,没有必然的先后次序,读者可根据自己的实际情况"有的放矢"地学习。不管处于哪个学习阶段,读者都要重视Java的实战练习。等学习到高级阶段后,还要用一些项目实训来提升自己。

    85e2f296fe77542f7aa34ae1459a25e3.png

    成为一名Java高手,可能需要经历多年的时间。一些读者担心,自己可能等不到成为高手那一天,就无力开发Java了。其实, Java相关的开发行业也如陈年美酒,愈陈愈香。想一想,前面提到Java的核心设计者James Gosling ,发髯皆白,却依然意气风发,时常给比他年轻很多的软件开发精英们讲解Java发展之道那种指点江山的气势,是何等的豪迈! Java软件开发行业职业寿命很长,能提供给从业人员更广阔的发展方向。如果想在Java开发相关的领域有所建树,多一份持久的坚持是必需的。

    从一个Java的初学者,升级为一个编程高手,从来都没有捷径。其必经的一个成长路线正如下图所示:编写代码一犯错(发现问题)一纠错(解决问题)一自我提升一编写代码一犯错(发现问题)一纠错(解决问题)一自我提升......积累了一定的感性认识后,才会有质的突变,提升至新的境界。总之,想成为一个高水平的Java程序员,一定要多动手练习,多思考。

    1c0280f83aec46ee3a43dc889837273a.png

    2000多年前,孔夫子就管说过,"学而时习之,不亦说乎?"杨伯峻先生在《论语译注》中对这句话有精辟的注解: "学了,然后(按一定的时间)去实习它,不也高兴吗?"对于Java的学习,也应是这样,仅仅懂得一堆Java语法,毫无意义,我们必须亲自动手实践它。

    最后需要说明的是, Java高手绝对没有什么捷径可走,也绝不是一本书就能成就的,需要学习者不断地自我迭代,在理论上提升自己(如在读完本书后,还可以接着读读《编程之美》 《设计模式之禅》 《企业应用构架模式》 《97 things software architec should know》等) ,并在实战中反复地练习。只要这样,才能让自己操作代码的“动作"收放自如,才能让自己的"招式"炉火纯青。

    各位Java爱好者,想在这个计算为王的大千世界放马驰骋吗?赶快动手吧(Just do IT) !

    本文节选自《Java编程技术大全》

    ebad7f3b16d9f4e17c63bdfe5e7a848a.png

    本书面向Java的零基础读者,用实际案例引导读者学习。本书主要包括基础知识、核心技术、高级应用和项目案例等4篇内容,帮助读者系统、全面地学习。 为了增强实用性,还特别赠送了精选的考试认证、求职面试等题库,供读者研究学习。最后,为帮助初入职场的从业者顺利进入角色,还赠送了职业规划建议及相关开发文档。

    展开全文
  • 针对本书,java学习可以大致分为3个阶段。初级阶段:学习Java基础语法和类的创建与使用,基础I/0 (输入/输出)操作、各种循环控制、运算符、数组的定义、方法定义格式、方法重载等,并熟练使用一种集成开发工具(如...

    针对本书,java学习可以大致分为3个阶段。

    初级阶段:学习Java基础语法和类的创建与使用,基础I/0 (输入/输出)操作、各种循环控制、运算符、数组的定义、方法定义格式、方法重载等,并熟练使用一种集成开发工具(如Eclipse等)。

    中级阶段:掌握面向对象的封装、继承和多态,学习常用对象和工具类,深入I/0操作,异常处理、抽象类与接口等。

    高级阶段:掌握Java的反射机制、GUI开发、并发多线程、Java Web编程、数据库编程、Android开发等。

    对于读者来说, Java学习的路线在整体上需遵循:初级阶段→中级阶段一高级阶段。循序渐进地学习(见下图) ,不建议读者一开始就"越级"学习,需知"欲速则不达"。在这3个阶段各自内部的知识点,没有必然的先后次序,读者可根据自己的实际情况"有的放矢"地学习。不管处于哪个学习阶段,读者都要重视Java的实战练习。等学习到高级阶段后,还要用一些项目实训来提升自己。

    9755db70edee32502fce6bfead1b8db6.png

    成为一名Java高手,可能需要经历多年的时间。一些读者担心,自己可能等不到成为高手那一天,就无力开发Java了。其实, Java相关的开发行业也如陈年美酒,愈陈愈香。想一想,前面提到Java的核心设计者James Gosling ,发髯皆白,却依然意气风发,时常给比他年轻很多的软件开发精英们讲解Java发展之道那种指点江山的气势,是何等的豪迈! Java软件开发行业职业寿命很长,能提供给从业人员更广阔的发展方向。如果想在Java开发相关的领域有所建树,多一份持久的坚持是必需的。

    从一个Java的初学者,升级为一个编程高手,从来都没有捷径。其必经的一个成长路线正如下图所示:编写代码一犯错(发现问题)一纠错(解决问题)一自我提升一编写代码一犯错(发现问题)一纠错(解决问题)一自我提升......积累了一定的感性认识后,才会有质的突变,提升至新的境界。总之,想成为一个高水平的Java程序员,一定要多动手练习,多思考。

    21eb083ae6e127db7a85d8dd3e996868.png

    2000多年前,孔夫子就管说过,"学而时习之,不亦说乎?"杨伯峻先生在《论语译注》中对这句话有精辟的注解: "学了,然后(按一定的时间)去实习它,不也高兴吗?"对于Java的学习,也应是这样,仅仅懂得一堆Java语法,毫无意义,我们必须亲自动手实践它。

    最后需要说明的是, Java高手绝对没有什么捷径可走,也绝不是一本书就能成就的,需要学习者不断地自我迭代,在理论上提升自己(如在读完本书后,还可以接着读读《编程之美》 《设计模式之禅》 《企业应用构架模式》 《97 things software architec should know》等) ,并在实战中反复地练习。只要这样,才能让自己操作代码的“动作"收放自如,才能让自己的"招式"炉火纯青。

    各位Java爱好者,想在这个计算为王的大千世界放马驰骋吗?赶快动手吧(Just do IT) !

    本文节选自《Java编程技术大全》

    281f6e2e49f6714de23faf108ab36de0.png

    本书面向Java的零基础读者,用实际案例引导读者学习。本书主要包括基础知识、核心技术、高级应用和项目案例等4篇内容,帮助读者系统、全面地学习。 为了增强实用性,还特别赠送了精选的考试认证、求职面试等题库,供读者研究学习。最后,为帮助初入职场的从业者顺利进入角色,还赠送了职业规划建议及相关开发文档。

    展开全文
  • 这篇文章主要是关于小白Java学习路线, 整个学习路线非常的清晰明确,适合各种层次的Java自学者,非常全面的Java学习路线。 整理不易,记得帮忙点个赞哟~ 第一阶段:Java基础 学习任何一门编程语言,首先要学习的是...
  • java详细路线:     图片来源:https://blog.csdn.net/hao65103940/article/details/78478472 本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助...
  • Spring和springMVC详细示例 https://pan.baidu.com/s/1Pf4h7cT_NBIsfSHeDTLb4w (新) oracle数据库单行和多行函数 https://pan.baidu.com/s/1QpG_SBLSOb36qiNRGNnKPA ...
  • java详细路线: 原文出自点击打开链接 本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢? ...
  • Java学习路线(完整详细版)超详细

    万次阅读 多人点赞 2019-05-14 10:56:47
    一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...
  • java学习路线

    2021-02-02 17:58:43
    java详细学习路线及路线图 置顶 钟长森 2020-03-29 12:22:42 ...
  • 详细Java学习路线

    2020-10-03 23:16:42
    Java 资源链接 博主找到的最齐全的Java学习链接(附带大量...博主找到的比较好的Java系统学习图解(附带水印可查看原图):Java体系和Java工程师学习路线图 别再抱怨自己的Java学习路线不清晰不敢向前了,我们本来
  • Java后端详细学习路线

    2020-07-27 09:40:02
    总体学习路线 java语言基础 设计模式 研发工具 应用框架 完整思维导图文件下载 因为文件时坚果云的思维导图,下载后是.nbmx的格式,可以注册坚果云的账号,然后文件上传,进行查看
  • 各种各样的编程语言不断崛起,但唯有Java是牢牢占据着老大的位置,目前几乎90%以上的大中型互联网应用系统在服务器端开发首选Java。...所以,今天,千锋的老师就跟大家分享一份系统的Java学习路线...
  • JAVA学习路线

    2020-03-11 10:59:15
    2020年Java学习路线汇总 2020最新零基础java学习路线图...Java学习路线(完整详细版) 2020年新版Java学习路线图(内含大纲+视频+工具+书籍+面试)-黑马程序员技术交流社区 JAVA学习路线图 2020Java系列学习路线图 ...
  • Java后端开发学习路线

    2020-09-17 15:50:36
    前面出过一个java详细学习路线及路线图的文章,里面是大神总结的Java整体学习的路线图,路线图中介绍了Java学习的大体方向,但由于这个路线图出的时间比较久了,有些东西已经落后了,PS:不过我们学习还是可以参考的...
  • Java教程,Java学习路线图(全网最详细Java教程,Java学习路线图(全网最详细) - CSDN博客​blog.csdn.net写给自己的Java程序员学习路线图史上最强Java学习路线(详解)​www.360doc.comJava 学习线路图是怎样的...
  • java学习路线

    2018-03-26 18:56:21
    java学习路线图,有详细java基础学习路线,javaweb,以及框架和实战演练
  • java学习路线汇总
  • 二、Java学习路线的七大阶 阶段1、JavaSE基础 Java IO操作、 Java常用类的使用、 Java集合的使用、 Java数组的使用、 Java反射机制、 .精通面向对象思想和Java基础语法、 掌握...
  • Java学习路线,Android学习路线,Java全套路线视频下载连接,这一整套的当前最新最权威的java学习视频,从javase到javaee到3G全部学完需要半年,非常详细的视频
  • 推荐教程:1、MySQL数据库https://www.bilibili.com/video/BV1fx411X7BD2、JDBChttps://www.bilibili.com/video/BV1Bt41137iB3、Oracle(有兴趣的可以学习一下)https://www.bilibili.com/video/BV1kx411s71nWeb前端...
  • java学习路线目录全套尚硅谷跟黑马视频笔记混搭 备用参考文档 备用java学习全套参考博客 也比较详细 尚硅谷周扬的博客 主要参考redis笔记 尚硅谷周扬的msyql高级部分 mysql主从复制深入详解 源码参考文档 个人觉得...
  • Java学习路线

    2018-12-29 23:03:05
    详细介绍学习Java路线,让你清晰掌握Java学习路径。
  • Java学习路线

    2020-11-11 21:12:57
    java详细路线:   原文出自点击打开链接 本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢...
  • Java学习详细路线

    2011-04-22 21:32:25
    Java学习路线图。路线图从“0基础入门”——>“JAVA就业”,基本涵盖了JavaEE体系中所有常用、流行技术。
  • java详细路线:网上有很多学习路线,当初,我就是受这个学习路线的影响入坑的。既然看到标题为我的java学习路,那就给大家看下我是怎么走过来的。阶段一_JavaSE入门推荐书:java开发实战经典,对,没看错,就是你们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 498
精华内容 199
关键字:

java详细学习路线

java 订阅