精华内容
下载资源
问答
  • 一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员的...

    在这里插入图片描述

    一门永不过时的编程语言——Java 软件开发。

    Java编程语言占比:

    据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员的数量最多。而在以Java编程为核心的开发领域中,javaEE程序员的需求量10年来一直居于首位!

    Java工程师就业:

    1.通过各大招聘网站统计,全国海量公司都在招聘Java开发工程师

    2.北京Java开发工程师平均薪资,即16788元

    3.全国Java开发薪资前三:北京 上海 广州

    javacto.taobao点com

    工具/原料

      Java学习路线
      Java学习大纲
      

    Java基础课程

      1
      Java基础课程内容涉及:Java开发介绍、Java数组、Java面向对象、常用基础类、集合、IO流、多线程、异常、反射。
      
      
      2
      
      第一部分:Java开发介绍
      
      1. DOS常用命令
      
      2. JVM、JRE、JDK之间的关系
      
      3. Java开发环境的搭建:安装JDK,配置环境变量
      
      4. Java入门程序(Java的开发流程)
      
      5. Java的注释,标识符、标识符的命名规范
      
      6. Java基本数据类型
      
      7. 变量和常量的定义及初始化
      
      8. Java的运算符
      
      9. 运算符的优先级
      
      10. Java分支语句之if...else
      
      11. 循环的嵌套
      
      12. 方法的定义
      
      13. 方法的形参和实参
      
      14. 方法的递归调用
      
      
      3
      
       
      
      第二部分:Java数组
      
      1. Java 数组的定义
      
      2. Java 数组的声明
      
      3. 数组的优势与局限
      
      4. 数组的遍历访问(普通循环,增强for循环)
      
      5. 数组元素的顺序查找
      
      6. 数组元素的冒泡法排序
      
      7. Arrays工具类的使用
      
      8. 二维数组
      
      
      4
      
       
      
      第三部分:Java面向对象
      
      1. 面向对象设计思想
      
      2. 面向对象的分析与设计
      
      3. Java与面向对象
      
      4. 类中成员变量的定义与意义
      
      5. 构造方法的定义和调用
      
      6. 面向对象的封装特性
      
      7. 局部变量和成员变量的作用域问题
      
      8. 静态属性、静态方法、静态代码块
      
      9. 面向对象的继承特性
      
      10. 继承中构造方法的细节
      
      11. 面向对象的多态特性
      
      12. 抽象方法与抽象类
      
      13. 接口
      
       
      
      
      5
      
      第四部分:异常
      
      1. 异常的概念
      
      2. 异常的分类
      
      3. 异常的理解
      
      4. 常见异常介绍
      
      5. 运行时异常
      
      6. 编译时异常
      
      7. 运行和编译异常区别
      
      8. 异常的处理方式之捕获异常
      
      9. 异常的处理方式之抛出异常
      
      10. 异常的处理方式之断点调试
      
      11. 断点调试之引导运行步骤
      
      12. 自定义异常
      
      13. 异常关键字处理
      
      14. 关键字执行流程
      
      15. 异常总结
      
      
      6
      
       
      
      第五部分:集合
      
      1. 集合的概念和作用
      
      2. 集合和数组的区别
      
      3. 集合框架体系介绍
      
      4. 集合框架之Collection接口
      
      6. ArrayList和LinkedList的方法使用
      
      7. ArrayList和LinkedList各自的工作原理分析原理分析
      
      8. 使用多种方式遍历集合
      
      9. HashSet和LinkedHashSet各自的工作原理分析
      
      10. 集合框架之Map接口
      
      11. 泛型的使用
      
      12. Collections工具类的使用
      
       
      
      
      7
      
      第六部分:IO流
      
      1. File类的作用
      
      2. File类中常用方法的使用介绍
      
      3. 使用File类操作文件和文件夹
      
      4. 相对路径和绝对路径的介绍
      
      5. IO流的概念和工作原理
      
      6. IO流的分类
      
      7. 文件流的使用
      
      8. 转换流的使用
      
      9. 缓冲流的使用
      
      10. 对象流的使用
      
      11. 内存流的使用
      
      12. 使用不同的流实现文件内容的拷贝
      
      
      8
      
      第七部分:多线程
      
      1. 进程和线程的介绍
      
      2. 进程和线程之间的区别与联系
      
      3. 线程实现方式之继承自Thread类
      
      4. 线程实现方式之实现Runnable接口
      
      5. 线程实现方式之线程池
      
      6. 线程的生命周期
      
      7. 线程中常用方法的使用
      
      END
      

    第二阶段:JavaWeb

      1
      JavaWeb课程内容涉及:HTML5课程、CSS3、JavaScript、MySQL使用、JDBC连接池、Servlet、JSP、AJAX、jQuery、Bootstrap。
      
      
      2
      
      第一部分:HTML5
      
      1. html概述
      
      2. html基本标签
      
      3. 图片标签
      
      4. 超链接标签
      
      5. 表格标签
      
      6. 无序列表标签
      
      7. 有序列表标签
      
      8. 定义列表标签
      
      9. div标签
      
      10. 语义化标签
      
      11. 表单标签
      
      
      3
      
       
      
      第二部分:CSS3
      
      1. CSS3简介和用途
      
      2. CSS3书写规范
      
      3. CSS3基本语法
      
      4. CSS3三种使用方式
      
      5. 标签选择器
      
      6. Id选择器
      
      7. Class选择器
      
      8. 属性选择器
      
      9. 层次选择器
      
      10. 文字、文本属性
      
      11. 背景、列表属性
      
      12. 尺寸、显示、轮廓属性
      
      13. 浮动、定位属性
      
      14. 盒子模型
      
      15. CSS3高级属性
      
       
      
      
      4
      
       
      
      第三部分:JavaScript
      
      1. JavaScript概述
      
      2. JavaScript发展史
      
      3. JavaScript组成
      
      4. 数据类型
      
      5. 运算符
      
      6. 分支语句
      
      7. 循环语句
      
      8. 系统函数、自定义函数、匿名函数
      
      9. 常见事件
      
      10. 数组、字符串、日期对象
      
      11. 正则表达式
      
      12. BOM对象:window、history、location
      
      13. DOM概念
      
      14. DOM操作:创建、修改内容、删除
      
      15. Css样式操作
      
       
      
      
      5
      
      第四部分:MySQL使用  或oracle数据库
      
      1. 数据库简介
      
      2. MySQL的安装与使用
      
      3. MySQL客户端和服务器配置
      
      4. 用户权限管理
      
      5. DDL创建数据库和表
      
      6. 约束与外键
      
      7. DML实现添加、修改、删除数据
      
      8. 聚合函数、日期函数等
      
      9. DQL简单查询
      
      10. 排序、分组、筛选
      
      11. 多表查询
      
      12. 子查询
      
      13. in和exists关键字
      
      14. 分页查询
      
      15. Mysql SQL语句优化介绍
      
      
      6
      
      第五部分:JDBC连接池
      
      1. JDBC概述
      
      2. JDBC使用步骤
      
      3. Connection、Statement、ResultSet接口
      
      4. 使用JDBC 完成数据库DML操作
      
      5. PreparedStatement对象
      
      6. 大数据的操作
      
      7. 批量处理与元数据
      
      8. 事务处理
      
      9. 隔离级别
      
      10. 自定义连接池
      
      11. DBCP、C3p0连接池
      
      12. DBUtis工具类
      
      13. QueryRunner
      
      14. 自定义结果集处理
      
      15. 连接池知识总结
      
      
      7
      
      第六部分:Servlet
      
      1. Tomcat与Eclipse的集成开发
      
      2. 什么是Servlet
      
      3. Servlet的进化史
      
      4. Servlet的优化过程
      
      5. Servlet中应用的多线程概念
      
      6. Servlet接收客户端请求信息
      
      7. Servlet响应客户端信息
      
      8. Servlet的生命周期
      
      9. 重定向写法
      
      10. 转发写法
      
      11. 转发和重定向区别
      
      12. HttpServletRequest获取中文乱码问题
      
      13. HttpServletResponse响应中文乱码问题
      
      14. Servlet路径映射问题
      
      15. Servlet多路径映射
      
      
      8
      
      第七部分:JSP
      
      1. 什么是JSP
      
      2. JSP的内置对象
      
      3. 透析JSP的本质
      
      4. JSTL+EL
      
      5. MVC介绍
      
      6. 分层的重要性
      
      7. Web工程中事务实现
      
      8. Session的使用
      
      9. Cookie的使用
      
      10. web工程中连接池的使用
      
      11. 实现用户的自动登录
      
      12. 文件的上传、下载
      
      13. 过滤器、 监听器
      
      14. 反射、注解、泛型
      
      15. 综合案例练习
      
      
      9
      
      第八部分:AJAX
      
      1. Ajax技术背景
      
      2. Ajax技术的理解
      
      3. XMLHttpRequest使用步骤
      
      4. XMLHttpRequest GET/POST的区别
      
      5. 同步请求&异步请求
      
      6. 同步请求&异步请求的区别
      
      7. Ajax获取不同的返回值类型
      
      8. Ajax使用原生JavaScript和Jquery的区别
      
      9. Ajax响应状态处理
      
      10. JSON语法
      
      11. Java JSON 解析
      
      12. Java JSON 生成
      
      13. Java JSON 第三方工具快速解析
      
      14. JavaScript JSON转换
      
      15. Jquery JSON转换
      
      END
      

    Java框架课程

      1
      Java框架课程内容涉及:Spring、Spring MVC、MyBatis、SVN、Git、Maven、SpringBoot
      
      
      2
      
      第一部分:Spring
      
      1. 框架原理介绍
      
      2. 框架环境搭建
      
      3. 快速入门
      
      4. 创建Bean的方式及实现原理
      
      5. Bean种类
      
      6. Bean生命周期
      
      7. Bean的作用域
      
      8. Bean的注值方式
      
      9. 整合Junit测试
      
      10. 注解装配Bean
      
      11. 注解装配Bean
      
      12. AOP思想、原理解剖
      
      13. AOP底层JDK动态代理
      
      14.AOP编程
      
      15. AspectJ介绍及实现AOP开发
      
      16.事务
      
      17. Web项目集成Spring
      
      
      3
      
      第二部分:Spring MVC
      
      1. Spring MVC 概述
      
      2. 使用 @RequestMapping映射请求
      
      3. 请求处理方法签名概述
      
      4. 处理方法签名详细说明
      
      5. 使用 HttpMessageConverter
      
      6. 处理模型数据
      
      7. 数据绑定流程剖析
      
      8. 数据格式化
      
      9. 数据校验
      
      10. 视图和视图解析器
      
      11. 处理方法的数据绑定
      
      12. 视图和视图解析器
      
      13. 文件上传下载
      
      14. JSON处理
      
      15. 拦截器
      
      
       
      
      第三部分:MyBatis
      
      1. MyBatis数据框架介绍
      
      2. MyBatis对比Hibernate框架
      
      3. MyBatis配置、查询数据
      
      4. MyBatis全局配置文件
      
      5. MyBatis全局配置文件元素详细介绍
      
      6. Mapper映射文件
      
      7. MyBatis两种开发方式
      
      8. MyBatis中别名配置
      
      9. MyBatis # 和 $ 拼接参数区别
      
      10. 关联查询,动态sql
      
      11. MyBatis缓存机制、整合ehcache
      
      12. MyBatis二级缓存处理
      
      13. MyBatis、Spring、SpringMVC整合
      
      14. 分页插件
      
      15. MyBatis逆向工程
      
       
      
      
      第四部分:SVN   和git
      
      1. SVN简介
      
      2. SVN和Git对比
      
      3. SVN服务器搭建
      
      4. SVN创建仓库
      
      5. SVN创建用户以及分配权限
      
      6. SVN签出、提交、更新
      
      7. Eclipse整合svn插件
      
      8. Idea整合svn插件
      
      9. 使用SVN更新提交
      
      10. SVN仓库分析
      
      11. SVN协同修改&冲突解决
      
      12. SVN代码整合注意事项
      
      13. SVN权限管理
      
      14. SVN数据回滚
      
      15. TortoiseSVN
      
      
      6
      
      第五部分:Maven
      
      1. Maven环境搭建
      
      2. Maven构建项目
      
      3. Maven本地仓库配置
      
      4. Maven中央仓库配置
      
      5. Maven基本概念
      
      6. Maven基本命令介绍
      
      7. Maven于Eclipse整合
      
      8. Maven于Idea整合
      
      9. Maven创建web工程
      
      10. pom.xml、依赖管理
      
      11. 坐标、依赖、生命周期等
      
      12. Eclipse下的Maven使用
      
      13. Maven中 继承、聚合
      
      14. Maven构建SSH/SSM应用
      
      15. 自动部署、持续集成、持续部署
      
      
      第六部分
      
      项目开发
      <hr>
      

    如果你是刚开始学习java,或者刚开始从事java行业,有很多的问题都可以关注微信公众号: java学长 ,一个致力于打造免费指导学习java高薪就业的公益平台!点赞、关注 哦,不定期分享程序员的骚操作和强势浪漫!

    展开全文
  • java详细学习路线及路线图

    万次阅读 多人点赞 2018-05-20 16:15:02
    本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢? 路线 Java发展到现在,按应用来分主要分为三大...

    本文将告诉你学习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周边语言,项目管理&领导力&流程,职业素养与个人成长

     

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

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

    展开全文
  • Java学习路线(完整详细版)超详细

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

    一门永不过时的编程语言——Java 软件开发。

    Java编程语言占比:

    据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员的数量最多。而在以Java编程为核心的开发领域中,javaEE程序员的需求量10年来一直居于首位!

    Java工程师就业:

    1.通过各大招聘网站统计,全国海量公司都在招聘Java开发工程师

    2.北京Java开发工程师平均薪资,即16788元

    3.全国Java开发薪资前三:北京 上海 广州

    javacto.taobao点com

    工具/原料

    • Java学习路线

    • Java学习大纲

    Java基础课程

    1. 1

      Java基础课程内容涉及:Java开发介绍、Java数组、Java面向对象、常用基础类、集合、IO流、多线程、异常、反射。

    2. 2

      第一部分:Java开发介绍

      1. DOS常用命令

      2. JVM、JRE、JDK之间的关系

      3. Java开发环境的搭建:安装JDK,配置环境变量

      4. Java入门程序(Java的开发流程)

      5. Java的注释,标识符、标识符的命名规范

      6. Java基本数据类型

      7. 变量和常量的定义及初始化

      8. Java的运算符

      9. 运算符的优先级

      10. Java分支语句之if...else

      11. 循环的嵌套

      12. 方法的定义

      13. 方法的形参和实参

      14. 方法的递归调用

    3. 3

       

      第二部分:Java数组

      1. Java 数组的定义

      2. Java 数组的声明

      3. 数组的优势与局限

      4. 数组的遍历访问(普通循环,增强for循环)

      5. 数组元素的顺序查找

      6. 数组元素的冒泡法排序

      7. Arrays工具类的使用

      8. 二维数组

    4. 4

       

      第三部分:Java面向对象

      1. 面向对象设计思想

      2. 面向对象的分析与设计

      3. Java与面向对象

      4. 类中成员变量的定义与意义

      5. 构造方法的定义和调用

      6. 面向对象的封装特性

      7. 局部变量和成员变量的作用域问题

      8. 静态属性、静态方法、静态代码块

      9. 面向对象的继承特性

      10. 继承中构造方法的细节

      11. 面向对象的多态特性

      12. 抽象方法与抽象类

      13. 接口

       

    5. 5

      第四部分:异常

      1. 异常的概念

      2. 异常的分类

      3. 异常的理解

      4. 常见异常介绍

      5. 运行时异常

      6. 编译时异常

      7. 运行和编译异常区别

      8. 异常的处理方式之捕获异常

      9. 异常的处理方式之抛出异常

      10. 异常的处理方式之断点调试

      11. 断点调试之引导运行步骤

      12. 自定义异常

      13. 异常关键字处理

      14. 关键字执行流程

      15. 异常总结

    6. 6

       

      第五部分:集合

      1. 集合的概念和作用

      2. 集合和数组的区别

      3. 集合框架体系介绍

      4. 集合框架之Collection接口

      6. ArrayList和LinkedList的方法使用

      7. ArrayList和LinkedList各自的工作原理分析原理分析

      8. 使用多种方式遍历集合

      9. HashSet和LinkedHashSet各自的工作原理分析

      10. 集合框架之Map接口

      11. 泛型的使用

      12. Collections工具类的使用

       

    7. 7

      第六部分:IO流

      1. File类的作用

      2. File类中常用方法的使用介绍

      3. 使用File类操作文件和文件夹

      4. 相对路径和绝对路径的介绍

      5. IO流的概念和工作原理

      6. IO流的分类

      7. 文件流的使用

      8. 转换流的使用

      9. 缓冲流的使用

      10. 对象流的使用

      11. 内存流的使用

      12. 使用不同的流实现文件内容的拷贝

    8. 8

      第七部分:多线程

      1. 进程和线程的介绍

      2. 进程和线程之间的区别与联系

      3. 线程实现方式之继承自Thread类

      4. 线程实现方式之实现Runnable接口

      5. 线程实现方式之线程池

      6. 线程的生命周期

      7. 线程中常用方法的使用

      END

    第二阶段:JavaWeb

    1. 1

      JavaWeb课程内容涉及:HTML5课程、CSS3、JavaScript、MySQL使用、JDBC连接池、Servlet、JSP、AJAX、jQuery、Bootstrap。

    2. 2

      第一部分:HTML5

      1. html概述

      2. html基本标签

      3. 图片标签

      4. 超链接标签

      5. 表格标签

      6. 无序列表标签

      7. 有序列表标签

      8. 定义列表标签

      9. div标签

      10. 语义化标签

      11. 表单标签

    3. 3

       

      第二部分:CSS3

      1. CSS3简介和用途

      2. CSS3书写规范

      3. CSS3基本语法

      4. CSS3三种使用方式

      5. 标签选择器

      6. Id选择器

      7. Class选择器

      8. 属性选择器

      9. 层次选择器

      10. 文字、文本属性

      11. 背景、列表属性

      12. 尺寸、显示、轮廓属性

      13. 浮动、定位属性

      14. 盒子模型

      15. CSS3高级属性

       

    4. 4

       

      第三部分:JavaScript

      1. JavaScript概述

      2. JavaScript发展史

      3. JavaScript组成

      4. 数据类型

      5. 运算符

      6. 分支语句

      7. 循环语句

      8. 系统函数、自定义函数、匿名函数

      9. 常见事件

      10. 数组、字符串、日期对象

      11. 正则表达式

      12. BOM对象:window、history、location

      13. DOM概念

      14. DOM操作:创建、修改内容、删除

      15. Css样式操作

       

    5. 5

      第四部分:MySQL使用  或oracle数据库

      1. 数据库简介

      2. MySQL的安装与使用

      3. MySQL客户端和服务器配置

      4. 用户权限管理

      5. DDL创建数据库和表

      6. 约束与外键

      7. DML实现添加、修改、删除数据

      8. 聚合函数、日期函数等

      9. DQL简单查询

      10. 排序、分组、筛选

      11. 多表查询

      12. 子查询

      13. in和exists关键字

      14. 分页查询

      15. Mysql SQL语句优化介绍

    6. 6

      第五部分:JDBC连接池

      1. JDBC概述

      2. JDBC使用步骤

      3. Connection、Statement、ResultSet接口

      4. 使用JDBC 完成数据库DML操作

      5. PreparedStatement对象

      6. 大数据的操作

      7. 批量处理与元数据

      8. 事务处理

      9. 隔离级别

      10. 自定义连接池

      11. DBCP、C3p0连接池

      12. DBUtis工具类

      13. QueryRunner

      14. 自定义结果集处理

      15. 连接池知识总结

    7. 7

      第六部分:Servlet

      1. Tomcat与Eclipse的集成开发

      2. 什么是Servlet

      3. Servlet的进化史

      4. Servlet的优化过程

      5. Servlet中应用的多线程概念

      6. Servlet接收客户端请求信息

      7. Servlet响应客户端信息

      8. Servlet的生命周期

      9. 重定向写法

      10. 转发写法

      11. 转发和重定向区别

      12. HttpServletRequest获取中文乱码问题

      13. HttpServletResponse响应中文乱码问题

      14. Servlet路径映射问题

      15. Servlet多路径映射

    8. 8

      第七部分:JSP

      1. 什么是JSP

      2. JSP的内置对象

      3. 透析JSP的本质

      4. JSTL+EL

      5. MVC介绍

      6. 分层的重要性

      7. Web工程中事务实现

      8. Session的使用

      9. Cookie的使用

      10. web工程中连接池的使用

      11. 实现用户的自动登录

      12. 文件的上传、下载

      13. 过滤器、 监听器

      14. 反射、注解、泛型

      15. 综合案例练习

    9. 9

      第八部分:AJAX

      1. Ajax技术背景

      2. Ajax技术的理解

      3. XMLHttpRequest使用步骤

      4. XMLHttpRequest GET/POST的区别

      5. 同步请求&异步请求

      6. 同步请求&异步请求的区别

      7. Ajax获取不同的返回值类型

      8. Ajax使用原生JavaScript和Jquery的区别

      9. Ajax响应状态处理

      10. JSON语法

      11. Java JSON 解析

      12. Java JSON 生成

      13. Java JSON 第三方工具快速解析

      14. JavaScript JSON转换

      15. Jquery JSON转换

      END

    Java框架课程

    1. 1

      Java框架课程内容涉及:Spring、Spring MVC、MyBatis、SVN、Git、Maven、SpringBoot

    2. 2

      第一部分:Spring

      1. 框架原理介绍

      2. 框架环境搭建

      3. 快速入门

      4. 创建Bean的方式及实现原理

      5. Bean种类

      6. Bean生命周期

      7. Bean的作用域

      8. Bean的注值方式

      9. 整合Junit测试

      10. 注解装配Bean

      11. 注解装配Bean

      12. AOP思想、原理解剖

      13. AOP底层JDK动态代理

      14.AOP编程

      15. AspectJ介绍及实现AOP开发

      16.事务

      17. Web项目集成Spring

    3. 3

      第二部分:Spring MVC

      1. Spring MVC 概述

      2. 使用 @RequestMapping映射请求

      3. 请求处理方法签名概述

      4. 处理方法签名详细说明

      5. 使用 HttpMessageConverter

      6. 处理模型数据

      7. 数据绑定流程剖析

      8. 数据格式化

      9. 数据校验

      10. 视图和视图解析器

      11. 处理方法的数据绑定

      12. 视图和视图解析器

      13. 文件上传下载

      14. JSON处理

      15. 拦截器

    4.  

      第三部分:MyBatis

      1. MyBatis数据框架介绍

      2. MyBatis对比Hibernate框架

      3. MyBatis配置、查询数据

      4. MyBatis全局配置文件

      5. MyBatis全局配置文件元素详细介绍

      6. Mapper映射文件

      7. MyBatis两种开发方式

      8. MyBatis中别名配置

      9. MyBatis # 和 $ 拼接参数区别

      10. 关联查询,动态sql

      11. MyBatis缓存机制、整合ehcache

      12. MyBatis二级缓存处理

      13. MyBatis、Spring、SpringMVC整合

      14. 分页插件

      15. MyBatis逆向工程

       

    5. 第四部分:SVN   和git

      1. SVN简介

      2. SVN和Git对比

      3. SVN服务器搭建

      4. SVN创建仓库

      5. SVN创建用户以及分配权限

      6. SVN签出、提交、更新

      7. Eclipse整合svn插件

      8. Idea整合svn插件

      9. 使用SVN更新提交

      10. SVN仓库分析

      11. SVN协同修改&冲突解决

      12. SVN代码整合注意事项

      13. SVN权限管理

      14. SVN数据回滚

      15. TortoiseSVN

    6. 6

      第五部分:Maven

      1. Maven环境搭建

      2. Maven构建项目

      3. Maven本地仓库配置

      4. Maven中央仓库配置

      5. Maven基本概念

      6. Maven基本命令介绍

      7. Maven于Eclipse整合

      8. Maven于Idea整合

      9. Maven创建web工程

      10. pom.xml、依赖管理

      11. 坐标、依赖、生命周期等

      12. Eclipse下的Maven使用

      13. Maven中 继承、聚合

      14. Maven构建SSH/SSM应用

      15. 自动部署、持续集成、持续部署

    7. 第六部分

      项目开发

    Java企业级课程  javacto点taobao点com

     

    展开全文
  • java100天学习路线

    2020-12-29 10:33:24
    java学习路线详细
  • 各种各样的编程语言不断崛起,但唯有Java是牢牢占据着老大的位置,目前几乎90%以上的大中型互联网应用系统在服务器端开发首选Java。...所以,今天,千锋的老师就跟大家分享一份系统的Java学习路线...

    各种各样的编程语言不断崛起,但唯有Java是牢牢占据着老大的位置,目前几乎90%以上的大中型互联网应用系统在服务器端开发首选Java。因此,也是吸引了不少年轻人投入到Java的学习之中。

    但不得不说,Java作为老牌编程语言,学习起来还是需要系统才行的。不少小伙伴会通过在网络上找各种各样的学习视频去研究学习,却往往缺乏了系统全面的学习路线。所以,今天,千锋的老师就跟大家分享一份系统的Java学习路线图,零基础也可以无压力的走进Java,学习Java!

    c9b375f06cb8d7a2b0eb12cb7d6d2f56.png

    第一阶段、Java基础

    JavaEE的学习内容从Java开发介绍开始,为你入门编程语言扫盲,什么是程序,如何配置Java开发环境,Java编程的过程是怎样的,Java有什么物特点,程序是如何运行的,这些你都可以在这里得到答案。接下来是介绍Java编程的基础语法,共分为10个知识点,我们将学习变量,基本数据类型,进制,转义字符,运算符,分支语句和循环语句等,以达到训练基础语法和逻辑能力的目的。还有对数组、面向对象和异常处理等。

    第二阶段、JavaWeb的学习

    Web前端开发基础和框架、Servlet和JSP在Web后端的应用、Web后端开发相关专题、MVC和分层架构以及项目开发流程及CASE工具的使用等。

    第三阶段、 Java框架

    框架是程序中另一种存储数据的方式,比直接使用数组来存储更加的灵活,在项目中应用十分广泛。同时,框架整合开发(SSH/SSS)、RESTful架构和移动端接口设计、第三方接口和在线支付功能、网站安全和Spring Security应用实战、复杂用户交互处理和Spring Web Flow的应用、MyBatis的应用和SSM整合,我们将深入研究其中涉及到的数据结构和算法,对学员的技术深度有了一个质的提升。

    第四阶段、Java+云数据

    亿级并发架构演进、Linux基础、搭建tomcat环境以及大数据开发云计算等高级Java教程,是Java技术的高端知识。其中穿插项目实战演练,企业真实项目供学员应用学习,进行知识体系的“二次学习”。

    到底要怎么入门去学习好Java呢?在看过上面的千锋Java培训老师分享的学习路线图之后,相信大家更有一个直观的了解,不是懵懵懂懂不知从何入手!

    展开全文
  • 详细Java学习路线

    2020-10-03 23:16:42
    Java 资源链接 ...博主参考的Java学习路线链接:https://blog.csdn.net/adam8813/article/details/88363139 图解 博主找到的比较好的Java系统学习图解(附带水印...别再抱怨自己的Java学习路线不清晰不敢向前了,我们本来
  • JAVA学习路线

    2020-03-11 10:59:15
    2020年Java学习路线汇总 2020最新零基础java学习路线图...Java学习路线(完整详细版) 2020年新版Java学习路线图(内含大纲+视频+工具+书籍+面试)-黑马程序员技术交流社区 JAVA学习路线图 2020Java系列学习路线图 ...
  • 这是我最开始学习Java时,在博客中找到的大佬整理出来的Java学习路线图,路线图中可以看出学习Java需要达到的30个目标,在学习之初对Java有一个整体的认识,会让你有学习的方向,起到事半功倍的效果,希望能够对你
  • Java教程,Java学习路线图(全网最详细)Java教程,Java学习路线图(全网最详细) - CSDN博客​blog.csdn.net写给自己的Java程序员学习路线图史上最强Java学习路线(详解)​www.360doc.comJava 学习线路图是怎样的...
  • JAVA学习路线(最全)

    千次阅读 多人点赞 2019-03-09 16:10:37
    JAVA学习路线 详细介绍
  • 推荐教程:1、MySQL数据库https://www.bilibili.com/video/BV1fx411X7BD2、JDBChttps://www.bilibili.com/video/BV1Bt41137iB3、Oracle(有兴趣的可以学习一下)https://www.bilibili.com/video/BV1kx411s71nWeb前端...
  • Java学习路线,Android学习路线,Java全套路线视频下载连接,这一整套的当前最新最权威的java学习视频,从javase到javaee到3G全部学完需要半年,非常详细的视频
  • java学习路线目录全套尚硅谷跟黑马视频笔记混搭 备用参考文档 备用java学习全套参考博客 也比较详细 尚硅谷周扬的博客 主要参考redis笔记 尚硅谷周扬的msyql高级部分 mysql主从复制深入详解 源码参考文档 个人觉得...
  • java学习路线

    2018-03-26 18:56:21
    java学习路线图,有详细的java基础学习路线,javaweb,以及框架和实战演练
  • 一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...
  • java学习路线汇总
  • Java学习路线

    2018-12-29 23:03:05
    详细介绍学习Java的路线,让你清晰掌握Java学习路径。
  • java详细路线:网上有很多学习路线,当初,我就是受这个学习路线的影响入坑的。既然看到标题为我的java学习路,那就给大家看下我是怎么走过来的。阶段一_JavaSE入门推荐书:java开发实战经典,对,没看错,就是你们...
  • Java学习路线图(完整详细2020版)

    万次阅读 多人点赞 2019-03-25 09:50:13
    一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...
  • 科技在进步,时代也在发展,很多人的理想再也不是骑马喝酒走四方,而是学习掌握java技术,真正的实现高薪就业,说到学习Java,我们今天就来说说Java开发需要学习的内容,说说java学习路线,说说Java学习的课程内容。...
  • java学习路线

    2021-02-02 17:58:43
    java详细学习路线及路线图 置顶 钟长森 2020-03-29 12:22:42 ...
  • 针对本书,java学习可以大致分为3个阶段。初级阶段:学习Java基础语法和类的创建与使用,基础I/0 (输入/输出)操作、各种循环控制、运算符、数组的定义、方法定义格式、方法重载等,并熟练使用一种集成开发工具(如...
  • Java学习路线

    2020-11-11 21:12:57
    本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢? 路线 Java发展到现在,按应用来分主要分为三大...
  • Java学习详细路线

    2011-04-22 21:32:25
    Java学习路线图。路线图从“0基础入门”——>“JAVA就业”,基本涵盖了JavaEE体系中所有常用、流行技术。

空空如也

空空如也

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

java学习路线详细

java 订阅