首页 文章 精选 留言 我的

精选列表

搜索[techo day],共2890篇文章
优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 8)——小小常量、变量大作用

计算机语言学习中都有常量和变量,他们几乎是我编写代码的灵魂了,离开他们我真的是“活不了” 常量是标识符的前面加上关键字let。常量其值在使用过程中不会发生变化的量,下面是声明常量: let_Hello = "Hello" 注意哦常量只能在初始化的时候被赋值,如果再次给_Hello赋值, 比如:_Hello = "Hello, World" 程序会报错的 变量来了 变量是在标识符的前面加上关键字var,声明变量啦: var scoreForStudent = 0.0 声明Double类型scoreForStudent变量,并且初始化为0.0。 如果在一个语句中声明和初始化了多个变量,那么所有的变量都具有相同的数据类型: var x = 10, y = 20 在多个变量的声明中,也能指定不同的数据类型哦: var x = 10, y = true 其中x为整型,y为布尔型。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746081,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 30)——选择类还是结构体呢?

类和结构体非常相似,很多情况下没有区别。如果你是设计人员在进行系统设计时候,是将某种类型设计成为类还是结构体? 类和结构体异同: 类和结构体都有如下功能: 定义存储属性 定义方法 定义下标 定义构造函数 定义扩展 实现协议 只有类才有的功能: 能够继承另外一个类 能够核对运行期对象的类型 析构对象释放资源 引用计数允许一个实例有多个引用 选择的原则: 结构体是值类型,每一个实例没有独一无二的标识,下面两个数组实例本质上没有区别,他们可以互相替换。 1 2 varstudentList1:[String]=[ "张三" , "李四" , "王五" ] varstudentList2:[String]=[ "张三" , "李四" , "王五" ] 但是我们提到类时候,它是引用类型,每个实例都有独一无二的标识。我们看看下面员工Employee类代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Employee{ varno= 0 varname= "" varjob= "" varsalary= 0.0 } varemp1=Employee() emp1.no= 100 emp1.name= "Tom" emp1.job= "SALES" emp1.salary= 9000 varemp2=Employee() emp2.no= 100 emp2.name= "Tom" emp2.job= "SALES" emp2.salary= 9000 emp1和emp2两个员工实例即便内容完全相同,但是这不能说明他们就是同一个员工,只是相似而已。每一个员工实例的背后都有独一无二的标识。 我们再来看看部门Department结构体。 1 2 3 4 5 6 7 8 9 10 11 12 structDepartment{ varno:Int= 0 varname:String= "" } vardept1=Department() dept1.no= 20 dept1.name= "Research" vardept2=Department() dept2.no= 20 dept2.name= "Research" Department为什么被设计成为结构体而不是类呢,那要看我们对于两个不同部门的理解是什么,如果具有相同的部门编号(no)和部门名称(name),我们就认为他们是两个相同的部门,那么就可以把Department定义为结构体,这一点与员工Employee不同。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746591,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 12)——说几个特殊运算符

除了一些常用的运算符,还有一些其他的: 引用号(.):实例调用属性、方法等操作符。 问号(?):用来声明可选类型。 感叹号(!):对可选类型值进行强制拆封。 箭头(->):说明函数或方法返回值类型。 冒号运算符(:):用于字典集合分割“键值”对。 …… 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746098,如需转载请自行联系原作者

优秀的个人博客,低调大师

DockerCon 2017 Day2: 安全、生态、敏捷-Docker企业应用的全方位升级

如往年的DockerCon一样,第一天的重点在Docker技术上的布局,无论是LinuxKit还是新的Moby项目。而第二天则会由Docker的CEO Ben介绍Docker的商业拓展和企业级市场。 如果说去年的Docker在企业生产环境可用只是一个开始,而今年Docker则憋了一个大招,展示了大量企业安全特性和成功客户故事。我们看本次DockerCon如何回答大家对企业市场的安全和稳定性的问题: 1.Docker在什么场景可用?我是传统系统,没有微服务,不是Cloud Native,能用Docker吗?Docker宣布了一个MTA项目(Modernize Traditional Applications )来帮助企业让原有的遗留系统更安全、有效和可迁移性。并携手Avanade 、CISCO、HPE和微软等合作伙伴,提供咨询和混合云方

优秀的个人博客,低调大师

Day1——2019 Intel MacBook Pro 32GB开发AI Agent:环境搭建实录

## **0. 起** --- 标题是Kimi帮我起的,我觉得有点复杂,但表述得还算清楚。 自己想做点东西。想来想去,准备做一个环保信息化助手的AI Agent。于是翻出了家里尘封的MacBook Pro,作为开发工具。 我让Kimi帮我评估这台老家伙还能不能顶得住。Kimi给予了肯定的答复,并贴心地附上了开发计划。 那么,开始吧。 --- ## **先看机器配置** --- 这是2019年买的一台MacBook Pro。当年作为主力开发本的,所以选配基本都是最高配。 **2.6GHz六核i7, 32GB内存, Intel UHD Graphics 630** 让Kimi给我评估并给出的建议: |**模型**|**量化格式**|**内存占用**|**本地推理速度**|**是否推荐**| | --- | --- | --- | --- | --- | |**Qwen3 8B**|q4_0|~4.5GB|8-12 token/s|✅ 主力开发模型| |**Qwen3 14B**|q4_0|~8GB|5-8 token/s|✅ 可做对比测试| |**Qwen3 32B**|q4_0|~18GB|2-4 token/s|⚠️ 能跑但慢,仅测试用| |**Llama 3.1 8B**|q4_0|~4.5GB|8-12 token/s|✅ 备选| |**nomic-embed-text**|默认|~700MB|极快|✅ 嵌入专用| |**MiniMax H3**|任何|不支持|不支持|❌ 纯CPU跑不了视频生成| **32GB内存下的并发能力:** 同时运行: - Ollama Qwen3 8B: 4.5GB - Ollama nomic-embed: 0.7GB - Chroma向量库: 1.5GB - FastAPI后端: 0.5GB - React dev server: 0.5GB - VS Code: 1.0GB - Chrome(10标签): 3.0GB - macOS系统: 4.0GB 总计: ~16GB 剩余可用: ~16GB ← 非常充裕 --- ## **第一步:环境检查** --- 看看这台老机器环境配置情况如何。下面是让Kimi给我写的检查脚本。 ```javascript cat > ~/check_env.sh /dev/null && check_pass "Homebrew $(brew --version | head -1)" || check_fail "Homebrew未安装" git --version > /dev/null 2>&1 && check_pass "Git $(git --version | cut -d' ' -f3)" || check_fail "Git未安装" python3 --version > /dev/null 2>&1 && check_pass "Python $(python3 --version | cut -d' ' -f2)" || check_fail "Python未安装" node --version > /dev/null 2>&1 && check_pass "Node.js $(node --version)" || check_fail "Node.js未安装" echo "" echo "【3/6】Docker(Week 4需要)" docker --version > /dev/null 2>&1 && check_pass "Docker $(docker --version | cut -d' ' -f3 | sed 's/,//')" || check_warn "Docker未安装(可稍后安装)" echo "" echo "【4/6】AI/ML工具" which ollama > /dev/null && check_pass "Ollama $(ollama --version | head -1)" || check_fail "Ollama未安装" if which ollama > /dev/null; then MODEL_COUNT=$(ollama list 2>/dev/null | wc -l) if [ "$MODEL_COUNT" -gt 1 ]; then check_pass "已下载模型: $(ollama list 2>/dev/null | tail -n +2 | awk '{print $1}' | tr '\n' ' ')" else check_warn "Ollama已安装但未下载模型" fi curl -s http://localhost:11434/api/tags > /dev/null && check_pass "Ollama服务运行中" || check_warn "Ollama服务未启动(运行: ollama serve)" fi echo "" echo "【5/6】Python AI库" python3 -c "import langchain" 2>/dev/null && check_pass "LangChain" || check_fail "LangChain未安装 (pip install langchain)" python3 -c "import chromadb" 2>/dev/null && check_pass "ChromaDB" || check_fail "ChromaDB未安装 (pip install chromadb)" python3 -c "import openai" 2>/dev/null && check_pass "OpenAI SDK" || check_fail "OpenAI SDK未安装 (pip install openai)" echo "" echo "【6/6】API连通性" ping -c 1 -W 3 api.moonshot.cn > /dev/null 2>&1 && check_pass "Kimi API可连通" || check_warn "Kimi API连通性异常" echo "" echo "╔════════════════════════════════════════════════════╗" echo "║ 检查完成 ║" echo "╚════════════════════════════════════════════════════╝" echo "" echo "📋 修复命令速查:" echo " 安装Homebrew: /bin/bash -c "\$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"" echo " 安装Ollama: curl -fsSL https://ollama.com/install.sh | sh" echo " 安装Docker: brew install --cask docker" echo " 安装Python库: pip install langchain chromadb openai fastapi uvicorn" echo " 拉取模型: ollama pull qwen3:8b && ollama pull nomic-embed-text" EOF chmod +x ~/check_env.sh ~/check_env.sh ``` 环境评分: |**检查项**|**状态**|**影响**| | --- | --- | --- | |macOS 15.7.9|✅|最新系统,无兼容问题| |32GB内存|✅|充裕,可并发跑多个服务| |32GB磁盘|⚠️|够用但紧张,需管理模型大小| |Python 3.13.7|⚠️|较新,可能遇到库兼容问题| |Homebrew/Git|✅|最新版本| |Docker 20.10.8|✅|旧但够用,Week 4再升级| |Kimi API连通|✅|国内API无阻碍| |Node.js|❌|待安装| |Ollama|❌|待安装| |Python AI库|❌|待安装| 底子不错,但需要修复4项。 --- ## **第二步:Python 3.11降级** --- 这是今晚踩的第一个坑。 系统自带Python 3.13.7,装`sentence-transformers`时torch直接报冲突:`ResolutionImpossible`。原因是Python 3.13太新,PyTorch还没有官方支持。 解决路径:降级到Python 3.11。 ```javascript # 退出当前venv deactivate # 删除旧venv(里面3.13的库全清掉) rm -rf ~/EcoEnforcer/venv # 用Homebrew安装Python 3.11 brew install python@3.11 # 验证 which python3.11 # /usr/local/bin/python3.11 python3.11 --version # Python 3.11.10 # 创建新venv /usr/local/bin/python3.11 -m venv ~/EcoEnforcer/venv source ~/EcoEnforcer/venv/bin/activate # 验证 which python3 # /Users/gaoxueting/EcoEnforcer/venv/bin/python3 python3 --version # Python 3.11.10 ``` --- ## **第三步:安装核心Python库** --- 在venv里分批安装,便于定位问题。 ```javascript # 升级pip pip install --upgrade pip # 批次1:基础Web框架 pip install fastapi uvicorn python-dotenv pydantic requests # 批次2:RAG和向量库(3.11下torch不冲突了) pip install langchain langchain-community chromadb sentence-transformers # 批次3:AI SDK和文档解析 # 注意:unstructured和autogen编译需要Xcode Command Line Tools # 先装能装的 pip install openai beautifulsoup4 pypdf # 开发工具 pip install pytest black isort ``` --- ## **第四步:安装Ollama + 拉取模型** --- ```javascript # 一键安装Ollama curl -fsSL https://ollama.com/install.sh | sh # 启动服务 ollama serve & # 拉取开发用模型 ollama pull qwen3:8b ollama pull nomic-embed-text # 验证 ollama list ``` 输出: ```javascript NAME ID SIZE MODIFIED nomic-embed-text:latest 0a109f422b47 274 MB 3 minutes ago qwen3:8b 500a1f067a9f 5.2 GB 5 minutes ago ``` --- ## **第五步:安装Node.js** --- **这是今晚踩的第二个坑。** ```javascript # 先尝试brew安装 brew install node@20 ``` 结果报错: ```javascript Warning: node@20 has been deprecated because it is not supported upstream! Warning: You are using macOS on Intel x86_64. We do not provide support for this platform... Error: No developer tools installed. ``` 两个暴击: 1. **Homebrew已宣布停止支持Intel Mac**(2026年9月起) 1. **Xcode Command Line Tools没装**,导致编译类库全挂 解决:直接浏览器下载Node.js官方pkg安装包。 安装完成后 ```javascript node --version # v20.17.0 ``` --- ## **踩的坑总结** --- ### **坑1:Python 3.13 torch冲突** **现象**:`pip install sentence-transformers`报`ResolutionImpossible`,torch没有匹配的分发版本。 **原因**:Python 3.13太新,PyTorch官方尚未发布3.13的wheel。 **解决**:降级到Python 3.11,重新创建venv,全部库一次装通。 **耗时**:约20分钟。 ### **坑2:Intel Mac Homebrew停止支持** **现象**:`brew install node@20`报错,提示Intel x86_64平台不再支持。 **原因**:Homebrew 2026年9月起停止支持Intel Mac,Node 20同时被弃用。 **解决**:绕过brew,直接下载官方pkg安装Node.js。 **耗时**:约5分钟(下载+安装)。 ### **坑3:Xcode Command Line Tools缺失** **现象**:`numba`、`llvmlite`、`autogen`等需要编译的库全部失败。 **原因**:系统没有安装Xcode CLI,缺少C编译器。 **解决**:`xcode-select --install`,后台下载安装(约15分钟)。装完后可以补装`pyautogen`。 **耗时**:15分钟(后台)。 ### **坑4:NumPy 2.x兼容性警告** **现象**:`import sentence_transformers`时提示NumPy 2.4.6与torch 2.2.2不兼容。 **原因**:sentence-transformers依赖的torch版本较旧,与NumPy 2.x API不兼容。 **解决**:项目里嵌入模型改用Ollama的`nomic-embed-text`,不依赖sentence-transformers。如需修复,降级NumPy即可:`pip install "numpy<2" --force-reinstall`。 **影响**:不影响项目运行,属于”噪音”。 --- ## **最终环境状态** --- 运行验证脚本: ```javascript python ~/EcoEnforcer/verify_env.py ``` 输出: ```javascript === EcoEnforcer 环境验证 === Python版本: 3.11.10 (main, Nov 25 2024, 03:36:47) [Clang 12.0.5] ✅ FastAPI ✅ LangChain ✅ ChromaDB ✅ OpenAI SDK ⚠ SentenceTransformers (NumPy 2.x警告,项目不依赖此项) === Ollama模型 === ✅ nomic-embed-text:latest 0a109f422b47 274 MB 25 minutes ago ✅ qwen3:8b 500a1f067a9f 5.2 GB 26 minutes ago ✅ 环境检查完成 ``` --- ## **下一步:开始EcoEnforcer项目** --- 环境就绪,今晚的核心产出达成。 明天开始: 1. 创建EcoEnforcer项目骨架(backend/frontend/data目录结构) 1. 初始化GitHub仓库,写好README 1. 加载第一批环保法规文档到Chroma,跑通基础RAG链路 双轨模型策略已确定: - **开发阶段**:本地Qwen3 8B + nomic-embed-text,零API费用 - **演示阶段**:云端Kimi 128K + GPT-4o,效果最佳 一个月API费用预估:约250元(主要用在演示和面试准备)。 --- ## **附录:快速修复命令速查** --- ```javascript # 安装Python 3.11 brew install python@3.11 # 创建venv /usr/local/bin/python3.11 -m venv ~/EcoEnforcer/venv source ~/EcoEnforcer/venv/bin/activate # 安装核心库 pip install fastapi uvicorn langchain chromadb openai # 安装Ollama curl -fsSL https://ollama.com/install.sh | sh ollama pull qwen3:8b ollama pull nomic-embed-text # 安装Node.js(Intel Mac推荐直接下载pkg) # https://nodejs.org/dist/v20.17.0/node-v20.17.0.pkg ``` --- *写于2026年9月4日。老Mac的第一篇开发日记。*

优秀的个人博客,低调大师

Every Day of a DBA,第153期: Oracle 19c Active Data Guard-DML Redirection

## **1. 功能概述** Active Data Guard DML 重定向 是 Oracle 19c 引入的一项重要新特性,允许在 物理备库(Physical Standby) 上直接执行 DML 操作(INSERT、UPDATE、DELETE)。当用户在备库上发起 DML 时,操作会被 透明地重定向 到主库执行,产生的 Redo 日志再传回备库应用,最终将结果返回给客户端。 > 此特性使得备库不再仅限于只读查询,而是可以承载 "偶尔写入" 的混合工作负载,真正实现 Read-Mostly 架构。 ### **适用场景** - 备库上运行的只读应用程序偶尔需要执行少量 DML(如更新状态、插入日志) - 希望减轻主库上大量只读会话的并发压力 - 应用代码无法修改连接字符串,但需要备库具备有限写入能力 - 报表系统需要在查询中间结果时写入临时标记 ## **2. 工作原理** ``` ┌─────────────────────────────────────────────────────────────┐ │ 应用层(客户端) │ │ 连接备库,发出 DML 语句(INSERT/UPDATE/DELETE) │ └──────────────────────┬──────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Active Data Guard 备库 │ │ │ │ ① 接收 DML 请求 │ │ ② 自动检测是否为 DML 操作 │ │ ③ 将 DML 重定向到主库(透明,应用无感知) │ │ ④ 等待主库执行完毕并传回 Redo │ │ ⑤ Redo 应用后,返回结果给客户端 │ └──────────────────────┬──────────────────────────────────────┘ │ 重定向 (ADG_REDIRECT_DML) ▼ ┌─────────────────────────────────────────────────────────────┐ │ 主库(Primary) │ │ │ │ ① 接收来自备库的重定向 DML │ │ ② 在本地执行 DML 操作 │ │ ③ 生成 Redo 日志 │ │ ④ 按 Data Guard 同步策略传送到备库 │ └─────────────────────────────────────────────────────────────┘ ``` ### **详细流程** |步骤|说明| | --- | --- | |1|客户端连接到备库,发起 DML 语句(INSERT / UPDATE / DELETE)| |2|备库检测到 DML 操作,通过 ADG_REDIRECT_DML 机制将其 透明重定向 到主库| |3|主库执行该 DML,生成 Redo 日志,提交事务| |4|主库将 Redo 传输到备库,MRP(Managed Recovery Process)应用 Redo| |5|备库应用变更后,返回成功结果给客户端,DML 会话期间保持读一致性| ### **关键特性** - 透明性:应用无需修改代码或连接字符串 - 读一致性:DML 会话中的未提交更改,在该会话内可查询到(其他会话需等待提交后) - 等待语义:备库会话会 同步等待 直到数据变更被传回并应用到备库后才返回 - ACID 保障:事务的原子性、一致性、隔离性、持久性完全保持 ## **3. 核心优势** |优势|说明| | --- | --- | |🔄 Read-Mostly 负载分担|备库可同时处理只读查询和偶发写入,分担主库压力| |⚡ 减少主库压力|大量的 SELECT 查询转移到备库,主库专注处理写入| |🔌 无需修改应用|备库 DML 对应用完全透明,连接字符串无需变更| |✅ 完整 ACID 保障|事务特性完全保留,数据一致性有保障| |🛡️ 高可用增强|备库在容灾之外获得更多实用价值| ## **4. 前提条件** 在启用 DML 重定向之前,必须满足以下条件: ### **4.1 环境要求** |条件|要求| | --- | --- | |Oracle 版本|19c 或更高版本(19.0.0.0.0 及以上)| |Data Guard 配置|已配置 Data Guard Broker(建议)| |备库状态|物理备库,处于 READ ONLY WITH APPLY 模式| |网络连接|主库和备库之间网络通畅,连接字符串可用| ### **4.2 限制说明** > ⚠️ 重要限制 - SYS 用户不支持:SYS 用户连接备库时无法使用 DML 重定向 - Oracle XA 事务不支持:分布式 XA 事务中的 DML 无法重定向 - 重定向量建议 参数 `ADG_REDIRECT_DML` 默认值为 `FALSE`。需要在 主库和备库两端 都设置为 `TRUE`。 ### **5.1 主库配置** ``` SQL>show parameter adg_redirect_dml NAME TYPE VALUE ———————————— ———– —————————— adg_redirect_dml boolean FALSE SQL>altersystemset adg_redirect_dml=true scope=both; System altered. SQL>show parameter adg_redirect_dml NAME TYPE VALUE ———————————— ———– —————————— adg_redirect_dml boolean TRUE ``` ### **5.2 备库配置** ``` SQL>show parameter adg_redirect_dml NAME TYPE VALUE ———————————— ———– —————————— adg_redirect_dml boolean FALSE SQL>altersystemset adg_redirect_dml=true scope=both; System altered. SQL>show parameter adg_redirect_dml NAME TYPE VALUE ———————————— ———– —————————— adg_redirect_dml boolean TRUE ``` ### **5.3 会话级别控制(可选)** 若仅需单个会话启用,而非全局启用: ``` -- 在当前会话启用 DML 重定向(会覆盖系统级设置) ALTERSESSIONENABLE ADG_REDIRECT_DML; -- 在当前会话禁用 DML 重定向 ALTERSESSIONDISABLE ADG_REDIRECT_DML; ``` 优先级:会话级设置 > 系统级设置 ## **6. 功能测试** ### **6.1 在主库创建测试表** ``` -- 连接主库(用户名/密码方式) sqlplus sys/oracle@primaryas sysdba -- 创建测试表 CREATETABLE oracle_dml_test ( name VARCHAR2(50), testdate TIMESTAMP ); -- 插入测试数据 INSERTINTO oracle_dml_test VALUES('主库写入测试', SYSDATE); INSERTINTO oracle_dml_test VALUES('初始数据', SYSDATE); COMMIT; -- 验证 SELECT*FROM oracle_dml_test; ``` ### **6.2 在备库验证数据已同步** ``` -- 连接备库(必须使用用户名/密码方式,不可用 / as sysdba) sqlplus sys/oracle@standbyas sysdba -- 查看主库创建的表和数据是否已同步(可能在备库需要完全路径或等待 apply 延迟) SELECT*FROM oracle_dml_test; -- 确认备库状态 SELECT DATABASE_ROLE, OPEN_MODE FROM V$DATABASE; SELECTSTATUS, INSTANCE_NAME, DATABASE_ROLE, PROTECTION_MODE FROM V$DATABASE, V$INSTANCE; ``` 预期输出: ``` DATABASE_ROLE OPEN_MODE -------------------- -------------------- PHYSICAL STANDBY READ ONLY WITH APPLY ``` ### **6.3 在备库执行 DML 重定向测试** ``` -- 连接备库(用户名/密码,非 SYS 用户优先) sqlplus test_user/test_pass@standby -- 在备库执行 DELETE 操作(将会被透明重定向到主库) DELETEFROM oracle_dml_test WHERE name ='初始数据'; -- 显示受影响行数 -- 输出: 1 row deleted. -- 提交事务 COMMIT; -- 再次查询,确认读一致性 SELECT*FROM oracle_dml_test; ``` ### **6.4 在主库验证变更已生效** ``` -- 连接主库 sqlplus sys/oracle@primaryas sysdba -- 验证数据已从备库删除 SELECT*FROM oracle_dml_test; -- 预期:'初始数据' 行已不存在,DML 重定向成功 ``` ## **7. 高级测试场景** ### **7.1 PL/SQL 块中的 DML 重定向** 备库上的 PL/SQL 块中包含的 DML 同样会被重定向: ``` -- 在备库执行 BEGIN INSERTINTO oracle_dml_test VALUES('PL/SQL 插入测试', SYSDATE); UPDATE oracle_dml_test SET name ='PL/SQL 已更新'WHERE name ='PL/SQL 插入测试'; COMMIT; END; / ``` ### **7.2 事务一致性验证** ``` -- 备库:插入后未提交,本会话可看到 INSERTINTO oracle_dml_test VALUES('未提交数据', SYSDATE); SELECT*FROM oracle_dml_test; -- 可以看到新行 -- 另开一个备库会话(同一事务未提交前),看不到新行 ``` ### **7.3 多表联合 DML** ``` -- 备库执行多表操作 INSERTINTO oracle_dml_test VALUES('多表测试A', SYSDATE); UPDATE oracle_dml_test SET testdate = SYSDATE WHERE name LIKE'多表%'; DELETEFROM oracle_dml_test WHERE name ='多表测试A'; COMMIT; ``` ## **8. 监控与诊断** ### **8.1 查看 DML 重定向状态** ``` -- 当前会话是否启用 DML 重定向 SELECT SYS_CONTEXT('USERENV','ADG_REDIRECT_DML')AS adg_redirect_enabled FROMDUAL; ``` ### **8.2 查询重定向相关的等待事件** ``` -- 查看 DML 重定向相关等待事件 SELECTevent, total_waits, time_waited, average_waitFROM V$SYSTEM_EVENTWHERE eventLIKE'%ADG%'OReventLIKE'%redirect%'; ``` ### **8.3 重定向错误诊断** 常见错误代码: |错误码|说明|解决方案| | --- | --- | --- | |ORA-16397|从备库到主库的语句重定向失败|检查主库连通性和 ADG_REDIRECT_DML 参数| |ORA-00604|递归 SQL 级别 1 发生错误|通常因使用 / as sysdba 连接导致,改用用户名/密码| |ORA-16000|备库上不支持的操作|确认操作类型为 DML(非 DDL)| ## **9. 最佳实践与注意事项** ### **✅ 最佳实践** |实践|说明| | --- | --- | |控制重定向占比 < 10%|备库 DML 最终在主库执行,过多 DML 会冲击主库性能| |使用非 SYS 用户|创建专用应用用户执行备库 DML,避免 SYS 限制| |监控主库负载|关注主库的 DB TIME 和 Redo 生成速率| |设置合理的网络延迟阈值|重定向对网络延迟敏感,建议主备之间延迟 < 5ms| |优先使用会话级别启用|默认关闭,仅对需要的会话启用,减少意外 DML 风险| |测试环境中充分验证|上线前模拟备库 DML 压力,确认主库可承受| ### **❌ 注意事项** 1. DDL 不会重定向 — 表结构变更仍需在主库执行 1. 序列(Sequence)不重定向 — 在备库访问序列需在主库预先处理 1. 临时表 — 全局临时表在备库行为可能不同,需仔细测试 1. 主备延迟影响 — 如果主备之间有较大 Redo 应用延迟,DML 操作等待时间会增加 1. Data Guard Broker — 建议使用 Broker 管理,Broker 故障切换后参数会自动同步 1. 版本兼容性 — 主备库必须同为 19c,且版本补丁级别一致 ## **10. 故障排除** ### **问题 1:ORA-16397 错误** ``` ORA-16397: statement redirection from Oracle Active Data Guard standby database to primary database failed ``` 排查步骤: 1. 检查主库和备库的 `ADG_REDIRECT_DML` 参数是否都为 `TRUE` 1. 确认备库处于 `READ ONLY WITH APPLY` 模式 1. 测试主备之间数据库连接是否正常 1. 确认未使用 `/ as sysdba` 连接备库 ### **问题 2:备库 DML 无反应** ``` -- 检查备库是否启用了 DML 重定向 ALTERSESSIONENABLE ADG_REDIRECT_DML; -- 检查连接方式 SELECT SYS_CONTEXT('USERENV','AUTHENTICATION_METHOD')FROMDUAL; -- 应返回非 SYSDBA 认证方式 ``` ### **问题 3:DML 性能缓慢** - 检查主备之间的 网络延迟 和 带宽 - 检查备库的 Redo Apply 速率 - 使用 `V$ADG_STATS` 视图诊断同步延迟 ``` -- 查看 ADG 同步状态 SELECT NAME,VALUE, TIME_COMPUTED, DATUM_TIME FROM V$ADG_STATS WHERE NAME LIKE'%lag%'; ```

优秀的个人博客,低调大师

【Java入门提高篇】Day25 史上最详细的HashMap红黑树解析

当当当当当当当,好久不见,最近又是换工作,又是换房子,忙的不可开交,断更了一小段时间,最重要的一篇迟迟出不来,每次都犹抱琵琶半遮面,想要把它用通俗易懂的方式进行说明,确实有一定的难度,可愁煞我也,但自己挖的坑,哭着也要把它补上。请允许我当一回标题党。 好了,言归正传,本篇主要内容便是介绍HashMap的男二号——TreeNode(男一号还是给Node吧,毕竟是TreeNode的爷爷,而且普通节点一般来说也比TreeNode要多),本篇主要从以下几个方面介绍: 1.红黑树介绍 2.TreeNode结构 3.树化的过程 4.红黑树的左旋和右旋 5.TreeNode的左旋和右旋 6.红黑树的插入 7.TreeNode的插入 8.红黑树的删除 9.TreeNode的删除 讲解红黑树的部分算是理论部分,讲解TreeNode的部分则是代码实践部分,配合服用效果更加。 保守估计,仔细食用本篇大约需要半小时,请各位细细品尝。 红黑树介绍 什么是红黑树?嗯,首先,它是一颗树,所谓的树,便是长的像这样的东西 不像树?emmmm,你把它想象成一颗倒过来的树就好了,A~H都是树的节点,每个节点有零个或者多个子节点,或者说多个孩子,但除了根节点以外,每个节点都只有一个父节点,也称只有一个父亲(老王嘿嘿一笑)。最上面的A是根节点,最下面的D、H、F、G是叶子节点。每一个非根节点有且只有一个父节点;树是具有一层一层的层次结构,这里A位于第一层,B、C位于第二层,依次类推。将左边的B节点部分(包括BDEH)拿出来,则又是一颗树,称为树的子树。 好了,知道树是什么东西了,那么红黑树是什么样的呢? 红黑树,本质上来说是一颗二叉搜索树。嗯,还是先说说这个二叉搜索树吧。二叉代表它的节点最多有两个子节点,而且左右有顺序,不能颠倒,分别叫左孩子和右孩子,这两个节点互为兄弟节点,嗯,其实叫法根现实里的叫法差不多,以下图为例,4、9互为兄弟,7是他们的父亲,9是2的叔叔,8是2的堂兄弟,很简单吧。说完了称谓,再来说说用途,既然叫做搜索树表示它的用途是为了更快的搜索和查找而设计的,所以这棵树本身满足一定的排序规则,即树中的任何节点的值大于它的左孩子,且小于它的右孩子。任意节点的左、右子树也分别为二叉查找树。嗯,结合下图意会一下: 而红黑树,就跟它的名字一样,又红又黑,红黑并进,理实交融,节点是非红即黑的,看起来就像这样: 红黑树的主要特性: (1)每个节点要么是黑色,要么是红色。(节点非黑即红) (2)根节点是黑色。 (3)每个叶子节点(NIL)是黑色。 (4)如果一个节点是红色的,则它的子节点必须是黑色的。(也就是说父子节点不能同时为红色) (5)从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。(这一点是平衡的关键) 说简单也简单,其实就是一颗比较平衡的又红又黑的二叉树嘛。 TreeNode结构 既然我们已经知道红黑树长什么样了,那么我们再来看看HashMap中的TreeNode代码里是如何表示的: /** * 用于Tree bins 的Entry。 扩展LinkedHashMap.Entry(进而扩展Node),因此可以用作常规节点或链接节点的扩展。 */ static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; // 红黑树父节点 TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; // 删除后需要取消链接 boolean red; TreeNode(int hash, K key, V val, Node<K,V> next) { super(hash, key, val, next); } //省略后续代码 TreeNode继承自LinkedHashMap中的内部类——LinkedHashMap.Entry,而这个内部类又继承自Node,所以算是Node的孙子辈了。我们再来看看它的几个属性,parent用来指向它的父节点,left指向左孩子,right指向右孩子,prev则指向前一个节点(原链表中的前一个节点),注意,这些字段跟Entry,Node中的字段一样,是使用默认访问权限的,所以子类可以直接使用父类的属性。 树化的过程 在前几篇中已经有所介绍,当HashMap桶中的元素个数超过一定数量时,就会树化,也就是将链表转化为红黑树的结构。 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { ...省略部分代码... else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); //当桶中元素个数超过阈值(8)时就进行树化 if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash); break; } ...省略部分代码... } final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); else if ((e = tab[index = (n - 1) & hash]) != null) { TreeNode<K,V> hd = null, tl = null; do { //将节点替换为TreeNode TreeNode<K,V> p = replacementTreeNode(e, null); if (tl == null) //hd指向头结点 hd = p; else { //这里其实是将单链表转化成了双向链表,tl是p的前驱,每次循环更新指向双链表的最后一个元素,用来和p相连,p是当前节点 p.prev = tl; tl.next = p; } tl = p; } while ((e = e.next) != null); if ((tab[index] = hd) != null) //将链表进行树化 hd.treeify(tab); } } 从代码中可以看到,在treeifyBin函数中,先将所有节点替换为TreeNode,然后再将单链表转为双链表,方便之后的遍历和移动操作。而最终的操作,实际上是调用TreeNode的方法treeify进行的。 final void treeify(Node<K,V>[] tab) { //树的根节点 TreeNode<K,V> root = null; //x是当前节点,next是后继 for (TreeNode<K,V> x = this, next; x != null; x = next) { next = (TreeNode<K,V>)x.next; x.left = x.right = null; //如果根节点为null,把当前节点设置为根节点 if (root == null) { x.parent = null; x.red = false; root = x; } else { K k = x.key; int h = x.hash; Class<?> kc = null; //这里循环遍历,进行二叉搜索树的插入 for (TreeNode<K,V> p = root;;) { //p指向遍历中的当前节点,x为待插入节点,k是x的key,h是x的hash值,ph是p的hash值,dir用来指示x节点与p的比较,-1表示比p小,1表示比p大,不存在相等情况,因为HashMap中是不存在两个key完全一致的情况。 int dir, ph; K pk = p.key; if ((ph = p.hash) > h) dir = -1; else if (ph < h) dir = 1; //如果hash值相等,那么判断k是否实现了comparable接口,如果实现了comparable接口就使用compareTo进行进行比较,如果仍旧相等或者没有实现comparable接口,则在tieBreakOrder中比较 else if ((kc == null && (kc = comparableClassFor(k)) == null) || (dir = compareComparables(kc, k, pk)) == 0) dir = tieBreakOrder(k, pk); TreeNode<K,V> xp = p; if ((p = (dir <= 0) ? p.left : p.right) == null) { x.parent = xp; if (dir <= 0) xp.left = x; else xp.right = x; //进行插入平衡处理 root = balanceInsertion(root, x); break; } } } } //确保给定节点是桶中的第一个元素 moveRootToFront(tab, root); } //这里不是为了整体排序,而是为了在插入中保持一致的顺序 static int tieBreakOrder(Object a, Object b) { int d; //用两者的类名进行比较,如果相同则使用对象默认的hashcode进行比较 if (a == null || b == null || (d = a.getClass().getName(). compareTo(b.getClass().getName())) == 0) d = (System.identityHashCode(a) <= System.identityHashCode(b) ? -1 : 1); return d; } 这里的逻辑其实不复杂,仅仅是循环遍历当前树,然后找到可以该节点可以插入的位置,依次和遍历节点比较,比它大则跟其右孩子比较,小则与其左孩子比较,依次遍历,直到找到左孩子或者右孩子为null的位置进行插入。 真正复杂一点的地方在于balanceInsertion函数,这个函数中,将红黑树进行插入平衡处理,保证插入节点后仍保持红黑树的性质。这个函数稍后在TreeNode的插入中进行介绍,这里先看看moveRootToFront,这个函数是将root节点移动到桶中的第一个元素,也就是链表的首节点,这样做是因为在判断桶中元素类型的时候会对链表进行遍历,将根节点移动到链表前端可以确保类型判断时不会出现错误。 /** * 把给定节点设为桶中的第一个元素 */ static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) { int n; if (root != null && tab != null && (n = tab.length) > 0) { int index = (n - 1) & root.hash; //first指向链表第一个节点 TreeNode<K,V> first = (TreeNode<K,V>)tab[index]; if (root != first) { //如果root不是第一个节点,则将root放到第一个首节点位置 Node<K,V> rn; tab[index] = root; TreeNode<K,V> rp = root.prev; if ((rn = root.next) != null) ((TreeNode<K,V>)rn).prev = rp; if (rp != null) rp.next = rn; if (first != null) first.prev = root; root.next = first; root.prev = null; } //这里是防御性编程,校验更改后的结构是否满足红黑树和双链表的特性 //因为HashMap并没有做并发安全处理,可能在并发场景中意外破坏了结构 assert checkInvariants(root); } } 红黑树的左旋和右旋 左旋和右旋,顾名思义嘛,就是将节点以某个节点为中心向左或者向右进行旋转操作以保持二叉树的平衡,让我们看图说话: 图画的有点大。将就着看一下吧,左旋相当于以要旋转的节点为中心,将子树整体向左旋转,该节点变成子树的根节点,原来的父节点A变成了左孩子,如果右孩子C有左孩子D,则将其变为A的右孩子。说起来好像有点绕,可以联系图进行形象化的理解,当节点A向左旋转之后,C的左孩子D可以理解为因为重力作用掉到A的右孩子位置,嗯,就是这样。右旋也是类似理解即可。 TreeNode的左旋和右旋 了解了左旋和右旋,让我们看看代码里是怎样实现的: /** * 左旋 */ static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root, TreeNode<K,V> p) { //这里的p即上图的A节点,r指向右孩子即C,rl指向右孩子的左孩子即D,pp为p的父节点 TreeNode<K,V> r, pp, rl; if (p != null && (r = p.right) != null) { if ((rl = p.right = r.left) != null) rl.parent = p; //将p的父节点的孩子节点指向r if ((pp = r.parent = p.parent) == null) (root = r).red = false; else if (pp.left == p) pp.left = r; else pp.right = r; //将p置为r的左节点 r.left = p; p.parent = r; } return root; } /** * 右旋 */ static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root, TreeNode<K,V> p) { //这里的p即上图的A节点,l指向左孩子即C,lr指向左孩子的右孩子即E,pp为p的父节点 TreeNode<K,V> l, pp, lr; if (p != null && (l = p.left) != null) { if ((lr = p.left = l.right) != null) lr.parent = p; if ((pp = l.parent = p.parent) == null) (root = l).red = false; else if (pp.right == p) pp.right = l; else pp.left = l; l.right = p; p.parent = l; } return root; } 其实,也很简单嘛。23333 红黑树的插入 现在来看看一个比较麻烦一点的操作,红黑树的插入,首先找到这个节点要插入的位置,即一层一层比较,大的放右边,小的放左边,直到找到为null的节点放入即可,但是如何在插入的过程保持红黑树的特性呢,想想好像比较头疼,但是再仔细想想其实就会发现,其实只有这么几种情况: 1.插入的为根节点,则直接把颜色改成黑色即可。 2.插入的节点的父节点是黑色节点,则不需要调整,因为插入的节点会初始化为红色节点,红色节点是不会影响树的平衡的。 3.插入的节点的祖父节点为null,即插入的节点的父节点是根节点,直接插入即可(因为根节点肯定是黑色)。 4.插入的节点父节点和祖父节点都存在,并且其父节点是祖父节点的左节点。这种情况稍微麻烦一点,又分两种子情况: i.插入节点的叔叔节点是红色,则将父亲节点和叔叔节点都改成黑色,然后祖父节点改成红色即可。 ii.插入节点的叔叔节点是黑色或不存在: a.若插入节点是其父节点的右孩子,则将其父节点左旋, b.若为左孩子,则将其父节点变成黑色节点,将其祖父节点变成红色节点,然后将其祖父节点右旋。 5.插入的节点父节点和祖父节点都存在,并且其父节点是祖父节点的右节点。这种情况跟上面是类似的,分两种子情况: i.插入节点的叔叔节点是红色,则将父亲节点和叔叔节点都改成黑色,然后祖父节点改成红色即可。 ii.插入节点的叔叔节点是黑色或不存在: a.若插入节点是其父节点的左孩子,则将其父节点右旋 b.若为右孩子,则将其父节点变成黑色节点,将其祖父节点变成红色节点,然后将其祖父节点左旋。 然后重复进行上述操作,直到变成1或2情况时则结束变换。说半天,可能还是云里雾里,一图胜千言,让我们从无到有构建一颗红黑树,假设插入的顺序为:10,5,9,3,6,7,19,32,24,17(数字是我拍脑袋瞎想的。) 先来插个10,为情景1,直接改成黑色即可,再插入5,为情景2,比10小,放到10的左孩子位置,插入9,比10小,但是比5大,放到5的右孩子位置,此时,为情景4iia,左旋后变成了情景4iib,变色右旋即可完成转化。插入3后为情景4i,将父节点和叔叔节点同时变色即可,插入6不需要调整,插入7后为情景5i,变色即可。插入19不需要调整,插入32,变成了5iib,左旋变色即可,插入24,变成5iia,右旋后变成5i,变色即可,最后插入17,完美。 看图说话是不是就简单明了了,看在我画图这么辛苦的份上,点个关注给个赞可好(滑稽)。 TreeNode的插入 了解了红黑树的删除之后,我们再来看下TreeNode中是怎样用代码实现的: static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root, TreeNode<K,V> x) { x.red = true; for (TreeNode<K,V> xp, xpp, xppl, xppr;;) { //情景1:父节点为null if ((xp = x.parent) == null) { x.red = false; return x; } //情景2,3:父节点是黑色节点或者祖父节点为null else if (!xp.red || (xpp = xp.parent) == null) return root; //情景4:插入的节点父节点和祖父节点都存在,并且其父节点是祖父节点的左节点 if (xp == (xppl = xpp.left)) { //情景4i:插入节点的叔叔节点是红色 if ((xppr = xpp.right) != null && xppr.red) { xppr.red = false; xp.red = false; xpp.red = true; x = xpp; } //情景4ii:插入节点的叔叔节点是黑色或不存在 else { //情景4iia:插入节点是其父节点的右孩子 if (x == xp.right) { root = rotateLeft(root, x = xp); xpp = (xp = x.parent) == null ? null : xp.parent; } //情景4iib:插入节点是其父节点的左孩子 if (xp != null) { xp.red = false; if (xpp != null) { xpp.red = true; root = rotateRight(root, xpp); } } } } //情景5:插入的节点父节点和祖父节点都存在,并且其父节点是祖父节点的右节点 else { //情景5i:插入节点的叔叔节点是红色 if (xppl != null && xppl.red) { xppl.red = false; xp.red = false; xpp.red = true; x = xpp; } //情景5ii:插入节点的叔叔节点是黑色或不存在 else {· //情景5iia:插入节点是其父节点的左孩子 if (x == xp.left) { root = rotateRight(root, x = xp); xpp = (xp = x.parent) == null ? null : xp.parent; } //情景5iib:插入节点是其父节点的右孩子 if (xp != null) { xp.red = false; if (xpp != null) { xpp.red = true; root = rotateLeft(root, xpp); } } } } } } 其实就是一毛一样的,对号入座即可。 红黑树的删除 讲完插入,接下来我们来说说删除,删除的话,比插入还要复杂一点,请各位看官先深呼吸,做好阅读准备。 之前已经说过,红黑树是一颗特殊的二叉搜索树,所以进行删除操作时,其实是先进行二叉搜索树的删除,然后再进行调整。所以,其实这里分为两部分内容:1.二叉搜索树的删除,2.红黑树的删除调整。 二叉搜索树的删除主要有这么几种情景: 情景1:待删除的节点无左右孩子。 情景2:待删除的节点只有左孩子或者右孩子。 情景3:待删除的节点既有左孩子又有右孩子。 对于情景1,直接删除即可,情景2,则直接把该节点的父节点指向它的左孩子或者右孩子即可,情景3稍微复杂一点,需要先找到其右子树的最左孩子(或者左子树的最右孩子),即左(右)子树中序遍历时的第一个节点,然后将其与待删除的节点互换,最后再删除该节点(如果有右子树,则右子树上位)。总之,就是先找到它的替代者,找到之后替换这个要删除的节点,然后再把这个节点真正删除掉。 其实二叉搜索树的删除总体来说还是比较简单的,删除完之后,如果替代者是红色节点,则不需要调整,如果是黑色节点,则会导致左子树和右子树路径中黑色节点数量不一致,需要进行红黑树的调整,跟上面一样,替代节点为其父节点的左孩子与右孩子的情况类似,所以这里只说其为左孩子的情景(PS:上一步的寻找替换节点使用的是右子树的最左节点,所以该节点如果有孩子,只能是右孩子): 情景1:只有右孩子且为红色,直接用右孩子替换该节点然后变成黑色即可。 (D代表替代节点,即要被删除的节点,之前在经过二叉搜索树的删除后,D节点其实已经被删除了,这里为了方便理解这个变化过程,所以把这个节点也画出来了,所以当前的初始状态是待删除节点与其替换节点互换位置与颜色之后的状态) 情景2:只有右孩子且为黑色,那么删除该节点会导致父节点的左子树路径上黑色节点减一,此时只能去借助右子树,从右子树中借一个红色节点过来即可,具体取决于右子树的情况,这里又分成两种: i.兄弟节点是红色,则此时父节点是黑色,且兄弟节点肯定有两个孩子,且兄弟节点的左右子树路径上均有两个黑色节点,此时只需将兄弟节点与父节点颜色互换,然后将父节点左旋,左旋后,兄弟节点的左子树SL挂到了父节点p的右孩子位置,这时会导致p的右子树路径上的黑色节点比左子树多一,此时再SL置为红色即可。 ii.兄弟节点是黑色,那么就只能打它孩子的主意了,这里主要关注远侄子(兄弟节点的右孩子,即SR)的颜色情况,这里分成两种情况: a.远侄子SR是黑色,近侄子任意(白色代表颜色可为任意颜色),则先将S转为红色,然后右旋,再将SL换成P节点颜色,P涂成黑色,S也涂成黑色,再进行左旋即可。其实简单说就是SL上位,替换父节点位置。 b.远侄子SR为红色,近侄子任意(该子树路径中有且仅有一个黑色节点),则先将兄弟节点与父节点颜色互换,将SR涂成黑色,再将父节点左旋即可。 emmmm...好像也不是很麻烦嘛(逃)。 TreeNode的删除节点 TreeNode删除节点其实也是两步走,先进行二叉搜索树的删除,然后再进行红黑树的调整,跟之前的情况分析是一致的。 final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab, boolean movable) { ...... //p是待删除节点,replacement用于后续的红黑树调整,指向的是p或者p的继承者。 //如果p是叶子节点,p==replacement,否则replacement为p的右子树中最左节点 if (replacement != p) { //若p不是叶子节点,则让replacement的父节点指向p的父节点 TreeNode<K,V> pp = replacement.parent = p.parent; if (pp == null) root = replacement; else if (p == pp.left) pp.left = replacement; else pp.right = replacement; p.left = p.right = p.parent = null; } //若待删除的节点p时红色的,则树平衡未被破坏,无需进行调整。 //否则删除节点后需要进行调整 TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement); //p为叶子节点,则直接将p从树中清除 if (replacement == p) { // detach TreeNode<K,V> pp = p.parent; p.parent = null; if (pp != null) { if (p == pp.left) pp.left = null; else if (p == pp.right) pp.right = null; } } } 麻烦的地方就在删除节点后的调整了,所有逻辑都在balanceDeletion函数里,两个参数分别表示根节点和删除节点的继承者,来看看它的具体实现: static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root, TreeNode<K,V> x) { for (TreeNode<K,V> xp, xpl, xpr;;) { //x为空或x为根节点,直接返回 if (x == null || x == root) return root; //x为根节点,染成黑色,直接返回(因为调整过后,root并不一定指向删除操作过后的根节点,如果之前删除的是root节点,则x将成为新的根节点) else if ((xp = x.parent) == null) { x.red = false; return x; } //如果x为红色,则无需调整,返回 else if (x.red) { x.red = false; return root; } //x为其父节点的左孩子 else if ((xpl = xp.left) == x) { //如果它有红色的兄弟节点xpr,那么它的父亲节点xp一定是黑色节点 if ((xpr = xp.right) != null && xpr.red) { xpr.red = false; xp.red = true; //对父节点xp做左旋转 root = rotateLeft(root, xp); //重新将xp指向x的父节点,xpr指向xp新的右孩子 xpr = (xp = x.parent) == null ? null : xp.right; } //如果xpr为空,则向上继续调整,将x的父节点xp作为新的x继续循环 if (xpr == null) x = xp; else { //sl和sr分别为其近侄子和远侄子 TreeNode<K,V> sl = xpr.left, sr = xpr.right; if ((sr == null || !sr.red) && (sl == null || !sl.red)) { xpr.red = true; //若sl和sr都为黑色或者不存在,即xpr没有红色孩子,则将xpr染红 x = xp; //本轮结束,继续向上循环 } else { //否则的话,就需要进一步调整 if (sr == null || !sr.red) { if (sl != null) //若左孩子为红,右孩子不存在或为黑 sl.red = false; //左孩子染黑 xpr.red = true; //将xpr染红 root = rotateRight(root, xpr); //右旋 xpr = (xp = x.parent) == null ? null : xp.right; //右旋后,xpr指向xp的新右孩子,即上一步中的sl } if (xpr != null) { xpr.red = (xp == null) ? false : xp.red; //xpr染成跟父节点一致的颜色,为后面父节点xp的左旋做准备 if ((sr = xpr.right) != null) sr.red = false; //xpr新的右孩子染黑,防止出现两个红色相连 } if (xp != null) { xp.red = false; //将xp染黑,并对其左旋,这样就能保证被删除的X所在的路径又多了一个黑色节点,从而达到恢复平衡的目的 root = rotateLeft(root, xp); } //到此调整已经完毕,进入下一次循环后将直接退出 x = root; } } } //x为其父节点的右孩子,跟上面类似 else { // symmetric if (xpl != null && xpl.red) { xpl.red = false; xp.red = true; root = rotateRight(root, xp); xpl = (xp = x.parent) == null ? null : xp.left; } if (xpl == null) x = xp; else { TreeNode<K,V> sl = xpl.left, sr = xpl.right; if ((sl == null || !sl.red) && (sr == null || !sr.red)) { xpl.red = true; x = xp; } else { if (sl == null || !sl.red) { if (sr != null) sr.red = false; xpl.red = true; root = rotateLeft(root, xpl); xpl = (xp = x.parent) == null ? null : xp.left; } if (xpl != null) { xpl.red = (xp == null) ? false : xp.red; if ((sl = xpl.left) != null) sl.red = false; } if (xp != null) { xp.red = false; root = rotateRight(root, xp); } x = root; } } } } } 呼。。。终于。。酝酿了好多天的一篇文章总算是写完了,为了尽量确认转换的准确性,找了很多资料进行参考,过程中花了不少时间,曾多次准备放弃。。。不过总算是没有死在娘胎里,也算是完成了一桩心事,开心。. 之后还会继续更新,欢迎大家继续关注。也欢迎大家前来打脸真正重要的东西,用眼睛是看不见的。

优秀的个人博客,低调大师

【Java入门提高篇】Day24 Java容器类详解(七)HashMap源码分析(下)

前两篇对HashMap这家伙的主要方法,主要算法做了一个详细的介绍,本篇主要介绍HashMap中默默无闻地工作着的集合们,包括KeySet,values,EntrySet,以及对应的迭代器:HashIterator,KeyIterator,ValueIterator,EntryIterator和fast-fail 机制。会介绍三个集合的作用以及它们中隐藏的惊人秘密。 KeySet 我们先来看看KeySet,HashMap中的成员变量keySet保存了所有的Key集合,事实上,这是继承自它的父类AbstractMap的成员变量: transient Set<K> keySet; 而keySet方法,也是覆盖了父类的方法: //AbstractMap 中的keySet方法 public Set<K> keySet() { Set<K> ks = keySet; if (ks == null) { ks = new AbstractSet<K>() { public Iterator<K> iterator() { return new Iterator<K>() { private Iterator<Entry<K,V>> i = entrySet().iterator(); public boolean hasNext() { return i.hasNext(); } public K next() { return i.next().getKey(); } public void remove() { i.remove(); } }; } public int size() { return AbstractMap.this.size(); } public boolean isEmpty() { return AbstractMap.this.isEmpty(); } public void clear() { AbstractMap.this.clear(); } public boolean contains(Object k) { return AbstractMap.this.containsKey(k); } }; keySet = ks; } return ks; } //HashMap 中的keySet方法 /** * 返回一个键值的集合视图,该集合由map支持,因此对map的更改会反映在集合中,反之亦然。 * 如果在对集合进行迭代的过程中修改了map中的映射(除了通过迭代器的删除操作),迭代的结果是未定义的。 * 该集合支持元素删除,通过Iterator.remove,Set.remove,removeAll,retainAll和clear操作 * 从映射中删除相应的映射。 它不支持add或addAll操作。 */ public Set<K> keySet() { Set<K> ks = keySet; if (ks == null) { ks = new KeySet(); keySet = ks; } return ks; } 可以看到,AbstractMap中keySet是一个AbstractSet类型,而覆盖后的keySet方法中,keySet被赋值为KeySet类型。翻翻构造器可以发现,在构造器中并没有初始化keySet,而是在KeySet方法中对keySet进行的初始化(HashMap中都是使用类似的懒加载机制),KeySet是HashMap中的一个内部类,让我们再来看看这个KeySet类型的全貌: final class KeySet extends AbstractSet<K> { public final int size() { return size; } public final void clear() { this.clear(); } public final Iterator<K> iterator() { return new KeyIterator(); } public final boolean contains(Object o) { return containsKey(o); } public final boolean remove(Object key) { return removeNode(hash(key), key, null, false, true) != null; } public final Spliterator<K> spliterator() { return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0); } public final void forEach(Consumer<? super K> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e.key); } if (modCount != mc) throw new ConcurrentModificationException(); } } } 其实KeySet就是继承自AbstractSet,并覆盖了其中的大部分方法,遍历KeySet时,会使用其中的KeyIterator,至于Spliterator,是为并行遍历设计的,一般是用于Stream的并行操作。forEach方法则是用于遍历操作,将函数式接口操作action应用于每一个元素,我们来看一个小栗子: public class Test { public static void main(String[] args) { Map<String, Integer> map = new HashMap(); map.put("小明", 66); map.put("小李", 77); map.put("小红", 88); map.put("小刚", 89); map.put("小力", 90); map.put("小王", 91); map.put("小黄", 92); map.put("小青", 93); map.put("小绿", 94); map.put("小黑", 95); map.put("小蓝", 96); map.put("小紫", 97); map.put("小橙", 98); map.put("小赤", 99); map.put("Frank", 100); Set<String> ks = map.keySet(); System.out.printf("keySet:%s,keySet的大小:%d,keySet中是否包含Frank:%s", ks, ks.size(), ks.contains("Frank")); System.out.println(); ks.forEach((item) -> System.out.println(item)); } } 输出如下: keySet:[小刚, 小橙, 小蓝, 小力, 小青, 小黑, 小明, 小李, 小王, 小紫, 小红, 小绿, Frank, 小黄, 小赤],keySet的大小:15,keySet中是否包含Frank:true 小刚 小橙 小蓝 小力 小青 小黑 小明 小李 小王 小紫 小红 小绿 Frank 小黄 小赤 如果不记得这个AbstractMap和AbstractSet在容器框架中是什么地位,可以往前翻翻这系列文章的第一篇,看看容器家族的族谱。 但是说了这么多,这个keySet。里面的元素是什么时候放进去的呢?我们自然会想到,大概就是调用put方法往里添加元素的时候,顺便把key放进keySet中,完美!让我们再回顾一下putVal方法,来看看是不是这样的: final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //如果当前table未初始化,则先重新调整大小至初始容量 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //(n-1)& hash 这个地方即根据hash求序号,想了解更多散列相关内容可以查看下一篇 if ((p = tab[i = (n - 1) & hash]) == null) //不存在,则新建节点 tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; //先找到对应的node if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) //如果是树节点,则调用相应的putVal方法,这部分放在第三篇内容里 //todo putTreeVal e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //如果是链表则之间遍历查找 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { //如果没有找到则在该链表新建一个节点挂在最后 p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st //如果链表长度达到树化的最大长度,则进行树化,该函数内容也放在第三篇 //todo treeifyBin treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } //如果已存在该key的映射,则将值进行替换 if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } //修改次数加一 ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; } emmmmm,好像没找到?你也许会想,会不会是在TreeNode的putTreeVal方法或者在treeifyBin方法中对key进行插入?好了好了,不要再翻了,其实这个奥秘隐藏在KeySet的迭代器中,再回头看看,它的迭代器返回的是一个KeyIterator,而KeyIterator也是HashMap中的一个内部类,继承自HashMap中的另一个内部类HashIterator。 HashIterator 让我们带着这个疑问,来看看这个HashIterator类里到底有什么玄机: abstract class HashIterator { //指向下一个节点 Node<K,V> next; //当前节点 Node<K,V> current; //为实现 fast-fail 机制而设置的期望修改数 int expectedModCount; //当前遍历到的序号 int index; HashIterator() { expectedModCount = modCount; Node<K,V>[] t = table; current = next = null; index = 0; if (t != null && size > 0) { // 移动到第一个非null节点 do {} while (index < t.length && (next = t[index++]) == null); } } public final boolean hasNext() { return next != null; } final Node<K,V> nextNode() { Node<K,V>[] t; Node<K,V> e = next; // fast-fail 机制的实现 即在迭代器往后遍历时,每次都检测expectedModCount是否和modCount相等 // 不相等则抛出ConcurrentModificationException异常 if (modCount != expectedModCount) throw new ConcurrentModificationException(); //如果遍历越界,则抛出NoSuchElementException异常 if (e == null) throw new NoSuchElementException(); if ((next = (current = e).next) == null && (t = table) != null) { //如果遍历到末尾,则跳到table中下一个不为null的节点处 do {} while (index < t.length && (next = t[index++]) == null); } return e; } public final void remove() { Node<K,V> p = current; if (p == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); current = null; K key = p.key; //移除节点 removeNode(hash(key), key, null, false, false); expectedModCount = modCount; } } 可以发现,在迭代器中,使用nextNode进行遍历时,先把next引用赋值给current,然后把next.next赋值给next,再获取了外部类HashMap中的table引用(t = table),这样就直接通过遍历table的方式来实现对key,value和entry的读取。 if ((next = (current = e).next) == null && (t = table) != null) { //如果遍历到末尾,则跳到table中下一个不为null的节点处 do {} while (index < t.length && (next = t[index++]) == null); } KeyIterator,ValueIterator,EntryIterator都是HashIterator的子类,实现也很简单,仅仅修改了泛型类型: final class KeyIterator extends HashIterator implements Iterator<K> { public final K next() { return nextNode().key; } } final class ValueIterator extends HashIterator implements Iterator<V> { public final V next() { return nextNode().value; } } final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> { public final Map.Entry<K,V> next() { return nextNode(); } } 这样keySet在遍历的时候,就可以通过它的迭代器去遍历访问外部类HashMap中的table,类似的,values和entrySet也是使用相似的方式进行遍历。 public Collection<V> values() { Collection<V> vs = values; if (vs == null) { vs = new Values(); values = vs; } return vs; } final class Values extends AbstractCollection<V> { public final int size() { return size; } public final void clear() { this.clear(); } public final Iterator<V> iterator() { return new ValueIterator(); } public final boolean contains(Object o) { return containsValue(o); } public final Spliterator<V> spliterator() { return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0); } public final void forEach(Consumer<? super V> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e.value); } if (modCount != mc) throw new ConcurrentModificationException(); } } } public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es; return (es = entrySet) == null ? (entrySet = new EntrySet()) : es; } final class EntrySet extends AbstractSet<Map.Entry<K,V>> { public final int size() { return size; } public final void clear() { this.clear(); } public final Iterator<Map.Entry<K,V>> iterator() { return new EntryIterator(); } public final boolean contains(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry<?,?> e = (Map.Entry<?,?>) o; Object key = e.getKey(); Node<K,V> candidate = getNode(hash(key), key); return candidate != null && candidate.equals(e); } public final boolean remove(Object o) { if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>) o; Object key = e.getKey(); Object value = e.getValue(); return removeNode(hash(key), key, value, true, true) != null; } return false; } public final Spliterator<Map.Entry<K,V>> spliterator() { return new EntrySpliterator<K,V>(HashMap.this, 0, -1, 0, 0); } public final void forEach(Consumer<? super Map.Entry<K,V>> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e); } if (modCount != mc) throw new ConcurrentModificationException(); } } } 至此,这个未解之谜算是告一段落了。 transient 但是,细心的同学可能会发现,HashMap中的table,entrySet,keySet,value等成员变量,都是用transient修饰的,为什么要这样做呢? 首先,我们还是先说说这个transient是干嘛用的,这就要涉及Java中的序列化了,序列化是什么东西呢? Java中对象的序列化指的是将对象转换成以字节序列的形式来表示,这些字节序列包含了对象的数据和信息。一个序列化后的对象可以被写到数据库或文件中,也可用于网络传输,一般当我们使用缓存cache(内存空间不够有可能会本地存储到硬盘)或远程调用rpc(网络传输)的时候,经常需要让我们的实体类实现Serializable接口,目的就是为了让其可序列化。 当然,就像数据存储是为了读取那样,序列化后的最终目的是为了恢复成原先的Java对象,要不然序列化后干嘛呢,这个过程就叫做反序列化。 当我们使用实现Serializable接口的方式来进行序列化时,所有字段都会被序列化,那如果不想让某个字段被序列化(比如出于安全考虑,不将敏感字段序列化传输),便可以使用transient关键字来标志,表示不想让这个字段被序列化。 那么问题来了,存储节点信息的table用transient修饰了,那么序列化和反序列化的时候,数据还怎么传输??? emmmm,这又涉及到一个蛋疼的操作,序列化并没有那么简单,实现了Serializable接口后,在序列化时,会先检测这个类是否存在writeObject和readObject方法,如果存在,则调用相应的方法: /** * 将HashMap的实例状态保存到一个流中 */ private void writeObject(java.io.ObjectOutputStream s) throws IOException { int buckets = capacity(); // 写出threshold,loadfactor和所有隐藏的成员 s.defaultWriteObject(); s.writeInt(buckets); s.writeInt(size); internalWriteEntries(s); } /** * 从流中重构HashMap实例 */ private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // 读取threshold,loadfactor和所有隐藏的成员 s.defaultReadObject(); reinitialize(); if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new InvalidObjectException("Illegal load factor: " + loadFactor); // 读取并忽略桶的数量 s.readInt(); // 读取映射的数量 int mappings = s.readInt(); if (mappings < 0) throw new InvalidObjectException("Illegal mappings count: " + mappings); else if (mappings > 0) { // (如果是0,则使用默认值) // Size the table using given load factor only if within // range of 0.25...4.0 float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f); float fc = (float)mappings / lf + 1.0f; int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ? DEFAULT_INITIAL_CAPACITY : (fc >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : tableSizeFor((int)fc)); float ft = (float)cap * lf; threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ? (int)ft : Integer.MAX_VALUE); SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap); @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] tab = (Node<K,V>[])new Node[cap]; table = tab; // 读取键值对信息,然后把映射插入HashMap实例中 for (int i = 0; i < mappings; i++) { @SuppressWarnings("unchecked") K key = (K) s.readObject(); @SuppressWarnings("unchecked") V value = (V) s.readObject(); putVal(hash(key), key, value, false, false); } } } 这确实是一个极其糟糕的设计。。。而且这里还是一个private方法。 那么直接使用默认的序列化不好吗?非要大费周章的骚操作一波?一部分原因是为了解决效率问题,因为HashMap中很多桶是空的,将其序列化没有任何意义,所以需要手动使用 writeObject() 方法,只序列化实际存储元素的数组。另一个很重要的原因便是,HashMap的存储是依赖于对象的hashCode的,而Object.hashCode()方法是依赖于具体虚拟机的,所以同一个对象,在不同虚拟机中的HashCode可能不同,那这样映射到的HashMap中的位置也不一样,这样序列化和反序列化的对象就不一样了。引用大神的一段话: For example, consider the case of a hash table. The physical representation is a sequence of hash buckets containing key-value entries. The bucket that an entry resides in is a function of the hash code of its key, which is not, in general, guaranteed to be the same from JVM implementation to JVM implementation. In fact, it isn't even guaranteed to be the same from run to run. Therefore, accepting the default serialized form for a hash table would constitute a serious bug. Serializing and deserializing the hash table could yield an object whose invariants were seriously corrupt. 蹩脚翻译一下: 例如,考虑散列表的情况。 它的物理存储是一系列包含键值条目的散列桶。 条目驻留的存储区是其密钥的哈希码的函数,通常,JVM的实现不保证相同。 事实上,它甚至不能保证每次运行都是一样的。 因此,接受哈希表的默认序列化形式将构成严重的错误。 对哈希表进行序列化和反序列化可能会产生不变性被严重损毁的对象。 好了,到此为止,这部分内容算是over了,后面会继续介绍HashMap中最麻烦的一部分,TreeNode让我们师母已呆 记得动动小手点个赞或者点个关注哦,如果觉得不错的话,也欢迎分享给你的朋友,让bug传播的更远一些,呸,说错了,让知识传播的更远一些如果写的有误的地方,欢迎大家及时指出,我会第一时间予以修正,也欢迎提出改进建议,之后还会继续更新,欢迎继续关注! 真正重要的东西,用眼睛是看不见的。

优秀的个人博客,低调大师

【Java入门提高篇】Day23 Java容器类详解(六)HashMap源码分析(中)

上一篇中对HashMap中的基本内容做了详细的介绍,解析了其中的get和put方法,想必大家对于HashMap也有了更好的认识,本篇将从了算法的角度,来分析HashMap中的那些函数。 HashCode 先来说说HashMap中HashCode的算法,在上一篇里,我们看到了HashMap中的put方法是这样的: public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } 那这个hash函数又是什么呢?让我们来看看它的真面目: /** * 将高位与低位进行与运算来计算哈希值。因为在hashmap中使用2的整数幂来作为掩码,所以只在当前掩码之上的位上发生 * 变化的散列总是会发生冲突。(在已知的例子中,Float键的集合在小表中保持连续的整数)因此,我们应用一个位运算 * 来向下转移高位的影响。 这是在综合考虑了运算速度,效用和质量之后的权衡。因为许多常见的散列集合已经合理分布 * (所以不能从扩散中受益),并且因为我们使用树来处理bin中发生的大量碰撞的情况,所以我们尽可能以代价最低的方式 * 对一些位移进行异或运算以减少系统损失, 以及合并由于hashmap容量边界而不会被用于散列运算的最高位的影响。 * * todo 扰动函数 */ static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } 可以看出,这里并不是简单的使用了key的hashCode,而是将它的高16位与低16位做了一个异或操作。(“>>>”是无符号右移的意思,即右移的时候左边空出的部分用0填充)这是一个扰动函数,具体效果后面会说明。接下来再看看之前的putval方法: 1 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, 2 boolean evict) { 3 Node<K,V>[] tab; Node<K,V> p; int n, i; 4 //如果当前table未初始化,则先重新调整大小至初始容量 5 if ((tab = table) == null || (n = tab.length) == 0) 6 n = (tab = resize()).length; 7 //(n-1)& hash 这个地方即根据hash求序号,想了解更多散列相关内容可以查看下一篇 8 if ((p = tab[i = (n - 1) & hash]) == null) 9 //不存在,则新建节点 10 tab[i] = newNode(hash, key, value, null); 11 else { 12 Node<K,V> e; K k; 13 //先找到对应的node 14 if (p.hash == hash && 15 ((k = p.key) == key || (key != null && key.equals(k)))) 16 e = p; 17 else if (p instanceof TreeNode) 18 //如果是树节点,则调用相应的putVal方法,这部分放在第三篇内容里 19 //todo putTreeVal 20 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); 21 else { 22 //如果是链表则之间遍历查找 23 for (int binCount = 0; ; ++binCount) { 24 if ((e = p.next) == null) { 25 //如果没有找到则在该链表新建一个节点挂在最后 26 p.next = newNode(hash, key, value, null); 27 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 28 //如果链表长度达到树化的最大长度,则进行树化,该函数内容也放在第三篇 29 //todo treeifyBin 30 treeifyBin(tab, hash); 31 break; 32 } 33 if (e.hash == hash && 34 ((k = e.key) == key || (key != null && key.equals(k)))) 35 break; 36 p = e; 37 } 38 } 39 //如果已存在该key的映射,则将值进行替换 40 if (e != null) { // existing mapping for key 41 V oldValue = e.value; 42 if (!onlyIfAbsent || oldValue == null) 43 e.value = value; 44 afterNodeAccess(e); 45 return oldValue; 46 } 47 } 48 //修改次数加一 49 ++modCount; 50 if (++size > threshold) 51 resize(); 52 afterNodeInsertion(evict); 53 return null; 54 } 注意看第八行的代码: tab[i = (n - 1) & hash] (n - 1) & hash即通过key的hash值来取对应的数组下标,并非是对table的size进行取余操作。 那么,为什么要这样做呢?首先,扰动函数的目的就是为了扩大高位的影响,使得计算出来的数值包含了高 16 位和第 16 位的特性,让 hash 值更加深不可测来降低碰撞的概率。从hash方法的注释中,我们也可以找到答案,一般的散列,其实都是做取余处理,但是HashMap中的table大小是2的整数次幂,也就是说,肯定不是质数,那么在取余的时候,偶数的映射范围势必就要小了一半,这样效果显然就差很多,而且,除法和取余其实是很慢的操作,所以在JDK8中,使用了一种很巧妙的方式来进行散列。首先,table的大小size设置成了2的整数次幂,这样使用size-1就变成了掩码,下面是我找的一张图,能很好的解释这个过程: n是table的大小,默认是16,二进制即为10000,n - 1对应的二进制则为1111,这样再与hash值做“与”操作时,就变成了掩码,除了最后四位全部被置为0,而最后四位的范围肯定会落在(0~n-1)之间,正好是数组的大小范围,散列函数的妙处就在于此了。简直不能更稳,一波操作猛如虎。 那么我们继续上一篇的栗子,我们来一步一步分析一下,小明和小李的hash值的映射过程: 小明的hash值是756692,转换为二进制为10111000101111010100,table的大小是32,n-1=31,对应的二进制为:11111,做“与”运算之后,得到的结果是10100,即为20。 小李的hash值是757012,转换为二进制为10111000110100010100,与11111做与运算后,得到的结果也是10100,即20,于是就与小明发生了冲突,但还是要先来后到,于是小李就挂在了小明后面。 散列函数看完了,我们接下来再看看扩容函数。 扩容函数 扩容函数其实之前也已经见过了,就在上面的putVal方法里,往上面翻一翻,第六行可以看到resize函数,这就是扩容函数,让我们来看看它的庐山真面目: 1 /** 2 * 初始化或将table的大小进行扩容。 如果table为null,则按照字段threshold中的初始容量目标进行分配。 3 * 否则,因为我们使用2次幂进行扩容,所以在新表中,来自每个bin中的元素必须保持在相同的索引处,或者以原偏移量的2次幂进行移动。 4 */ 5 final Node<K,V>[] resize() { 6 Node<K,V>[] oldTab = table; 7 int oldCap = (oldTab == null) ? 0 : oldTab.length; 8 int oldThr = threshold; 9 int newCap, newThr = 0; 10 if (oldCap > 0) { 11 if (oldCap >= MAXIMUM_CAPACITY) { 12 threshold = Integer.MAX_VALUE; 13 return oldTab; 14 } 15 //新的容量扩展成原来的两倍 16 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && 17 oldCap >= DEFAULT_INITIAL_CAPACITY) 18 //阈值也调整为原来的两倍 19 newThr = oldThr << 1; // double threshold 20 } 21 else if (oldThr > 0) // initial capacity was placed in threshold 22 newCap = oldThr; 23 else { // zero initial threshold signifies using defaults 24 newCap = DEFAULT_INITIAL_CAPACITY; 25 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); 26 } 27 if (newThr == 0) { 28 float ft = (float)newCap * loadFactor; 29 newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? 30 (int)ft : Integer.MAX_VALUE); 31 } 32 threshold = newThr; 33 @SuppressWarnings({"rawtypes","unchecked"}) 34 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; 35 table = newTab; 36 //将旧数组中的node重新散列到新数组中 37 if (oldTab != null) { 38 for (int j = 0; j < oldCap; ++j) { 39 Node<K,V> e; 40 if ((e = oldTab[j]) != null) { 41 oldTab[j] = null; 42 if (e.next == null) 43 newTab[e.hash & (newCap - 1)] = e; 44 else if (e instanceof TreeNode) 45 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); 46 else { // preserve order 47 Node<K,V> loHead = null, loTail = null; 48 Node<K,V> hiHead = null, hiTail = null; 49 Node<K,V> next; 50 do { 51 next = e.next; 52 if ((e.hash & oldCap) == 0) { 53 if (loTail == null) 54 loHead = e; 55 else 56 loTail.next = e; 57 loTail = e; 58 } 59 else { 60 if (hiTail == null) 61 hiHead = e; 62 else 63 hiTail.next = e; 64 hiTail = e; 65 } 66 } while ((e = next) != null); 67 if (loTail != null) { 68 loTail.next = null; 69 newTab[j] = loHead; 70 } 71 if (hiTail != null) { 72 hiTail.next = null; 73 newTab[j + oldCap] = hiHead; 74 } 75 } 76 } 77 } 78 } 79 return newTab; 80 } 这里可以看到,如果原来的table还未被初始化的话,调用该函数后就会被扩容到默认大小(16),上一篇中也已经说过,HashMap也是使用了懒加载的方式,在构造函数中并没有初始化table,而是在延迟到了第一次插入元素之后。 当使用put插入元素的时候,如果发现目前的bins占用程度已经超过了Load Factor所设置的比例,那么就会发生resize,简单来说就是把原来的容量和阈值都调整为原来的2倍,之后重新计算index,把节点再放到新的bin中。因为index值的计算与table数组的大小有关,所以扩容后,元素的位置有可能会调整: 以上图为例,如果对应的hash值第五位是0,那么做与操作后,得到的序号不会变,那么它的位置就不会改变,相反,如果是1,那么它的新序号就会变成原来的序号+16,。 好像也不是很多嘛,嗯,算法部分就先介绍到这里了,之后的一篇再来说说HashMap中的EntrySet,KeySet和values(如果时间够的话顺便把迭代器也说一说)。 好了,本篇就此愉快的结束了,最后祝大家端午节快乐!如果觉得内容还不错的话记得动动小手点关注哦,你的支持就是我最大的动力! 真正重要的东西,用眼睛是看不见的。

优秀的个人博客,低调大师

【Java入门提高篇】Day22 Java容器类详解(五)HashMap源码分析(上)

准备了很长时间,终于理清了思路,鼓起勇气,开始介绍本篇的主角——HashMap。说实话,这家伙能说的内容太多了,要是像前面ArrayList那样翻译一下源码,稍微说说重点,肯定会让很多人摸不着头脑,不能把复杂的东西用尽量简单的方式说明白,那就说明讲的挺失败的(面壁中)。所以这次决定把内容分四篇进行讲解, 第一篇主要讲解HashMap中的结构,重要参数和重要方法,以及使用中需要注意的地方和应用场景。 第二篇主要讲解HashMap中的散列算法,扰动函数以及扩容函数。普通节点的较深入的解析其中算法的妙处。 第三篇主要讲解HashMap中的EntrySet,KeySet和Values。 第四篇主要讲解HashMap中的TreeNode结构以及元素增减时的结构调整方式。(以JDK8中的红黑树进行讲解)。 因为HashMap中可以说说的点实在太多了,这里选取了比较重要的几点进行说明,四篇的角度和深度各不一样,这样不同阶段的同学也可以选取不同的部分进行阅读,第一篇属于简单易懂的初级部分,第二、第三篇和第四篇属于HashMap的高级部分,如果阅读有难度,可以先跳过,以后再来进行阅读。 好了,话不多说,接下来就进入我们的主题了。 本篇将摈弃之前的讲法,直接摆几百行源码实在是太干了,我们得弄湿一点才好消化(滑稽),接下来将用图文并茂的方式进行说明。 通过本篇,你将了解以下问题: 1.HashMap的结构是什么? 2.HashMap的优点和缺点是什么? 3.什么时候该使用HashMap? 4.HashMap中的常用方法有哪些? 5.HashMap的get()方法和put()方法的工作原理是什么? 6.HashMap中的碰撞探测(collision detection)以及碰撞的解决方法是什么? 7.如果HashMap的大小超过了负载因子(load factor)定义的容量,怎么办? 8.在设置HashMap的键是需要注意什么?可以使用自定义的对象作为键吗? 嗯,所以内容还是挺多的,干货也不少。我们先来看一个HashMap的小栗子: public class Test { public static void main(String[] args){ Map<String, Integer> map = new HashMap(); map.put("小明", 66); map.put("小李", 77); map.put("小红", 88); map.put("小刚", 89); map.put("小力", 90); map.put("小王", 91); map.put("小黄", 92); map.put("小青", 93); map.put("小绿", 94); map.put("小黑", 95); map.put("小蓝", 96); map.put("小紫", 97); map.put("小橙", 98); map.put("小赤", 99); map.put("Frank", 100); for(Map.Entry<String, Integer> entry : map.entrySet()){ System.out.println(entry.getKey() + ":" + entry.getValue()); } } } 输出也很简单: 小刚:89 小橙:98 小蓝:96 小力:90 小青:93 小黑:95 小明:66 小李:77 小王:91 小紫:97 小红:88 小绿:94 Frank:100 小黄:92 小赤:99 可以看到,HashMap中存储的顺序跟我们放入的顺序有些不太一样,但是每次运行的结果都是一样的,以一种神奇的顺序输出着,为什么会这样呢?不要着急,让我们先来打个断点看看。 可以看到,这个HashMap对象里,有一个table字段,可以看出,它是一个数组,我们put的成绩信息,就在这个家伙里面了,你看看,这个顺序跟上面的输出顺序是不是很像? 不过,等一下,你有没有发现,小李,小紫,小赤失踪了。。这个问题,不要着急,待会我们就一起去找他们。 HashMap里的数据结构是数组+链表的形式来存储节点的,每个节点以键值对(Node<K,V>)的形式存储,上面看到的table,就是HashMap中存放值的地方,它的数据结构是这样的:Node<K,V>[] table;那这个Node到底是什么东西呢?我们来看看它的代码: /** * 用于大多数键值对的普通节点 */ static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; /** * 指向下一个节点的引用 */ Node<K,V> next; Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { //返回key和value的哈希值的异或运算结果 return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } } Node类继承于Map.Entry接口,如果对这个接口没有印象了可以回过头翻一下Map接口的内容,Node中的内容很简单,hash,键值信息和下一个节点的引用,Node之间正是通过这样的引用来连接起来形成一条链。再想想table的结构,Node<K,V>[],现在是不是理解了什么是数组+链表的存储方式了? 什么?这样说的还不够形象?好吧,一图胜千言,之前说要用图文并茂的方式来进行讲解,所以还是一起来看几张图片: 嗯,我们存储的数据在内存里就是这样的,我们再来看一下断点里的数据: 对比两幅图应该就能比较清楚的了解了,可以看出里面数组并不是顺序往里存的,中间有很多空的桶(每个格子称为一个bin,这里蹩脚翻译成桶),那为什么会是这样的顺序呢?我们来看看它的put方法: /** * 将map中指定key和value进行关联,如果map中已经存在该key的映射,则旧的值将会被替换。 * 返回该key映射的旧值,如果该key的映射不存在的话则返回null。 */ public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } /** * 实现 Map.put 和相关方法 * * @param hash key的哈希值 * @param key key * @param value key将要映射的value * @param onlyIfAbsent 如果是true的话,将不会改变已存在的值 * @param evict 这个参数如果为true,那么每插入一个新值,就会把链表的第一个元素顶出去,保持链表元素个数不变 */ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //如果当前table未初始化,则先重新调整大小至初始容量 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //(n-1)& hash 这个地方即根据hash求序号,想了解更多散列相关内容可以查看下一篇 if ((p = tab[i = (n - 1) & hash]) == null) //不存在,则新建节点 tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; //先找到对应的node if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) //如果是树节点,则调用相应的putVal方法 //todo putTreeVal e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //如果是链表则之间遍历查找 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { //如果没有找到则在该链表新建一个节点挂在最后 p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st //如果链表长度达到树化的最大长度,则进行树化 //todo treeifyBin treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } //如果已存在该key的映射,则将值进行替换 if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } //修改次数加一 ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; } 从这里可以看出往HashMap添加元素时的逻辑: 对key的hashCode()做一次散列(hash函数,具体内容下一篇讲解),然后根据这个散列值计算index(i = (n - 1) & hash); 如果没有发生碰撞(哈希冲突),则直接放到桶里; 如果碰撞了,以链表的形式挂在桶后; 如果因为碰撞导致链表过长(大于等于TREEIFY_THRESHOLD),就把链表转换成红黑树; 如果节点已经存在就替换old value(保证key的唯一性) 如果桶满了(超过负载因子*当前容量),就要resize(重新调整大小并重新散列)。 也许你想知道这个table是什么东西,那我们顺便一起看看那几个重要的成员变量吧: /* ---------------- 字段 -------------- */ /** * 哈希表,该表在初次使用时初始化,并根据需要调整大小。 分配时,长度总是2的幂 * * todo hashMap的结构 * todo transient */ transient Node<K,V>[] table; /** * 保存缓存的entrySet,注意AbstractMap中的字段是用于keySet() 和 values(). */ transient Set<Map.Entry<K,V>> entrySet; /** * map中的键值对个数 */ transient int size; /** * hashmap 结构性修改的次数,结构性修改是指改变hashmap中映射数量或者修改内部结构。 * 该字段用于在HashMap中创建基于集合视图的可失败快速的(fail-fast)迭代器。 */ transient int modCount; /** * 下一个调整大小的值(容量*加载因子)。 */ int threshold; /** * hashmap的装载因子 */ final float loadFactor; table字段是中保存了我们的数据,类型是Node数组,Node的结构也很简单,只是简单的存放key和value,以及key的hash和指向下一个节点的引用。 /** * 用于大多数键值对的普通节点 */ static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; /** * 指向下一个节点的引用 */ Node<K,V> next; Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { //返回key和value的哈希值的异或运算结果 return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } } 在成员变量entrySet中缓存了Entry的集合(其实你仔细找找的话,会发现entrySet的存储元素逻辑并不简单,这将在第三篇里讲解)。threshold表示进行下一次重新调整的阈值(容量*装载因子),转载因子表示table最大装满程度,默认是0.75,即当容量被用掉75%后将会触发扩容,因为当table中的元素足够多时,发生冲突的概率就会大大增加,冲突的增多会导致每个桶中的元素个数变多,这样的话会使得查找元素效率变得低下,当同一个桶中元素个数达到8时,桶中的元素结构将转换为红黑树。 那么,问题来了,为什么是8,而不是6或者7,10呢???这个话题如果要深入探讨的话,又要说上一篇了。。。这里我就引用一下JDK8中的HashMap的中注解: * Ideally, under random hashCodes, the frequency of * nodes in bins follows a Poisson distribution * (http://en.wikipedia.org/wiki/Poisson_distribution) with a * parameter of about 0.5 on average for the default resizing * threshold of 0.75, although with a large variance because of * resizing granularity. Ignoring variance, the expected * occurrences of list size k are (exp(-0.5) * pow(0.5, k) / * factorial(k)). The first values are: * * 0: 0.60653066 * 1: 0.30326533 * 2: 0.07581633 * 3: 0.01263606 * 4: 0.00157952 * 5: 0.00015795 * 6: 0.00001316 * 7: 0.00000094 * 8: 0.00000006 * more: less than 1 in ten million * 大致意思是,理想情况下,HashCode随机分布,当负载因子设置成0.75时,那么在桶中元素个数的概率大致符合0.5的泊松分布,桶中元素个数达到8的概率小于千万分之一,因为转化为红黑树还是比较耗时耗力的操作,自然不希望经常进行,但如果设置得过大,将失去设置该值的意义。 那么,问题又来了。。为什么是0.75,而不是0.5,0.8???这是一个经验值,在空间和时间成本中的折中,跟默认初始容量设置为16一样。看看JDK8中HashMap最开头的注释即可找到答案:(说实话,JDK中的注解真是太多太详细了,教科书式的代码人一般人写的还是不一样的) * <p>As a general rule, the default load factor (.75) offers a good * tradeoff between time and space costs. Higher values decrease the * space overhead but increase the lookup cost (reflected in most of * the operations of the <tt>HashMap</tt> class, including * <tt>get</tt> and <tt>put</tt>). The expected number of entries in * the map and its load factor should be taken into account when * setting its initial capacity, so as to minimize the number of * rehash operations. If the initial capacity is greater than the * maximum number of entries divided by the load factor, no rehash * operations will ever occur. 再蹩脚的翻译一次: * 通常,默认的负载因子(0.75)是在时间和空间成本上比较好的折中选择。如果设置成更高的值,虽然会 * 减少空间开销,但是会增加查找的成本(反应在HashMap的大部分操作中,包括get和put方法)。 * 在设置初始容量时,应该考虑映射中的条目数量以及负载因子,以尽量减少重新散列的次数。 * 如果初始容量大于最大词条数量除以负载因子,那么就不会发生重新散列操作。 而且,装载因子和容量都是可以在构造函数中指定的: /** * 用指定初始容量和装载因子构造一个空的hashmap, */ public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; //重新计算阈值 this.threshold = tableSizeFor(initialCapacity); } /** * 用指定初始容量和默认的装载因子(0.75)构造一个空的hashmap */ public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } /** * 用指定默认容量(16)和默认的装载因子(0.75)构造一个空的hashmap */ public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } /** * 用另一个map来构造一个新的hashmap,并保留相同的映射。新的HashMap使用默认加载因子(0.75)和适合装下指定map中所有映射关系的 * 初始容量。 */ public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); } 如果不指定初始大小和加载因子,将使用默认的加载因子和默认的容量,而且HashMap中是使用懒加载的方式进行的,只有真正往里添加元素时才会初始化table。上面我们已经看过了put方法的实现,那我们再来看看get方法是怎样实现的: /** * 返回指定键映射的值,当该key不存在的时候返回null */ public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } /** * 实现了Map.get 和相关方法 */ final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { //判断是否是第一个节点 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; if ((e = first.next) != null) { if (first instanceof TreeNode) //如果是树节点,则用TreeNode的getTreeNode方法来查找相应的key return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { //否则遍历链表来查找 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; } get的思路很简单。大致思路如下: 先匹配bucket里的第一个节点,直接命中则返回; 如果有冲突,则通过key.equals(k)去查找对应的entry若为树节点,则在树中通过key.equals(k)查找,时间复杂度为O(logn);若为链表节点,则在链表中通过key.equals(k)查找,时间复杂度为O(n)。 好了,最重要的方法都介绍完了,是时候去救爷爷了,说错了,是时候来回答最开头提出的问题了: 1.HashMap的结构是什么? HashMap是数组+链表的存储形式,默认的初始容量是16,默认的加载因子是0.75,当链表长度达到8时将会转化为红黑树来提高查找效率。 2.HashMap的优点和缺点是什么? HashMap的优点是查找速度很快,我们可以在常数时间内迅速定位到某个桶以及要找的对象。缺点嘛,就是它的拿手好戏——散列算法是依赖key的hashcode,所以如果key的hashcode设计的很烂,将会严重影响性能。 极端情况下,如果每次计算hash值都是同一个值,那么会造成链表中长度过长然后转化成树,扩容时再散列的效果也很差的问题。另一个极端情况. 每次计算hash值都是不同的值,那么就是HashMap中的数组会不断的扩容,造成HashMap的容量不断增大。 另一方面,HashMap是线程不安全的,如果想在并发编程中使用到HashMap,就需要使用它的同步类,Collections.synchronizedMap()方法将普通的HashMap转化成线程安全的,或者使用Concurrent包下的ConcurrentHashMap进行替换。 3.什么时候该使用HashMap? 因为HashMap查找速度很快,所以应用在经常需要存取元素的场景,比如要将一个ListB中的元素根据另一个ListA的元素来进行排序,那么需要经常将B中的元素来到A中进行查找,而查找一般都是使用遍历的方式进行的,如果List很大的情况下,效率问题还是需要考虑的,这时候如果将A中的元素存储在Map中,以B中的元素作为key,那么查找效率将大大提高,这是以空间换取时间的策略。 4.HashMap中的常用方法有哪些? 常用方法有put,get,putAll,remove,clear,replace,size。 5.HashMap的get()方法和put()方法的工作原理是什么? 通过对key的hashCode()进行hashing,并计算下标( n-1 & hash),从而获得桶的位置。如果发生哈希冲突,则利用key.equals()方法去链表或树中去查找对应的节点。 6.HashMap中的碰撞探测(collision detection)以及碰撞的解决方法是什么? 当两个key的hashCode相同时,就会发生碰撞,就像上面的小明和小李,这时候后添加的元素将会以链表或树节点的形式挂在桶后面。 7.如果HashMap的大小超过了负载因子(load factor)定义的容量,怎么办? 如果HashMap的大小超过了加载因子*容量,那么将会进行扩容操作,扩容到原来的两倍。 8.在设置HashMap的键是需要注意什么?可以使用自定义的对象作为键吗? 设置的key尽量使用不可变对象,例如数值,String,这样可以保证key的不可变性,也可以使用自定义的类对象,但需要对hashCode方法和equals方法有良好的设计。 此处应有掌声,本篇终于讲解完毕,这段时间因为其他时间,一直没多少时间来写博客,耽搁了两个星期,对不住各位看官啦,不过写一篇博客真心挺花时间的,这篇文章我也是想了好几天才想好思路,HashMap的东西实在是太多了,细节不太可能面面俱到,而且如果事无巨细全部介绍的话,显然对初学者来说不够友好,所以才决定分成了四篇,这样大家可以根据自己能理解的程度选择性的阅读。 还望各位看官赏个赞,对我的文章感兴趣的话,也欢迎动动小手点点关注,还是持续更新的。也欢迎提出好的建议,如果有重要知识点遗漏或者说错了的地方,还请各位看官及时指出,多多交流。 真正重要的东西,用眼睛是看不见的。

优秀的个人博客,低调大师

java基础学习_集合类04_Map接口、Collections工具类_day18总结

========================================================================================================================================================== 涉及到的知识点有: 1:Map接口(掌握) (1)Map接口的概述 (2)Map接口和Collection接口的区别? (3)Map接口的功能概述 A:添加功能 B:删除功能 C:判断功能 D:获取功能 E:长度功能 (4)Map集合的遍历 A:键找值 B:键值对对象找键和值 (5)HashMap集合(唯一) A:HashMap集合的概述 B:HashMap集合的案例 C:LinkedHashMap集合的概述(唯一和有序) (6)TreeMap集合(排序和唯一) A:TreeMap类概述 B:TreeMap集合的案例 (7)Map集合案例 A:统计一个字符串中每个字符出现的次数(要对着思路会写) B:集合的嵌套遍历 (8)面试题 a:HashMap类和Hashtable类的区别 b:List、Set、Map等接口是否都继承自Map接口? 2:Collections工具类(理解) (1)Collections类的概述 (2)面试题:Collection和Collections的区别 (3)Collections工具类的常见成员方法 (4)Collections工具类的案例 A:ArrayList集合存储自定义对象的排序 B:模拟斗地主洗牌和发牌 C:模拟斗地主洗牌和发牌并对牌进行排序==========================================================================================================================================================1:Map接口(掌握) (1)Map接口的概述 将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值。 (2)Map接口和Collection接口的区别? A:Map集合存储的元素是键值对形式出现的,Map集合的键是唯一,值是可以重复的。可以把这个理解为:夫妻对。 B:Collection集合存储的元素是单独出现的,子接口Set元素唯一,子接口List元素可重复。可以把这个理解为:光棍(11.11)。 C:Map集合的数据结构只针对键有效,跟值无关。 D:Collection集合的数据结构针对元素有效。--------------------------------------- (3)Map接口的功能概述 A:添加功能 V put(K key, V value) 添加元素/替换元素 如果键是第一次存储,就直接存储元素,而返回的值是null。 如果键不是第一次存储,就用现在的值把以前的值替换掉,而返回的值是以前的值。 B:删除功能 void clear() 移除所有的键值对元素 V remove(Object key) 根据键删除键值对元素,并把值返回 C:判断功能 boolean containsKey(Object key) 判断集合是否包含指定的键 boolean containsValue(Object value) 判断集合是否包含指定的值 boolean isEmpty() 判断集合是否为空 D:获取功能 Set<Map.Entry<K, V>> entrySet() 返回的是键值对对象的集合 V get(Object key) 根据键获取值,返回的是值 Set<K> keySet() 获取集合中所有键的集合(因为键不可重复) Collection<V> values() 获取集合中所有值的集合(因为值可以重复) E:长度功能 int size() 返回集合中的键值对的对数 1 package cn.itcast_01; 2 3 import java.util.HashMap; 4 import java.util.Map; 5 6 /* 7 * 作为学生来说,是根据学号来区分不同的学生的,那么假设我现在已经知道了学生的学号,我要根据学号去获取学生姓名,请问怎么做呢? 8 * 如果采用前面讲解过的集合,我们只能把学生学号和学生姓名作为一个对象的成员变量,然后存储整个对象,将来遍历的时候,判断,获取对应的名称。 9 * 但是呢,如果我都能把学生姓名拿出来了,我还需要根据编号去找吗? 10 * 11 * 针对我们目前的这种需求:仅仅知道学号,就想知道学生姓名的情况,Java就提供了一种新的集合 Map(接口)。 12 * 通过查看API,我们知道Map集合的一个最大的特点,就是它可以存储键值对的元素。这个时候存储我们上面的需求,就可以这样做: 13 * Set(不可重复) List(可重复) 14 * 键 映射 值 15 * 学号1 对应 姓名1 16 * 学号2 对应 姓名2 17 * 学号3 对应 姓名3 18 * 学号2(不行) 不能对应 姓名4 19 * 学号4 对应 姓名4 20 * 21 * Map集合的特点: 22 * 将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值。 23 * 24 * Map集合和Collection集合的区别? 25 * Map集合存储元素是成对出现的,Map集合的键是唯一的,值是可重复的。可以把这个理解为:夫妻对 26 * Collection集合存储元素是单独出现的,Collection的儿子Set是唯一的,List是可重复的。可以把这个理解为:光棍(11.11) 27 * 28 * 注意: 29 * Map集合的数据结构值针对键有效,跟值无关。 30 * HashMap,TreeMap等会讲。 31 * Collection集合的数据结构是针对元素有效。 32 * 33 * Map集合的功能概述: 34 * 1:添加功能 35 * V put(K key, V value) 添加元素/替换元素 36 * 如果键是第一次存储,就直接存储元素,而返回的值是null。 37 * 如果键不是第一次存储,就用现在的值把以前的值替换掉,而返回的值是以前的值。 38 * 2:删除功能 39 * void clear() 移除所有的键值对元素 40 * V remove(Object key) 根据键删除键值对元素,并把值返回 41 * 3:判断功能 42 * boolean containsKey(Object key) 判断集合是否包含指定的键 43 * boolean containsValue(Object value) 判断集合是否包含指定的值 44 * boolean isEmpty() 判断集合是否为空 45 * 4:获取功能 46 * Set<Map.Entry<K, V>> entrySet() 返回的是键值对对象的集合 47 * V get(Object key) 根据键获取值 48 * Set<K> keySet() 获取集合中所有键的集合 49 * Collection<V> values() 获取集合中所有值的集合 50 * 5:长度功能 51 * int size() 返回集合中的键值对的对数 52 */ 53 public class MapDemo { 54 public static void main(String[] args) { 55 // 创建集合对象,且键和值都是字符串类型 56 Map<String, String> map = new HashMap<String, String>(); 57 58 // 添加元素 59 // V put(K key, V value) 添加元素 60 // 如果键是第一次存储,就直接存储元素,而返回的值是null。 61 // 如果键不是第一次存储,就用现在的值把以前的值替换掉,而返回的值是以前的值。 62 // System.out.println("put:" + map.put("文章", "马伊俐")); 63 // System.out.println("put:" + map.put("文章", "姚笛")); 64 65 map.put("邓超", "孙俪"); 66 map.put("黄晓明", "杨颖"); 67 map.put("周杰伦", "蔡依林"); 68 map.put("刘恺威", "杨幂"); 69 70 // void clear() 移除所有的键值对元素 71 // map.clear(); 72 73 // V remove(Object key) 根据键删除键值对元素,并把值返回 74 // System.out.println("remove:" + map.remove("黄晓明")); // 返回的是杨颖 75 // System.out.println("remove:" + map.remove("黄晓波")); // 键不存在的时候返回null 76 77 // boolean containsKey(Object key) 判断集合是否包含指定的键 78 // System.out.println("containsKey:" + map.containsKey("黄晓明")); // 包含指定的键时返回true 79 // System.out.println("containsKey:" + map.containsKey("黄晓波")); // 不包含指定的键时返回false 80 81 // boolean isEmpty() 判断集合是否为空 82 // System.out.println("isEmpty:"+map.isEmpty()); 83 84 // int size() 返回集合中的键值对的对数 85 System.out.println("size:"+map.size()); // 4 86 87 // 输出集合名称 88 System.out.println("map:" + map); // 重写了toString()方法 89 } 90 } MapDemo.java 1 package cn.itcast_01; 2 3 import java.util.Collection; 4 import java.util.HashMap; 5 import java.util.Map; 6 import java.util.Set; 7 8 /* 9 * Map集合的功能概述: 10 * 4:获取功能 11 * V get(Object key) 根据键获取值,返回的是值 12 * Set<K> keySet() 获取集合中所有键的集合 13 * Collection<V> values() 获取集合中所有值的集合 14 */ 15 public class MapDemo2 { 16 public static void main(String[] args) { 17 // 创建集合对象 18 Map<String, String> map = new HashMap<String, String>(); 19 20 // 创建元素并添加元素 21 map.put("邓超", "孙俪"); 22 map.put("黄晓明", "杨颖"); 23 map.put("周杰伦", "蔡依林"); 24 map.put("刘恺威", "杨幂"); 25 26 // V get(Object key) 根据键获取值,返回的是值 27 System.out.println("get:" + map.get("周杰伦")); 28 System.out.println("get:" + map.get("周杰")); // 返回null 29 System.out.println("----------------------"); 30 31 // Set<K> keySet() 获取集合中所有键的集合 32 Set<String> set = map.keySet(); 33 for (String key : set) { 34 System.out.println(key); 35 } 36 System.out.println("----------------------"); 37 38 // Collection<V> values() 获取集合中所有值的集合 39 Collection<String> con = map.values(); 40 for (String value : con) { 41 System.out.println(value); 42 } 43 } 44 } MapDemo2.java --------------------------------------- (4)Map集合的遍历 A:键找值 a:获取所有键的集合 b:遍历键的集合,得到每一个键 c:根据键到集合中去找值 B:键值对对象找键和值 a:获取所有的键值对对象的集合 b:遍历键值对对象的集合,获取每一个键值对对象 c:根据键值对对象找键和值 代码体现: Map<String,String> hm = new HashMap<String, String>(); hm.put("it002", "hello"); hm.put("it003", "world"); hm.put("it001", "java"); // 方式1:键找值 Set<String> set = hm.keySet(); for (String key : set) { String value = hm.get(key); System.out.println(key + "---" + value); } // 方式2:键值对对象找键和值 Set<Map.Entry<String,String>> set2 = hm.entrySet(); for (Map.Entry<String,String> me : set2) { String key = me.getKey(); String value = me.getValue(); System.out.println(key + "---" + value); } --------------------------------------- (5)HashMap集合(唯一) A:HashMap集合的概述 是基于哈希表的Map接口实现类。键是哈希表结构,可以保证键的唯一性。依赖于hashCode()和equals()方法来保证唯一性的。 B:HashMap集合的案例(注意:蓝色字体为键) a:HashMap<String, String> 1 package cn.itcast_02; 2 3 import java.util.HashMap; 4 import java.util.Set; 5 6 /* 7 * HashMap:是基于哈希表的Map接口实现类。 8 * 哈希表的作用是用来保证键的唯一性的。 9 * 依赖于hashCode()和equals()方法来保证唯一性的。 10 * 11 * 而String类默认重写了hashCode()和equals()方法。 12 * 13 * HashMap<String, String> 14 * 键:String 15 * 值:String 16 */ 17 public class HashMapDemo { 18 public static void main(String[] args) { 19 // 创建集合对象 20 HashMap<String, String> hm = new HashMap<String, String>(); 21 22 // 创建元素并添加元素 23 // String key1 = "it001"; 24 // String value1 = "马云"; 25 // hm.put(key1, value1); 26 27 // 添加元素到集合 28 hm.put("it001", "马云"); 29 hm.put("it003", "马化腾"); 30 hm.put("it004", "乔布斯"); 31 hm.put("it005", "张朝阳"); 32 hm.put("it002", "裘伯君"); 33 hm.put("it001", "比尔盖茨"); // 键相同,则值覆盖。 34 35 // 遍历集合 36 Set<String> set = hm.keySet(); 37 for (String key : set) { 38 String value = hm.get(key); 39 System.out.println(key + "---" + value); 40 } 41 } 42 } HashMapDemo.java 程序运行的结果为:it004---乔布斯 it003---马化腾 it005---张朝阳 it002---裘伯君 it001---比尔盖茨 b:HashMap<Integer, String> 1 package cn.itcast_02; 2 3 import java.util.HashMap; 4 import java.util.Set; 5 6 /* 7 * HashMap<Integer, String> 8 * 键:Integer 9 * 值:String 10 * 11 * 而Integer类默认也重写了hashCode()和equals()方法。 12 * 13 */ 14 public class HashMapDemo2 { 15 public static void main(String[] args) { 16 // 创建集合对象 17 HashMap<Integer, String> hm = new HashMap<Integer, String>(); 18 19 // 创建元素并添加元素 20 // Integer i = new Integer(27); 21 // Integer i = 27; // 自动装箱 22 // String s = "林青霞"; 23 // hm.put(i, s); 24 25 // 添加元素到集合 26 hm.put(35, "风清扬"); 27 hm.put(29, "林青霞"); 28 hm.put(27, "林青霞"); 29 hm.put(28, "刘意"); 30 31 32 // 0开头的表示的是八进制数据,下面的写法是八进制的写法,但是不能出现8以上的单个数据 33 // hm.put(003, "hello"); 34 // hm.put(006, "hello"); 35 // hm.put(007, "hello"); 36 // hm.put(008, "hello"); // 错误 37 38 // 遍历集合 39 Set<Integer> set = hm.keySet(); 40 for (Integer key : set) { 41 String value = hm.get(key); 42 System.out.println(key + "---" + value); 43 } 44 45 // 下面这种方式仅仅是集合元素的字符串表示,不是遍历 46 // System.out.println("hm:" + hm); 47 } 48 } HashMapDemo2.java 程序运行的结果为:35---风清扬 27---林青霞 28---刘意 29---林青霞 c:HashMap<String, Student> 1 package cn.itcast_02; 2 3 public class Student { 4 private String name; 5 private int age; 6 7 public Student() { 8 super(); 9 } 10 11 public Student(String name, int age) { 12 super(); 13 this.name = name; 14 this.age = age; 15 } 16 17 public String getName() { 18 return name; 19 } 20 21 public void setName(String name) { 22 this.name = name; 23 } 24 25 public int getAge() { 26 return age; 27 } 28 29 public void setAge(int age) { 30 this.age = age; 31 } 32 } Student.java 1 package cn.itcast_02; 2 3 import java.util.HashMap; 4 import java.util.Set; 5 6 /* 7 * HashMap<String, Student> 8 * 键:String 学号 9 * 值:Student 学生对象 10 */ 11 public class HashMapDemo3 { 12 public static void main(String[] args) { 13 // 创建集合对象 14 HashMap<String, Student> hm = new HashMap<String, Student>(); 15 16 // 创建学生对象 17 Student s1 = new Student("周星驰", 58); 18 Student s2 = new Student("刘德华", 55); 19 Student s3 = new Student("梁朝伟", 54); 20 Student s4 = new Student("郭富城", 50); 21 Student s5 = new Student("周星驰", 58); // 此时的学生对象是值,键值对的值是不具备唯一性的。 22 23 // 添加元素到集合 24 hm.put("9527", s1); 25 hm.put("9522", s2); 26 hm.put("9524", s3); 27 hm.put("9529", s4); 28 hm.put("9521", s5); 29 30 // 遍历集合 31 Set<String> set = hm.keySet(); 32 for (String key : set) { 33 Student value = hm.get(key); 34 System.out.println(key + "---" + value.getName() + "---" + value.getAge()); 35 } 36 } 37 } HashMapDemo3.java 程序运行的结果为:9521---周星驰---58 9524---梁朝伟---54 9522---刘德华---55 9529---郭富城---50 9527---周星驰---58 d:HashMap<Student, String> 1 package cn.itcast_02; 2 3 public class Student { 4 private String name; 5 private int age; 6 7 public Student() { 8 super(); 9 } 10 11 public Student(String name, int age) { 12 super(); 13 this.name = name; 14 this.age = age; 15 } 16 17 public String getName() { 18 return name; 19 } 20 21 public void setName(String name) { 22 this.name = name; 23 } 24 25 public int getAge() { 26 return age; 27 } 28 29 public void setAge(int age) { 30 this.age = age; 31 } 32 33 @Override 34 public int hashCode() { 35 final int prime = 31; 36 int result = 1; 37 result = prime * result + age; 38 result = prime * result + ((name == null) ? 0 : name.hashCode()); 39 return result; 40 } 41 42 @Override 43 public boolean equals(Object obj) { 44 if (this == obj) 45 return true; 46 if (obj == null) 47 return false; 48 if (getClass() != obj.getClass()) 49 return false; 50 Student other = (Student) obj; 51 if (age != other.age) 52 return false; 53 if (name == null) { 54 if (other.name != null) 55 return false; 56 } else if (!name.equals(other.name)) 57 return false; 58 return true; 59 } 60 61 } Student.java 1 package cn.itcast_02; 2 3 import java.util.HashMap; 4 import java.util.Set; 5 6 /* 7 * HashMap<Student, String> 8 * 键:Student 9 * 要求:如果键的成员变量值都相同,则为同一个对象。即:键相同,则值覆盖。 10 * 即:要手动重写键Student类的hashCode()和equals()方法。 11 * 值:String 12 */ 13 public class HashMapDemo4 { 14 public static void main(String[] args) { 15 // 创建集合对象 16 HashMap<Student, String> hm = new HashMap<Student, String>(); 17 18 // 创建学生对象 19 Student s1 = new Student("貂蝉", 27); 20 Student s2 = new Student("王昭君", 30); 21 Student s3 = new Student("西施", 33); 22 Student s4 = new Student("杨玉环", 35); 23 Student s5 = new Student("貂蝉", 27); // 此时的学生对象是键,而键值对的键具备唯一性。即:键相同,则值覆盖。 24 25 // 添加元素到集合 26 hm.put(s1, "8888"); 27 hm.put(s2, "6666"); 28 hm.put(s3, "5555"); 29 hm.put(s4, "7777"); 30 hm.put(s5, "9999"); 31 32 // 遍历集合 33 Set<Student> set = hm.keySet(); 34 for (Student key : set) { 35 String value = hm.get(key); 36 System.out.println(key.getName() + "---" + key.getAge() + "---" + value); 37 } 38 } 39 } HashMapDemo4.java 程序运行的结果为:王昭君---30---6666 貂蝉---27---9999 杨玉环---35---7777 西施---33---5555 C:LinkedHashMap集合的概述(唯一和有序) 是Map接口的哈希表和链表的实现类,具有可预知的迭代顺序。 由哈希表保证键的唯一性。 由链表保证键盘的有序(存储和取出的顺序一致)。 1 package cn.itcast_03; 2 3 import java.util.LinkedHashMap; 4 import java.util.Set; 5 6 /* 7 * LinkedHashMap:是Map接口的哈希表和链接列表实现类,具有可预知的迭代顺序。 8 * 由哈希表保证键的唯一性。 9 * 由链表保证键盘的有序(存储和取出的顺序一致)。 10 */ 11 public class LinkedHashMapDemo { 12 public static void main(String[] args) { 13 // 创建集合对象 14 LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>(); 15 16 // 创建并添加元素到集合 17 hm.put("2345", "hello"); 18 hm.put("1234", "world"); 19 hm.put("3456", "java"); 20 hm.put("1234", "javaee"); // 键相同,则值覆盖。 21 hm.put("3456", "android"); // 键相同,则值覆盖。 22 23 // 遍历结合 24 Set<String> set = hm.keySet(); 25 for (String key : set) { 26 String value = hm.get(key); 27 System.out.println(key + "---" + value); 28 } 29 } 30 } LinkedHashMapDemo.java 程序运行的结果为:2345---hello 1234---javaee 3456---android --------------------------------------- (6)TreeMap集合(排序和唯一) A:TreeMap类概述 是基于红黑树的Map接口的实现类。键是红黑树结构,可以保证键的排序和唯一性。 B:TreeMap集合的案例(注意:蓝色字体为键) a:TreeMap<String, String> 自然排序: String类默认实现了Comparable接口,重写了compareTo()方法,故而是自然排序。 1 package cn.itcast_04; 2 3 public class Student { 4 private String name; 5 private int age; 6 7 public Student() { 8 super(); 9 } 10 11 public Student(String name, int age) { 12 super(); 13 this.name = name; 14 this.age = age; 15 } 16 17 public String getName() { 18 return name; 19 } 20 21 public void setName(String name) { 22 this.name = name; 23 } 24 25 public int getAge() { 26 return age; 27 } 28 29 public void setAge(int age) { 30 this.age = age; 31 } 32 } Student.java 1 package cn.itcast_04; 2 3 import java.util.Set; 4 import java.util.TreeMap; 5 6 /* 7 * TreeMap:是基于红黑树的Map接口的实现类。 8 * 键是红黑树结构,可以保证键的排序和唯一性 9 * 10 * TreeMap<String, String> 11 * 键:String 12 * 值:String 13 * 14 * 自然排序: 15 * String类默认实现了Comparable接口,重写了compareTo()方法,故而是自然排序。 16 */ 17 public class TreeMapDemo { 18 public static void main(String[] args) { 19 // 创建集合对象 20 TreeMap<String, String> tm = new TreeMap<String, String>(); 21 22 // 创建元素并添加元素到集合 23 tm.put("hello", "你好"); 24 tm.put("world", "世界"); 25 tm.put("java", "爪哇"); 26 tm.put("world", "世界2"); // 键相同,则值覆盖。 27 tm.put("javaee", "爪哇EE"); 28 29 // 遍历集合 30 Set<String> set = tm.keySet(); 31 for (String key : set) { 32 String value = tm.get(key); 33 System.out.println(key + "---" + value); 34 } 35 } 36 } TreeMapDemo.java 程序运行的结果为:hello---你好 java---爪哇 javaee---爪哇EE world---世界2 b:TreeMap<Student, String> 比较器排序: 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。 1 package cn.itcast_04; 2 3 public class Student { 4 private String name; 5 private int age; 6 7 public Student() { 8 super(); 9 } 10 11 public Student(String name, int age) { 12 super(); 13 this.name = name; 14 this.age = age; 15 } 16 17 public String getName() { 18 return name; 19 } 20 21 public void setName(String name) { 22 this.name = name; 23 } 24 25 public int getAge() { 26 return age; 27 } 28 29 public void setAge(int age) { 30 this.age = age; 31 } 32 } Student.java 1 package cn.itcast_04; 2 3 import java.util.Comparator; 4 import java.util.Set; 5 import java.util.TreeMap; 6 7 /* 8 * TreeMap<Student, String> 9 * 键:Student 10 * 值:String 11 * 12 * 比较器排序: 13 * 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。 14 * 15 * 如果一个方法的参数是接口,那么真正需要的是接口的实现类的对象,而且该方法只调用一次。 16 * 所以使用匿名内部类就可以实现这个东西,这样就不用自己去重新写一个具体的实现类了。其实这种方式是很常见的。 17 */ 18 public class TreeMapDemo2 { 19 public static void main(String[] args) { 20 // 创建集合对象 21 TreeMap<Student, String> tm = new TreeMap<Student, String>( 22 new Comparator<Student>() { 23 @Override 24 public int compare(Student s1, Student s2) { 25 // 主要条件 26 int num = s1.getAge() - s2.getAge(); 27 // 次要条件 28 int num2 = (num == 0 ? s1.getName().compareTo(s2.getName()) : num); 29 return num2; 30 } 31 }); 32 33 // 创建学生对象 34 Student s1 = new Student("潘安", 30); 35 Student s2 = new Student("柳下惠", 35); 36 Student s3 = new Student("唐伯虎", 33); 37 Student s4 = new Student("燕青", 32); 38 Student s5 = new Student("唐伯虎", 33); // 键相同,则值覆盖。即最终唐伯虎是汉朝的。 39 40 // 添加元素到集合 41 tm.put(s1, "宋朝"); 42 tm.put(s2, "元朝"); 43 tm.put(s3, "明朝"); 44 tm.put(s4, "清朝"); 45 tm.put(s5, "汉朝"); 46 47 // 遍历集合 48 Set<Student> set = tm.keySet(); 49 for (Student key : set) { 50 String value = tm.get(key); 51 System.out.println(key.getName() + "---" + key.getAge() + "---" + value); 52 } 53 } 54 } TreeMapDemo2.java 程序运行的结果为:潘安---30---宋朝 燕青---32---清朝 唐伯虎---33---汉朝 柳下惠---35---元朝 --------------------------------------- (7)Map集合案例 A:统计一个字符串中每个字符出现的次数(要对着思路会写) 示例代码如下: 1 package cn.itcast_05; 2 3 import java.util.Scanner; 4 import java.util.Set; 5 import java.util.TreeMap; 6 7 /* 8 * 需求 :"aababcabcdabcde",获取字符串中每一个字母出现的次数。 9 * 要求输出结果的格式为 a(5)b(4)c(3)d(2)e(1) 10 * 11 * 分析: 12 * A:定义一个字符串(可以改进为键盘录入); 13 * B:定义一个TreeMap集合(为了使用其自带的排序功能); 14 * 键:Character 15 * 值:Integer 16 * Character类默认实现了Comparable接口,重写了compareTo()方法,故而是自然排序。 17 * C:把字符串转换为字符数组; 18 * D:遍历字符数组,得到每一个字符; 19 * E:拿得到的字符作为键到集合中去找值,看返回的值值: 20 * 如果是null:说明该键不存在,就把该字符作为键,把次数1作为值进行存储到集合中; 21 * 如果不是null:说明该键存在,就把值加1,然后重写存储该键和值到集合中。 22 * F:定义字符串缓冲区变量(对象); 23 * G:遍历集合,获取到每一个键和值,按照输出格式要求进行拼接; 24 * H:把字符串缓冲区内容转换为字符串输出。 25 * 26 * 测试: 27 * 录入:linqingxia 28 * 结果:result:a(1)g(1)i(3)l(1)n(2)q(1)x(1) 29 */ 30 public class TreeMapDemo { 31 public static void main(String[] args) { 32 // 定义一个字符串(可以改进为键盘录入) 33 Scanner sc = new Scanner(System.in); 34 System.out.println("请输入一个字符串:"); 35 String line = sc.nextLine(); 36 37 // 定义一个TreeMap集合 38 TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>(); 39 40 // 把字符串转换为字符数组 41 char[] chs = line.toCharArray(); 42 43 // 遍历字符数组,得到每一个字符 44 for(char ch : chs){ 45 // 拿刚才得到的字符作为键到集合中去找值,看返回值 46 Integer i = tm.get(ch); // 自动装箱 47 48 // 如果是null:说明该键不存在,就把该字符作为键,把次数1作为值进行存储到集合中 49 if(i == null){ 50 tm.put(ch, 1); 51 }else { 52 // 如果不是null:说明该键存在,就把值加1,然后重写存储该键和值到集合中 53 i++; // 自动拆箱,再自动装箱 54 tm.put(ch,i); 55 } 56 } 57 58 // 定义字符串缓冲区(对象) 59 StringBuilder sb= new StringBuilder(); 60 61 // 遍历集合,得到键和值,进行按照要求拼接 62 Set<Character> set = tm.keySet(); 63 for(Character key : set){ 64 Integer value = tm.get(key); // 得到键 65 sb.append(key).append("(").append(value).append(")"); // a(5)b(4)c(3)d(2)e(1) 66 } 67 68 // 把字符串缓冲区内容转换为字符串输出 69 String result = sb.toString(); 70 System.out.println("result:"+result); 71 } 72 } TreeMapDemo.java 程序运行的结果为: 请输入一个字符串: aababcabcdabcde result:a(5)b(4)c(3)d(2)e(1) B:集合的嵌套遍历(注意:蓝色字体为键) a:HashMap嵌套HashMap,即 HashMap<String, HashMap<String, Integer>> 1 package cn.itcast_05; 2 3 import java.util.HashMap; 4 import java.util.Set; 5 6 /* 7 * HashMap嵌套HashMap 8 * 9 * 存储的格式为: 10 * 传智播客 11 * 键 值 12 * jc---基础班 13 * 键 值 14 * 陈玉楼 ---20 15 * 高跃---22 16 * 17 * 键 值 18 * jy---就业班 19 * 键 值 20 * 李杰---21 21 * 曹石磊---23 22 * 输出形式为: 23 * jc 24 * 陈玉楼---20 25 * 高跃---22 26 * jy 27 * 李杰---21 28 * 曹石磊---23 29 * 30 * 先存储元素,然后遍历元素 31 */ 32 public class HashMapIncludeHashMapDemo { 33 public static void main(String[] args) { 34 // 创建传智播客集合对象 35 HashMap<String, HashMap<String, Integer>> czbkMap = new HashMap<String, HashMap<String, Integer>>(); 36 37 // 创建基础班集合对象 38 HashMap<String, Integer> jcMap = new HashMap<String, Integer>(); 39 // 添加元素到基础班集合 40 jcMap.put("陈玉楼", 20); 41 jcMap.put("高跃", 22); 42 // 把基础班添加到传智播客大集合 43 czbkMap.put("jc", jcMap); 44 45 // 创建就业班集合对象 46 HashMap<String, Integer> jyMap = new HashMap<String, Integer>(); 47 // 添加元素到就业班集合 48 jyMap.put("李杰", 21); 49 jyMap.put("曹石磊", 23); 50 // 把基础班添加到传智播客大集合 51 czbkMap.put("jy", jyMap); 52 53 // 遍历传智播客大集合 54 Set<String> czbkMapSet = czbkMap.keySet(); // 得到键 55 for(String czbkMapKey : czbkMapSet){ // 遍历键 56 System.out.println(czbkMapKey); // 输出键 57 HashMap<String, Integer> czbkMapValue = czbkMap.get(czbkMapKey); // 根据键获取值,返回的是值,该值是hashMap集合 58 // 遍历班级集合 59 Set<String> czbkMapValueSet = czbkMapValue.keySet(); // 得到键 60 for(String czbkMapValueKey : czbkMapValueSet){ // 遍历键 61 Integer czbkMapValueValue = czbkMapValue.get(czbkMapValueKey); // 根据键获取值,返回的是值 62 System.out.println("\t"+czbkMapValueKey+"---"+czbkMapValueValue); 63 } 64 } 65 } 66 } HashMapIncludeHashMapDemo.java 程序运行结果为:jc 高跃---22 陈玉楼---20 jy 曹石磊---23 李杰---21 b:HashMap嵌套ArrayList,即 HashMap<String, ArrayList<String>> 1 package cn.itcast_05; 2 3 import java.util.ArrayList; 4 import java.util.HashMap; 5 import java.util.Set; 6 7 /* 8 * HashMap结合嵌套ArrayList集合并遍历。 9 * 10 * 需求: 11 * 假设HashMap集合的元素是ArrayList。每个HashMap集合有3个ArrayList集合元素。 12 * 每一个ArrayList集合的值是字符串。每个ArrayList集合有2个元素。 13 * 元素我已经完成,请遍历。 14 * 15 * 存储的格式为: 16 * 键 值 17 * 三国演义---ArrayList 18 * 吕布 19 * 周瑜 20 * 笑傲江湖---ArrayList 21 * 令狐冲 22 * 林平之 23 * 神雕侠侣---ArrayList 24 * 郭靖 25 * 杨过 26 * 27 * 输出形式为: 28 * 三国演义 29 * 吕布 30 * 周瑜 31 * 笑傲江湖 32 * 令狐冲 33 * 林平之 34 * 神雕侠侣 35 * 郭靖 36 * 杨过 37 */ 38 public class HashMapIncludeArrayListDemo { 39 public static void main(String[] args) { 40 // 创建HashMap集合对象 41 HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>(); 42 43 // 创建元素集合1 44 ArrayList<String> array1 = new ArrayList<String>(); 45 array1.add("吕布"); 46 array1.add("周瑜"); 47 // 把元素添加到hm里面 48 hm.put("三国演义", array1); 49 50 // 创建元素集合2 51 ArrayList<String> array2 = new ArrayList<String>(); 52 array2.add("令狐冲"); 53 array2.add("林平之"); 54 // 把元素添加到hm里面 55 hm.put("笑傲江湖", array2); 56 57 // 创建元素集合3 58 ArrayList<String> array3 = new ArrayList<String>(); 59 array3.add("郭靖"); 60 array3.add("杨过"); 61 // 把元素添加到hm里面 62 hm.put("神雕侠侣", array3); 63 64 // 遍历HashMap集合 65 Set<String> set = hm.keySet(); // 得到键 66 for(String key : set){ // 遍历键 67 System.out.println(key); // 输出键 68 ArrayList<String> value = hm.get(key); // 根据键获取值,返回的是值,该值是ArrayList集合 69 // 遍历ArrayList集合 70 for(String s : value){ 71 System.out.println("\t" + s); 72 } 73 } 74 } 75 } HashMapIncludeArrayListDemo.java 程序的运行结果为:神雕侠侣 郭靖 杨过 三国演义 吕布 周瑜 笑傲江湖 令狐冲 林平之 c:ArrayList嵌套HashMap,即 ArrayList<HashMap<String, String>> 1 package cn.itcast_05; 2 3 import java.util.ArrayList; 4 import java.util.HashMap; 5 import java.util.Set; 6 7 /* 8 * ArrayList集合嵌套HashMap集合并遍历。 9 * 10 * 需求: 11 * 假设ArrayList集合的元素是HashMap。每个ArrayList集合有3个HashMap集合元素。 12 * 每一个HashMap集合的键和值都是字符串。每个HashMap集合有2个元素。 13 * 元素我已经完成,请遍历。 14 * 15 *输出形式为: 16 * ArrayList 17 * 键 值 18 * 周瑜---小乔 19 * 吕布---貂蝉 20 * 21 * 郭靖---黄蓉 22 * 杨过---小龙女 23 * 24 * 令狐冲---任盈盈 25 * 林平之---岳灵珊 26 */ 27 public class ArrayListIncludeHashMapDemo { 28 public static void main(String[] args) { 29 // 创建ArrayList集合对象 30 ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>(); 31 32 // 创建元素集合1 33 HashMap<String, String> hm1 = new HashMap<String, String>(); 34 hm1.put("周瑜", "小乔"); 35 hm1.put("吕布", "貂蝉"); 36 // 把元素添加到array里面 37 array.add(hm1); 38 39 // 创建元素集合2 40 HashMap<String, String> hm2 = new HashMap<String, String>(); 41 hm2.put("郭靖", "黄蓉"); 42 hm2.put("杨过", "小龙女"); 43 // 把元素添加到array里面 44 array.add(hm2); 45 46 // 创建元素集合3 47 HashMap<String, String> hm3 = new HashMap<String, String>(); 48 hm3.put("令狐冲", "任盈盈"); 49 hm3.put("林平之", "岳灵珊"); 50 // 把元素添加到array里面 51 array.add(hm3); 52 53 // 遍历ArrayList集合 54 for (HashMap<String, String> hm : array) { 55 // 遍历HashMap集合 56 Set<String> set = hm.keySet(); // 得到键 57 for (String key : set) { 58 String value = hm.get(key); // 根据键获取值,返回的是值 59 System.out.println(key + "---" + value); 60 } 61 System.out.println(); 62 } 63 } 64 } ArrayListIncludeHashMapDemo.java 程序运行结果为:吕布---貂蝉 周瑜---小乔 杨过---小龙女 郭靖---黄蓉 令狐冲---任盈盈 林平之---岳灵珊 d:HashMap嵌套HashMap嵌套ArrayList(多层嵌套),即 HashMap<String, HashMap<String, ArrayList<Student>>> 1 package cn.itcast_06; 2 3 import java.util.ArrayList; 4 import java.util.HashMap; 5 import java.util.Set; 6 7 /* 8 * HashMap嵌套HashMap嵌套ArrayList(多层嵌套) 9 * 10 * 为了更符合要求: 11 * 这次的数据是学生对象。 12 * 13 * 存储的格式为: 14 * 传智播客 15 * 键 值 16 * bj---北京校区 17 * 键 值 18 * jc---基础班 19 * ArrayList集合 20 * 林青霞--- 27 21 * 风清扬---30 22 * jy---就业班 23 * 赵雅芝---28 24 * 武鑫---29 25 * sh---上海校区 26 * jc---基础班 27 * 郭美美---20 28 * 犀利哥---22 29 * jy---就业班 30 * 罗玉凤---21 31 * 马征---23 32 * gz---广州校区 33 * jc---基础班 34 * 王力宏---30 35 * 李静磊---32 36 * jy---就业班 37 * 郎朗---31 38 * 柳岩---33 39 * xa---西安校区 40 * jc---基础班 41 * 范冰冰---27 42 * 刘意---30 43 * jy---就业班 44 * 李冰冰---28 45 * 张志豪---29 46 * 输出形式为: 47 * bj 48 * jc 49 * 林青霞---27 50 * 风清扬---30 51 * jy 52 * 赵雅芝---28 53 * 武鑫---29 54 * xa 55 * jc 56 * 范冰冰---27 57 * 刘意---30 58 * jy 59 * 李冰冰---28 60 * 张志豪---29 61 */ 62 public class HashMapIncludeHashMapIncludeArrayListDemo { 63 public static void main(String[] args) { 64 // 创建传智播客大集合对象 65 HashMap<String, HashMap<String, ArrayList<Student>>> czbkMap = new HashMap<String, HashMap<String, ArrayList<Student>>>(); 66 67 // 创建北京校区集合对象 68 HashMap<String, ArrayList<Student>> bjCzbkMap = new HashMap<String, ArrayList<Student>>(); 69 70 // 创建基础班集合对象 71 ArrayList<Student> array1 = new ArrayList<Student>(); 72 // 创建学生对象 73 Student s1 = new Student("林青霞", 27); 74 Student s2 = new Student("风清扬", 30); 75 // 把学生对象添加进基础班集合 76 array1.add(s1); 77 array1.add(s2); 78 79 // 创建就业班集合对象 80 ArrayList<Student> array2 = new ArrayList<Student>(); 81 // 创建学生对象 82 Student s3 = new Student("赵雅芝", 28); 83 Student s4 = new Student("武鑫", 29); 84 // 把学生对象添加进就业班集合 85 array2.add(s3); 86 array2.add(s4); 87 88 // 把基础班添加到北京校区集合 89 bjCzbkMap.put("jc", array1); 90 // 把就业班添加到北京校区集合 91 bjCzbkMap.put("jy", array2); 92 // 把北京校区添加到传智播客大集合 93 czbkMap.put("bj", bjCzbkMap); 94 95 // 上海校区数据自己做 96 // 广州校区数据自己做 97 98 // 创建西安校区集合对象(同理) 99 HashMap<String, ArrayList<Student>> xaCzbkMap = new HashMap<String, ArrayList<Student>>(); 100 ArrayList<Student> array3 = new ArrayList<Student>(); 101 Student s5 = new Student("范冰冰", 27); 102 Student s6 = new Student("刘意", 30); 103 array3.add(s5); 104 array3.add(s6); 105 ArrayList<Student> array4 = new ArrayList<Student>(); 106 Student s7 = new Student("李冰冰", 28); 107 Student s8 = new Student("张志豪", 29); 108 array4.add(s7); 109 array4.add(s8); 110 xaCzbkMap.put("jc", array3); 111 xaCzbkMap.put("jy", array4); 112 czbkMap.put("xa", xaCzbkMap); 113 114 // 遍历传智播客大集合 115 Set<String> czbkMapSet = czbkMap.keySet(); // 得到键 116 for (String czbkMapKey : czbkMapSet) { // 遍历键 117 System.out.println(czbkMapKey); // 输出键 118 HashMap<String, ArrayList<Student>> czbkMapValue = czbkMap.get(czbkMapKey); // 根据键获取值,返回的是值,该值是hashMap集合 119 // 遍历北京校区集合 120 Set<String> czbkMapValueSet = czbkMapValue.keySet(); // 得到键 121 for (String czbkMapValueKey : czbkMapValueSet) { // 遍历键 122 System.out.println("\t" + czbkMapValueKey); // 输出键 123 ArrayList<Student> czbkMapValueValue = czbkMapValue.get(czbkMapValueKey); // 根据键获取值,返回的是值,该值是ArrayList集合 124 // 遍历ArrayList集合 125 for (Student s : czbkMapValueValue) { 126 System.out.println("\t\t" + s.getName() + "---" + s.getAge()); 127 } 128 } 129 } 130 } 131 } HashMapIncludeHashMapIncludeArrayListDemo.java 程序运行结果为:bj jc 林青霞---27 风清扬---30 jy 赵雅芝---28 武鑫---29 xa jc 范冰冰---27 刘意---30 jy 李冰冰---28 张志豪---29 --------------------------------------- (8)面试题 a:HashMap类和Hashtable类的区别(注意:Hashtable的第二个单词是小写,继承了老版本jdk1.0的命名错误,如同System类下的静态方法Arraycopy()一样) HashMap类:不同步,线程不安全,效率高。允许null键和null值。 Hashtable类:同步,线程安全,效率低。不允许null键和null值。 其实HashMap类就是用来替代Hashtable类的。如同ArrayList类用来替代Vector类一样。 b:List、Set、Map等接口是否都继承自Map接口? List、Set不是继承自Map接口,它们继承自Collection接口。 Map接口本身就是一个顶层接口。 1 package cn.itcast_07; 2 3 import java.util.Hashtable; 4 5 /* 6 * 1:HashMap类和Hashtable类的区别? 7 * HashMap类:不同步,线程不安全,效率高。允许null键和null值。 8 * Hashtable类:同步,线程安全,效率低。不允许null键和null值。 9 * 其实HashMap类就是用来替代Hashtable类的。如同ArrayList类用来替代Vector类一样。 10 * 11 * 2:List、Set、Map等接口是否都继承自Map接口? 12 * List、Set不是继承自Map接口,它们继承自Collection接口。 13 * Map接口本身就是一个顶层接口。 14 */ 15 public class HashtableDemo { 16 public static void main(String[] args) { 17 // HashMap<String, String> hm = new HashMap<String, String>(); 18 // hm.put("it001", "hello"); 19 // hm.put(null, "world"); 20 // hm.put("java", null); 21 22 23 Hashtable<String, String> hm = new Hashtable<String, String>(); 24 hm.put("it001", "hello"); 25 hm.put(null, "world"); // NullPointerException 空指针异常 26 hm.put("java", null); // NullPointerException 空指针异常 27 28 System.out.println(hm); 29 } 30 } ----------------------------------------------------------------------------- 2:Collections工具类(理解) (1)Collections类的概述 是针对集合进行操作的工具类,都是静态方法。在java.util包下,父类是Object。 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。 (2)面试题:Collection和Collections的区别 a:Collection接口:是单列集合的顶层接口,有两个子接口List和Set。(Map是双列集合的顶层接口) b:Collections工具类:是针对集合进行操作的工具类,有对集合进行排序和二分查找的方法等。 (3)Collections工具类的常见成员方法 A:public static <T> void sort(List<T> list) 排序(默认情况下是自然顺序) B:public static <T> int binarySearch(List<?> list,T key) 二分查找(前提集合有序),若找到,则返回的是索引值;若找不到,则返回的是 -(元素个数+1) C:public static <T> T max(Collection<?> coll) 最大值 D:public static void reverse(List<?> list) 反转 E:public static void shuffle(List<?> list) 随机置换 1 package cn.itcast_01; 2 3 import java.util.Collections; 4 import java.util.List; 5 import java.util.ArrayList; 6 7 /* 8 * Collections:是针对集合进行操作的工具类,都是静态方法。 9 * 是针对集合进行操作的工具类,都是静态方法。在java.util包下,父类是Object。 10 * 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。 11 * 12 * 面试题: 13 * Collection和Collections的区别? 14 * Collection接口:是单列集合的顶层接口,有子接口List和Set。(Map是双列集合的顶层接口) 15 * Collections工具类:是针对集合操作的工具类,有对集合进行排序和二分查找的方法等。 16 * 17 * Collections类的常见成员方法: 18 * public static <T> void sort(List<T> list) 排序(默认情况下是自然顺序) 19 * public static <T> int binarySearch(List<?> list,T key) 二分查找(前提集合有序),若找到,则返回的是索引值;若找不到,则返回的是 -(元素个数+1) 20 * public static <T> T max(Collection<?> coll) 最大值 21 * public static void reverse(List<?> list) 反转 22 * public static void shuffle(List<?> list) 随机置换 23 * 24 * Integer类和String类都默认实现了Comparable接口,重写了compareTo()方法,故而是自然排序。 25 * 但是自定义对象默认没有实现Comparable接口。 26 */ 27 public class CollectionsDemo { 28 public static void main(String[] args) { 29 // 创建集合对象,List接口是集合,以List进行举例 30 List<Integer> list = new ArrayList<Integer>(); 31 32 // 添加元素 33 list.add(30); // 自动装箱 34 list.add(20); 35 list.add(50); 36 list.add(10); 37 list.add(40); 38 39 System.out.println("list:" + list); // list:[30, 20, 50, 10, 40] 40 41 // public static <T> void sort(List<T> list) 排序(默认情况下是自然顺序) 42 // Collections.sort(list); 43 // System.out.println("list:" + list); // list:[10, 20, 30, 40, 50] 44 45 // public static <T> int binarySearch(List<?> list,T key) 二分查找(前提集合有序),若找到,则返回的是索引值;若找不到,则返回的是 -(元素个数+1) 46 // System.out.println("binarySearch:" + Collections.binarySearch(list, 30)); // binarySearch:2 47 // System.out.println("binarySearch:" + Collections.binarySearch(list, 300));// binarySearch:-6 48 49 // public static <T> T max(Collection<?> coll) 最大值 50 // System.out.println("max:" + Collections.max(list)); // max:50 51 52 // public static void reverse(List<?> list) 反转 53 // Collections.reverse(list); // list:[40, 10, 50, 20, 30] 54 // System.out.println("list:" + list); 55 56 // public static void shuffle(List<?> list) 随机置换 57 Collections.shuffle(list); 58 System.out.println("list:" + list); 59 } 60 } CollectionsDemo.java (4)Collections工具类的案例 A:ArrayList集合存储自定义对象的排序 Collections可以针对ArrayList存储基本包装类的元素可以排序,存储自定义对象可不可以排序呢? 因为Integer类和String类都默认实现了Comparable接口,重写了compareTo()方法,故而自然排序。 但是自定义对象默认没有实现Comparable接口,所以不能进行自然排序。 示例代码如下:(注意:示例代码中既有自然排序也有比较器排序) 1 package cn.itcast_02; 2 3 /** 4 * @author Administrator 5 * 6 */ 7 public class Student implements Comparable<Student> { 8 private String name; 9 private int age; 10 11 public Student() { 12 super(); 13 } 14 15 public Student(String name, int age) { 16 super(); 17 this.name = name; 18 this.age = age; 19 } 20 21 public String getName() { 22 return name; 23 } 24 25 public void setName(String name) { 26 this.name = name; 27 } 28 29 public int getAge() { 30 return age; 31 } 32 33 public void setAge(int age) { 34 this.age = age; 35 } 36 37 @Override 38 public int compareTo(Student s) { 39 int num = this.age - s.age; // 从上到下,从小到大,顺序,升序 40 int num2 = (num == 0 ? this.name.compareTo(s.name) : num); 41 return num2; 42 } 43 44 } 1 package cn.itcast_02; 2 3 import java.util.ArrayList; 4 import java.util.Collections; 5 import java.util.Comparator; 6 import java.util.List; 7 8 /* 9 * Collections可以针对ArrayList存储基本包装类的元素排序,存储自定义对象可不可以排序呢? 10 */ 11 public class CollectionsDemo { 12 public static void main(String[] args) { 13 // 创建集合对象,List接口是集合,以List进行举例 14 List<Student> list = new ArrayList<Student>(); 15 16 // 创建学生对象 17 Student s1 = new Student("林青霞", 27); 18 Student s2 = new Student("风清扬", 30); 19 Student s3 = new Student("刘晓曲", 28); 20 Student s4 = new Student("武鑫", 29); 21 Student s5 = new Student("林青霞", 27); 22 23 // 添加元素对象到集合 24 list.add(s1); 25 list.add(s2); 26 list.add(s3); 27 list.add(s4); 28 list.add(s5); 29 30 // 调用Collections工具类中的方法使得ArrayList集合进行排序 31 // 方式一:自然排序 32 // Collections.sort(list); // 从上到下,从小到大,顺序,升序 33 // 如果学生类中的元素要想能够进行自然排序,学生类就必须实现自然排序接口,然后在学生类中重写compareTo()方法。否则编译就通不过。 34 35 // 如何去除ArrayList集合中的重复元素呢? 36 // 步骤一:我们需要重写自定义对象学生类中的equals()方法,自动生成即可。 37 // 步骤二:创建新集合; 38 // 步骤三:遍历旧集合,获取得到每一个元素;拿这个元素到新集合去找,看有没有,新集合中没有该元素就添加,有就不搭理它; 39 // 步骤四:遍历新集合。 40 // 综上:我们可以写一个去除ArrayList集合中的重复元素的功能。 41 42 // 这样我们通过Collectins工具类中的排序方法和去除ArrayList集合中的重复元素的功能, 43 // 就能实现ArrayList集合的排序和去重复元素了!!! 44 // 这个时候我还要Set集合、Map结合干嘛呢!!! 45 // 因为我的ArrayList集合就能干所有的事情了!!! 46 47 // 方式二:比较器排序,一般用匿名内部类实现,在匿名内部类中重写compare()方法。 48 // 如果同时有自然排序和比较器排序,则以比较器排序为主。 49 Collections.sort(list, new Comparator<Student>() { 50 // @Override 51 // public int compare(Student s1, Student s2) { 52 // return 0; 53 // } 54 55 @Override 56 public int compare(Student s1, Student s2) { 57 int num = s2.getAge() - s1.getAge(); // 从上到下,从大到小,倒序,降序 58 int num2 = (num == 0 ? s1.getName().compareTo(s2.getName()) : num); 59 return num2; 60 } 61 }); 62 63 // 遍历集合 64 for (Student s : list) { 65 System.out.println(s.getName() + "---" + s.getAge()); 66 } 67 } 68 } B:模拟斗地主洗牌和发牌 1 package cn.itcast_03; 2 3 import java.util.ArrayList; 4 import java.util.Collections; 5 6 /* 7 * 模拟斗地主洗牌和发牌 8 * 9 * 分析: 10 * A:创建一个牌盒(集合) 11 * B:装牌 12 * C:洗牌 13 * D:发牌 14 * E:看牌 15 */ 16 public class PokerDemo { 17 public static void main(String[] args) { 18 // 创建一个牌盒(集合) 19 ArrayList<String> array = new ArrayList<String>(); 20 21 // 装牌 22 // 牌的組成: 23 // 黑桃A,黑桃2,黑桃3,...,黑桃K 24 // 红桃A,... 25 // 梅花A,... 26 // 方块A,... 27 // 定义一个花色字符串数组 28 String[] colors = { "", "", "", "" }; 29 // 定义一个点数字符串数组 30 String[] numbers = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" }; 31 // 装牌 32 // 增强for遍历花色(外循环) 4组X每组13个 A 2 3 ... Q K A 2 3 ... Q K A 2 3 ... Q K A 2 3 ... Q K 33 for (String color : colors) { 34 // 增强for遍历色数字(内循环) 35 for (String number : numbers) { 36 array.add(color.concat(number)); 37 } 38 } 39 array.add("小王"); 40 array.add("大王"); 41 42 System.out.println("array:" + array); // array:[A, 2, ... Q, K, A, 2, ... Q, K, A, 2, ... Q, K, A, 2, ... Q, K, 小王, 大王] 43 44 // 洗牌 45 Collections.shuffle(array); 46 47 System.out.println("array:" + array); 48 49 // 发牌 50 ArrayList<String> fengQingYang = new ArrayList<String>(); 51 ArrayList<String> linQingXia = new ArrayList<String>(); 52 ArrayList<String> liuYi = new ArrayList<String>(); 53 ArrayList<String> diPai = new ArrayList<String>(); 54 55 // int size() 元素的个数(即集合的长度) array.size() 集合的长度为54 56 for (int x = 0; x < array.size(); x++) { 57 if (x >= array.size() - 3) { // 51 >= 54 - 3 = 51 58 diPai.add(array.get(x)); // array.get(x) x是索引,当x = 51时,表示的是第52张牌 59 } else if (x % 3 == 0) { 60 fengQingYang.add(array.get(x)); 61 } else if (x % 3 == 1) { 62 linQingXia.add(array.get(x)); 63 } else if (x % 3 == 2) { 64 liuYi.add(array.get(x)); 65 } 66 } 67 68 // 看牌 69 lookPoker("风清扬", fengQingYang); 70 lookPoker("林青霞", linQingXia); 71 lookPoker("刘意", liuYi); 72 lookPoker("底牌", diPai); 73 } 74 75 public static void lookPoker(String name, ArrayList<String> array) { 76 System.out.print(name + "的牌是:"); 77 for (String s : array) { 78 System.out.print(s + " "); 79 } 80 System.out.println(); 81 } 82 } PokerDemo.java C:模拟斗地主洗牌和发牌并对牌进行排序 1 package cn.itcast_04; 2 3 import java.util.ArrayList; 4 import java.util.Collections; 5 import java.util.HashMap; 6 import java.util.TreeSet; 7 8 /* 9 * 模拟斗地主洗牌和发牌并对牌进行排序 10 * 11 * 思路: 12 * A:创建一个HashMap集合(键值对:存储制定的规则) 13 * B:创建一个ArrayList集合(创建一个牌盒) 14 * C:创建点数字符串数组和花字符串色数组 15 * D:从0开始往HashMap里面存储编号(键),并存储对应的牌(值),同时往ArrayList里面存储编号即可。 16 * E:洗牌(洗的是编号) 17 * F:发牌(发的也是编号,为了保证编号是排序的,就创建TreeSet集合接收,因为TreeSet集合保证元素排序和唯一性) 18 * G:看牌(遍历TreeSet集合,获取编号后,到HashMap集合找对应的牌) 19 */ 20 public class PokerDemo { 21 public static void main(String[] args) { 22 // 创建一个HashMap集合(键值对:存储制定的规则) 23 HashMap<Integer, String> hm = new HashMap<Integer, String>(); 24 25 // 创建一个ArrayList集合(创建一个牌盒) 26 ArrayList<Integer> array = new ArrayList<Integer>(); 27 28 // 创建点数字符串数组和花色字符串数组 29 // 定义一个点数字符串数组 30 String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2", }; 31 // 定义一个花色字符串数组 32 String[] colors = { "", "", "", "" }; 33 34 // 从0开始往HashMap里面存储编号(键),并存储对应的牌(值),同时往ArrayList里面存储编号即可。 35 int index = 0; 36 // 增强for遍历色数字(外循环) 13组X每组4个 3 3 3 3 4 4 4 4 ...... A A A A 2 2 2 2 37 for (String number : numbers) { 38 // 增强for遍历花色(内循环) 39 for (String color : colors) { 40 String poker = color.concat(number); 41 hm.put(index, poker); 42 array.add(index); 43 index++; 44 } 45 } 46 hm.put(index, "小王"); 47 array.add(index); 48 index++; 49 hm.put(index, "大王"); 50 array.add(index); 51 52 // 洗牌(洗的是编号) 53 Collections.shuffle(array); 54 55 // 发牌(发的也是编号,为了保证编号是排序的,就创建TreeSet集合接收,因为TreeSet集合保证元素排序和唯一性) 56 TreeSet<Integer> fengQingYang = new TreeSet<Integer>(); 57 TreeSet<Integer> linQingXia = new TreeSet<Integer>(); 58 TreeSet<Integer> liuYi = new TreeSet<Integer>(); 59 TreeSet<Integer> diPai = new TreeSet<Integer>(); 60 61 // int size() 元素的个数(即集合的长度) array.size() 集合的长度为54 62 for (int x = 0; x < array.size(); x++) { 63 if (x >= array.size() - 3) { // 51 >= 54 - 3 = 51 64 diPai.add(array.get(x)); // array.get(x) x是索引,当x = 51时,表示的是第52张牌 65 } else if (x % 3 == 0) { 66 fengQingYang.add(array.get(x)); 67 } else if (x % 3 == 1) { 68 linQingXia.add(array.get(x)); 69 } else if (x % 3 == 2) { 70 liuYi.add(array.get(x)); 71 } 72 } 73 74 // 看牌(遍历TreeSet集合,获取编号后,到HashMap集合找对应的牌) 75 lookPoker("风清扬", fengQingYang, hm); 76 lookPoker("林青霞", linQingXia, hm); 77 lookPoker("刘意", liuYi, hm); 78 lookPoker("底牌", diPai, hm); 79 } 80 81 // 写看牌的功能 82 public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) { 83 System.out.print(name + "的牌是:"); 84 for (Integer key : ts) { // 遍历键 85 String value = hm.get(key); // 根据键,获取对应的值 86 System.out.print(value + " "); 87 } 88 System.out.println(); 89 } 90 } PokerDemo.java =============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_常用类02_Scanner类和String类_day12总结

==========================================================================================================================================================涉及到的知识点有: 1:Scanner类的概述和使用(了解) (1)Scanner类的概述 (2)Scanner类的构造方法 (3)Scanner类的成员方法 2:String类的概述和使用(掌握) (1)String类的概述 (2)String类的构造方法 (3)字符串的特点 (4)字符串的面试题(看程序写结果) (5)字符串的功能 (6)字符串的案例==========================================================================================================================================================1:Scanner类的概述和使用(了解) (1)Scanner类的概述 在JDK5以后出现的用于键盘录入数据的类。 是一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。 --------------------------------------- (2)Scanner类的构造方法 A:讲解了System.in这个东西。 它其实是标准的输入流,对应于键盘录入 B:构造方法 InputStream is = System.in; public Scanner(InputStream is) C:常用的格式 Scanner sc = new Scanner(System.in);--------------------------------------- (3)Scanner类的成员方法 1.基本方法的格式: A:public boolean hasNextXxx() 即判断下一个输入项是否是某种类型的。 其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串,则可以省略Xxx。 B:public Xxx nextXxx() 获取某种类型的元素,即返回某种类型的元素。 Xxx的含义和上个方法中的Xxx相同。--------------------------------------- 2.要掌握的两个常用方法: A:public int nextInt() 获取一个int类型的值 B:public String nextLine() 获取一个String类型的值--------------------------------------- 3.需要注意的小问题: 对于同一个扫描器对象,若先获取一个数值,再获取一个字符串,会出现问题。 即:先nextInt()然后nextLine()的问题。 主要原因:就是那个换行符号的问题。 如何解决呢? A:先用键盘录入对象获取一个数值后,再创建一个新的键盘录入对象用来获取字符串。 B:把所有的数据都先按照字符串获取,然后要什么,你就对应的转换成什么。----------------------------------------------------------------------------- 2:String类的概述和使用(掌握) (1)String类的概述 字符串是由多个字符组成的一串数据(字符序列)。 字符串可以看成是字符数组,即它可以和字符数组进行相互转换。 在实际开发中,字符串的操作是最常见的操作,没有之一。 而Java没有内置的字符串类型,所以,就在Java类库中提供了一个类String 供我们来使用。--------------------------------------- (2)String类的构造方法 A:public String() 无参构造,即创建一个空内容的字符串对象。 B:public String(byte[] bytes) 把字节数组转成字符串,即使用一个字节数组构建一个字符串对象。 C:public String(char[] value) 把字符数组转成字符串,即使用一个字符数组构建一个字符串对象。 D:public String(byte[] bytes, int offset, int length) 把字节数组的一部分转成字符串,即使用一个字节数组构建一个字符串对象,指定开始的索引值,与使用的字节个数。 E:public String(char[] value, int offset, int count) 把字符数组的一部分转成字符串,即使用一个字符数组构建一个字符串对象,指定开始的索引值,与使用的字符个数。 F:public String(String original) 把字符串常量值转成一个字符串对象。 String s = new String("hello"); 这种构造方法会创建两个或一个对象。 G:String s = "hello"; 虽然不是构造方法,但是结果也是一个字符串对象。这种直接赋值的方法会创建一个或零个对象。 String 类代表字符串。Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现。--------------------------------------- (3)字符串的特点 A:字符串是常量,字符串的内容一旦被赋值,就不能被改变。 注意:这里指的是字符串的内容不能改变,而不是引用不能改变,引用可以改变。 即:字符串的内容会在字符串常量池里。每一个字符串的内容会有一个地址值。 B:字面值作为字符串对象和通过构造方法创建对象的不同? String s1 = new String("hello"); String s2 = "hello"; System.out.println(s1 == s2); // false System.out.println(s1.equals(s2)); // true ==(等号的比较的是): 基本类型:比较的就是值是否相同。 引用类型:比较的就是地址值是否相同。 equals(该方法比较的是): 只能是引用类型:默认情况下,比较的是地址值。 不过,我们可以根据情况自己重写该方法。一般重写都是自动生成,比较的是对象的成员变量值是否相同。 equals: 比较引用类型默认也是比较地址值是否相同,而String类重写了equals()方法,比较的是内容是否相同。内存如下图所示01/02: --------------------------------------- (4)字符串的面试题(看程序写结果) A:==和equals() String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2); // false System.out.println(s1.equals(s2)); // true String s3 = new String("hello"); String s4 = "hello"; System.out.println(s3 == s4); // false System.out.println(s3.equals(s4)); // true String s5 = "hello"; String s6 = "hello"; System.out.println(s5 == s6); // true System.out.println(s5.equals(s6)); // true B:字符串的拼接 String s1 = "hello"; String s2 = "world"; String s3 = "helloworld"; System.out.println(s3 == s1 + s2); // false 字符串为变量时 System.out.println(s3.equals((s1 + s2))); // true System.out.println(s3 == "hello" + "world"); // true 字符串为常量时 System.out.println(s3.equals("hello" + "world")); // true 注意: 字符串如果是变量相加,先开空间,再拼接。 字符串如果是常量相加,是先加,然后在常量池找,如果有就直接返回,否则,就创建。--------------------------------------- (5)字符串的功能 A:String类的判断功能 public boolean equals(Object obj) 比较字符串的内容是否相同,区分大小写 public boolean equalsIgnoreCase(String str) 比较字符串的内容是否相同,忽略大小写 public boolean contains(String str) 判断大字符串中是否包含小字符串 public boolean startsWith(String str) 判断字符串是否以某个指定的字符串开头 public boolean endsWith(String str) 判断字符串是否以某个指定的字符串结尾 public boolean isEmpty() 判断字符串是否为空 注意: String s = ""; //字符串内容为空。 String s = null; //字符串对象为空。对象都不存在,所以不能调用方法,如果去调用方法,会出现空指针异常。--------------------------------------- B:String类的获取功能 public int length() 获取字符串的长度(字符个数)。 public char charAt(int index) 获取指定索引位置的字符。 public int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 注意:形参为什么这里是int类型,而不是char类型? 原因是:'a'和97其实都可以代表'a'。形参为int类型时写'a'和97都可以,而为char类型时则只能写'a'了。 public int indexOf(String str) 返回指定字符串在此字符串中第一次出现处的索引。 public int indexOf(int ch, int fromIndex) 返回指定字符在此字符串中从指定位置后第一次出现处的索引。 public int indexOf(String str, int fromIndex) 返回指定字符串在此字符串中从指定位置后第一次出现处的索引。 public String substring(int start) 从指定位置开始截取字符串,默认到末尾(包含start这个索引)。 public String substring(int start, int end) 从指定位置开始到指定位置结束截取字符串(包括start索引但是不包end索引)。--------------------------------------- C:String类的转换功能 public byte[] getBytes() 把字符串转换为字节数组。 public char[] toCharArray() 把字符串转换为字符数组。 public static String valueOf(char[] chs) 把字符数组转成字符串。(方法重载) public static String valueOf(int i) 把int类型的数据转成字符串。(方法重载) 注意:String类的valueOf方法可以把任意类型的数据转成字符串。 public String toLowerCase() 把字符串转成小写。(注意:原串不变,生成的新串变为小写的) public String toUpperCase() 把字符串转成大写。(注意:原串不变,生成的新串变为小写的) public String concat(String str) 把字符串进行拼接。--------------------------------------- D:String类的其他功能 a:替换功能 public String replace(char old, char new) public String replace(String old, String new) b:去除字符串两端空格功能 public String trim() c:按字典顺序比较两个字符串功能 public int compareTo(String str) public int compareToIgnoreCase(String str) 示例: String s1 = "hello"; String s2 = "hello"; String s3 = "abc"; String s4 = "xyz"; System.out.println(s1.compareTo(s2)); // 0 System.out.println(s1.compareTo(s3)); // 7 System.out.println(s1.compareTo(s4)); // -16 比较不一样的时候,就用前一个串的第一个字符的ASCII减去后一个串的第一个字符的ASCII,得到一个int值返回。 若第一个字符相同,则比较第二个字符,以此类推。若都相同,则返回int值0。 若如下这样,查看该方法源码可知,返回的是第一个串比第二个串多的字符个数。 String s5 = "hello"; String s6 = "hel"; System.out.println(s5.compareTo(s6)); // -2--------------------------------------- (6)字符串的案例 A:模拟用户登录 B:字符串的遍历 C:统计字符串中大写、小写及数字字符的个数 D:把字符串的首字母转成大写,其他转成小写 E:把int数组拼接成一个指定格式的字符串输出 F:字符串反转 G:统计大串中小串出现的次数=============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 15)——请注意数字类型之间的转换

在C、Objective-C和Java等其他语言中,整型之间有两种转换方法: 从小范围数到大范围数转换是自动的; 从大范围数到小范围数需要强制类型转换,有可能造成数据精度的丢失。 而在Swift中这两种方法是行不通的,需要通过一些函数进行显式地转换,代码如下: 1 2 3 4 5 lethistoryScore:UInt8= 90 letenglishScore:UInt16= 130 lettotalScore=historyScore+englishScore //错误 程序就会有编译错误,原因是historyScore是UInt8类型,而englishScore是UInt16类型,它们之间不能转换。 两种转换方法: 一种是把UInt8的historyScore转换为UInt16类型。由于是从小范围数转换为大范围数,这种转换是安全的。 代码: 1 2 lettotalScore=UInt16(historyScore)+englishScore // 是正确的转换方法 。 另外一种是把UInt16的englishScore转换为UInt8类型。由于是从大范围数转换为小范围数,这种转换是不安全的,如果转换的数比较大可能会造成精度的丢失。 代码: 1 2 lettotalScore=historyScore+UInt8(englishScore) // 是正确的转换方法。 本例中englishScore的值是130,这个转换是成功的,如果把这个数修改为1300,虽然程序编译没有问题,但是会在控制台中输出异常信息。 整型与浮点型之间的转换 整型与浮点型之间的转换与整型之间的转换类似: 1 2 3 4 5 6 7 8 9 lethistoryScore:Float= 90.6 letenglishScore:UInt16= 130 lettotalScore=historyScore+englishScore //错误 lettotalScore=historyScore+Float(englishScore) //正确,安全 lettotalScore=UInt16(historyScore)+englishScore //正确,小数被截掉 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1746109,如需转载请自行联系原作者

优秀的个人博客,低调大师

Android Day05-网络编程之文件下载之多线程断点续传技术

文件下载之多线程断点续传技术底层实现 通过HttpURLConnection连接 断点续传核心步骤: 1.UI设计 2.获取服务器文件的大小,通过连接的一个方法getContentLength()来得到。 3.在客户端创建一个和将要下载的文件的同样大小的同名文件。 4.计算每个线程的起始位置和结束位置 5.开启多个线程,采用RandomAccessFile类,根据计算得到的起始位置和结束位置来随机的读取服务 器资源的输出流,并且实时的采用RandomAccessFile类保存线程读取到的字节位置。 6.判断线程结束和文件上传成功。 断点续传具体实现: 1.UI设计 下载主界面设计 进度条单独存放在一个布局文件中,注意进度条要采用以下的样式的进度条。 2.代码逻辑 多线程断点续传的技术可以说是目前学Android课程以来最难、代码最长的一个案例,那么如何 有章有序的将代码写出来呢? 思路整理: 1)网络访问权限和SD卡访问权限的添加 2)初始化动作及下载点击事件的书写 3)随机读取文件线程类的定义 具体代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 //注册点击事件 public void click(Viewv){ path=et_path.getText().toString().trim(); Stringthreadcount_str=et_threadcount.getText().toString().trim(); final int threadcount=Integer.parseInt(threadcount_str); if (TextUtils.isEmpty(path)||threadcount< 0 ){ Toast.makeText(getApplicationContext(), "输入错误" , 0 ).show(); return ; } list_pbBars= new ArrayList<ProgressBar>(); //先清空进度条布局 ll_layout.removeAllViews(); //添加进度条 for ( int i= 0 ;i<threadcount;i++){ //得到进度条的View对象 Viewitem_pb_View=View.inflate(getApplicationContext(),R.layout.item_progress, null ); //通过View再得到进度条 ProgressBarpb_bar=(ProgressBar)item_pb_View.findViewById(R.id.item_pb); list_pbBars.add(pb_bar); ll_layout.addView(item_pb_View); } try { //将服务器文件路径用File包装一下,以便获得它的文件名。 sourceFile= new File(path); //访问URL得到文件的大小,通过Content-Length得到。 new Thread(){ public void run() { System.out.println( "xxx" +Thread.currentThread().getName()); try { //创建HttpURLConnection URLurl= new URL(path); HttpURLConnectionconn=(HttpURLConnection)url.openConnection(); conn.setRequestMethod( "GET" ); //获取状态码 int responseCode=conn.getResponseCode(); if (responseCode== 200 ) { //获取资源文件的长度 sourceFileLength=conn.getContentLength(); sourceFileName=sourceFile.getName(); clientFile= new RandomAccessFile(Environment.getExternalStorageDirectory()+ "/" +sourceFileName, "rw" ); clientFile.setLength(sourceFileLength); //正在运行的线程 runningThreadCount=threadcount; //第3步:计算每个线程读取文件的起始和结束位置 int blockSize=sourceFileLength/threadcount; for ( int i= 0 ;i<threadcount;i++){ //得到每个线程读取的起始和结束位置 int start_index=i*blockSize; int end_index=(i+ 1 )*blockSize- 1 ; int last_index=- 1 ; if (i==threadcount- 1 ) { end_index=sourceFileLength- 1 ; } //------如果采用了断点续传,线程的起始位置就是上次记录位置。 FilerecordIndexFile= new File(Environment.getExternalStorageDirectory().getPath()+ "/" +i+ ".txt" ); //如果有断点文件,就得到上次记录的读取位置。 if (recordIndexFile.exists()&&recordIndexFile.length()> 0 ) { BufferedReaderbufr= new BufferedReader( new FileReader(recordIndexFile)); last_index=Integer.parseInt(bufr.readLine()); // last_index++; bufr.close(); } else //否则上次读取位置就是开始位置。 { last_index=start_index; } //设置进度条的总长度 list_pbBars.get(i).setMax(( int )(end_index-start_index)); System.out.println( "线程" +i+ "::" +last_index+ "----" +end_index); //第4步:启动线程 new DownloadThread(i,start_index,end_index,last_index).start(); } } else { showToast( "请求不到资源" ); return ; } } catch (Exceptione){ e.printStackTrace(); } } }.start(); //第5步:判断线程结束 } catch (Exceptione){ e.printStackTrace(); } } //定义下载的线程类 class DownloadThread extends Thread{ private int threadID; private int start_index,end_index,last_index; private int total= 0 ; //记录已经读写的总的字节数 public DownloadThread( int threadID, int start_index, int end_index, int last_index){ this .threadID=threadID; this .start_index=start_index; this .end_index=end_index; this .last_index=last_index; this .setName( "线程" +threadID); } public void run(){ try { //创建HttpURLConnection URLurl= new URL(path); HttpURLConnectionconn=(HttpURLConnection)url.openConnection(); conn.setRequestMethod( "GET" ); // conn.setReadTimeout(5); //设置一个头信息Range,表示要读取的流的字节范围。 conn.setRequestProperty( "Range" , "bytes=" +last_index+ "-" +end_index); //获取状态码 int responseCode=conn.getResponseCode(); //注意多线程下载状态得用206来判断 if (responseCode== 206 ) { //得到服务器的输出流 InputStreamserverIn=conn.getInputStream(); //得到客户端的文件输出流 RandomAccessFilemyClientFile= new RandomAccessFile( Environment.getExternalStorageDirectory()+ "/" +sourceFileName, "rwd" ); myClientFile.seek(last_index); //读取服务器文件写入到客户端文件中 //断点续传文件 int len= 0 ; byte []buf= new byte [ 1024 * 1024 ]; while ((len=serverIn.read(buf))!=- 1 ) { myClientFile.write(buf, 0 ,len); total+=len; //实时存储当前读取到的文件位置。 int current_index=last_index+total; //因为此处实时的存储读取文件的位置,将缓冲区buf稍微弄大点。 //改 /***注意读取文件位置的流一定要用RandomAccessFile,因为它可以直接同步到缓存(磁盘上)。***/ RandomAccessFileraffAccessFile= new RandomAccessFile(Environment.getExternalStorageDirectory().getPath()+ "/" +threadID+ ".txt" , "rwd" ); raffAccessFile.write(String.valueOf(current_index).getBytes()); raffAccessFile.close(); //设置进度条的当前进度 list_pbBars.get(threadID).setProgress(( int )(total+last_index-start_index)); } myClientFile.close(); serverIn.close(); //操作共享资源,注意加锁。 synchronized (DownloadThread. class ){ runningThreadCount--; if (runningThreadCount== 0 ) { Toast.makeText(getApplicationContext(), "文件下载完毕" , 0 ).show(); } } } else { showToast( "服务器忙" ); } } catch (Exceptione){ e.printStackTrace(); } } } 本文转自屠夫章哥 51CTO博客,原文链接:http://blog.51cto.com/4259297/1676571,如需转载请自行联系原作者

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称,一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux

Rocky Linux(中文名:洛基)是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版,作为CentOS稳定版停止维护后与RHEL(Red Hat Enterprise Linux)完全兼容的开源替代方案,由社区拥有并管理,支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性,采用模块化包装和SELinux安全架构,默认包含GNOME桌面环境及XFS文件系统,支持十年生命周期更新。

用户登录
用户注册
修改密码
忘记密码