词典的实现(3)--使用JAVA类库ArrayList实现Map数据结构

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量98 收藏
点赞数
文章标签： java 数据结构与算法

1，在词典的实现(2)-借助顺序表(数组)实现词典文章中使用了自定义的数组代替ArrayList，并实现了Map数据结构的基本功能。而借助JAVA类库ArrayList类的一些方法可以更加容易地实现Map。

 

2，实现思路如下

ArrayListDictionary.java 中定义了一个ArrayList的对象，该ArrayList对象用来存储Entry类的对象，而Entry类封装了(key，value)。这样，利用ArrayList类的一些方法来间接地操作(key,value)，从而实现各种词典的操作。

 

ArrayListDictionary.java 中部分代码解释如下：

 

public ArrayListDictionary(){
        listDictionary = new ArrayList<Entry>();
    }

在构造方法中初始化ArrayList对象。这样，每生成一个词典对象，就会有一个ArrayList对象。因为，每个词典对象都需要一个ArrayList对象来存储词典中的元素。

 

private class Entry{
        K key;
        V value;

私有内部类Entry用来封装(key,value)对，key 只有get方法没有set方法。因为对于词典而言，key是不能更改的。而value既有get方法又有set方法。

 

private class KeyIterator<S> implements Iterator<K>{

        Iterator<Entry> it = null;
        public KeyIterator(){
            it = listDictionary.iterator();
        }
        
        @Override
        public boolean hasNext() {
            return it.hasNext();
        }

        @Override
        public K next() {
            return  (K) it.next().getKey();
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("can not remove a entry in iterator.unsupported");
            
        }
    }

私有内部类KeyIterator用来实现词典中键的迭代器。该迭代器的实现基于遍历Entry的迭代器，由于ArrayList存储Entry对象，因此可以借助ArrayList的iterator()方法很容易地得到遍历Entry的迭代器。在KeyIterator的构造方法中实例化遍历Entry对象的迭代器后，通过实现Iterator接口的三个方法来实现遍历词典的查找键的迭代器。

 

 

@Override
    public Iterator<K> getKeyIterator() {
        return new KeyIterator();
    }

ArrayListDictionary.java的getKeyIterator()方法返回一个遍历词典查找键的迭代器的对象。这样，ArrayListDictionary的对象就可以调用该方法来得到该迭代器了。

 

private int locateIndex(K key){
        int index = -1;
        Iterator<Entry> it = listDictionary.iterator();
        while(it.hasNext()){
            Entry e = it.next();//先获得每一个Map元素
            if(e.getKey().equals(key)){//依次与每一个Map元素的查找键比较
                index = listDictionary.indexOf(e);//获得给定的key匹配的Map元素在Arraylist中的位置
                break;
            }
        }
        return index;
    }

私有方法locateIndex(K key)，用来查找某个查找键在ArrayList数组中的哪个位置。由于ArrayList数组中存储的是Entry对象，因此先要通过遍历Entry的迭代器获得Entry对象，然后通过Entry类的getKey()方法来获得Entry对象的key属性。index 返回 –1 表示查找键key(所代表的Entry对象)不在ArrayList中。

 

public V remove(K key) {
        V  result = null;
        int index = locateIndex(key);
        if(index == -1){//key 不存在于ArrayList中
            result = null;
        }
        else{
            result = listDictionary.get(index).getValue();
            listDictionary.remove(index);
        }
        return result;
    }

remove()用来删除词典中的元素。其他的一些方法的功能可以参考DictionaryInterface.java中声明的方法解释。

 

整个完整的ArrayListDictionary.java实现如下

package dictionary;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDictionary<K,V> implements DictionaryInterface<K, V>,Serializable {
    
    private static final long serialVersionUID = 1L;
    ArrayList<Entry> listDictionary = null;
    
    public ArrayListDictionary(){
        listDictionary = new ArrayList<Entry>();
    }
    
    private class Entry{
        K key;
        V value;
        
        private Entry(K key, V value){
            this.key = key;
            this.value = value;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }
    }
    
    private class KeyIterator<S> implements Iterator<K>{

        Iterator<Entry> it = null;
        public KeyIterator(){
            it = listDictionary.iterator();
        }
        
        @Override
        public boolean hasNext() {
            return it.hasNext();
        }

        @Override
        public K next() {
            return  (K) it.next().getKey();
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("can not remove a entry in iterator.unsupported");
            
        }
    }
    
    private class ValueIterator<V> implements Iterator<V>{

        Iterator<Entry> it = null;
        public ValueIterator(){
            it = listDictionary.iterator();
        }
        
        @Override
        public boolean hasNext() {
            return it.hasNext();
        }

        @Override
        public V next() {
            return (V) it.next().getValue();
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
    
    //返回指定的查找键所代表的元素在arraylist中的位置
    private int locateIndex(K key){
        int index = -1;
        Iterator<Entry> it = listDictionary.iterator();
        while(it.hasNext()){
            Entry e = it.next();//先获得每一个Map元素
            if(e.getKey().equals(key)){//依次与每一个Map元素的查找键比较
                index = listDictionary.indexOf(e);//获得给定的key匹配的Map元素在Arraylist中的位置
                break;
            }
        }
        return index;
    }
    
    @Override
    public V add(K key, V value) {
        V result = null;
        int index = locateIndex(key);
        if(index == -1){//key 不在ArrayList中
            listDictionary.add(new Entry(key, value));
        }
        else{
            //这里index不会为-1，所以 get(index)不会抛出IndexOutOfBoundsException
            result = listDictionary.get(index).getValue();
            listDictionary.get(index).setValue(value);//调用Entry内部类中的setValue方法更新Entry的Value
        }
        return result;
    }

    @Override
    public V remove(K key) {
        V  result = null;
        int index = locateIndex(key);
        if(index == -1){//key 不存在于ArrayList中
            result = null;
        }
        else{
            result = listDictionary.get(index).getValue();
            listDictionary.remove(index);
        }
        return result;
    }

    @Override
    public V getValue(K key) {
        V result = null;
        int index = locateIndex(key);
        try{
            result = listDictionary.get(index).getValue();//当index=-1时，表示key不存在
        }catch(IndexOutOfBoundsException e){//index = -1时抛出异常
            result = null;
        }
        return result;
    }

    @Override
    public boolean contains(K key) {
        boolean result = false;
        Iterator<Entry> it = listDictionary.iterator();
        while(it.hasNext()){
            Entry e = it.next();
            if(e.getKey().equals(key)){
                result = true;
                break;
            }
        }
        return result;
    }
    

    @Override
    public Iterator<K> getKeyIterator() {
        return new KeyIterator();
    }

    @Override
    public Iterator<V> getValueIterator() {
        return new ValueIterator();
    }

    @Override
    public boolean isEmpty() {
        return listDictionary.isEmpty();
    }

    @Override
    public boolean isFull() {
        return false;
    }

    @Override
    public int getSize() {
        return listDictionary.size();
    }

    @Override
    public void clear() {
        listDictionary.clear();
    }
}

 

 

在实现完词典后，以下写了个测试程序借且词典来统计单词的个数。思路如下：

文本文件word.txt中存放待统计的单词，词典客户端程序PrintWordsFrequency.java 提供word.txt，然后查看每个单词出现的次数。

词典表FrequencyCounterDictionary.java负责统计word.txt中的单词并将结果存储到Map词典中，并实现对词典的遍历(display())。

 

PrintWordsFrequency.java 代码如下：

package dictionary.common;
package dictionary.client;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Scanner;

import dictionary.common.FrequencyCounterDictionary;

public class PrintWordsFrequency {
    public static void main(String[] args) {
        FrequencyCounterDictionary wordCounter = new FrequencyCounterDictionary();
        String fileName = "word.txt";//存放单词的文本文件，统计其中的单词出现次数
        try{
            Scanner data = new Scanner(new File(fileName));
            wordCounter.readFile(data);
        }catch(FileNotFoundException e){
            System.out.println("File not found: " + e.getMessage());
        }catch(IOException e){
            System.out.println("I/O error" + e.getMessage());
        }
        
        wordCounter.display();
        System.out.println("Bye");
    }
}

 

FrequencyCounterDictionary.java代码如下：

package dictionary.common;

import java.util.Iterator;
import java.util.Scanner;

import dictionary.ArrayListDictionary;
import dictionary.DictionaryInterface;

public class FrequencyCounterDictionary {
    private DictionaryInterface<String, Integer> wordTable;
    
    public FrequencyCounterDictionary(){
        wordTable = new ArrayListDictionary<String, Integer>();
    }
    
    public void readFile(Scanner data){
        data.useDelimiter("\\W+");
        while(data.hasNext()){
            String nextWord = data.next();//从Scanner打开的输入流中读取单词
            nextWord.toLowerCase();
            Integer frequency = wordTable.getValue(nextWord);//判断该单词在词典中已出现的次数
            
            if(frequency == null){//单词从未出现过
                wordTable.add(nextWord, new Integer(1));//将其出现次数置 1
            }
            else//单词已经在词典中
            {
                frequency++;//出现次数增 1
                wordTable.add(nextWord, frequency);
            }
        }//end while
        data.close();
    }
    
    public void display(){
        Iterator<String> keyIterator = wordTable.getKeyIterator();
        Iterator<Integer> valueIterator = wordTable.getValueIterator();
        while(keyIterator.hasNext()){
            System.out.println(keyIterator.next() + " : " + valueIterator.next());
    }
    }
}

运行结果

文本文件内容如下：

data

 

result

weixin_34220623
关注
Lucene使用IKAnalyzer分词实例 及 IKAnalyzer扩展词库
weixin_33994444的博客
04-07 265
方案一: 基于配置的词典扩充 项目结构图如下:IK分词器还支持通过配置IKAnalyzer.cfg.xml文件来扩充您的专有词典。谷歌拼音词库下载: http://ishare.iask.sina.com.cn/f/14446921.html?from=like在web项目的src目录下创建IKAnalyzer.cfg.xml文件,内容如下 &lt;?xml version="1.0" e...
024.ArrayList中方法详解
_川江的博客
11-11 430
数组终于已经告一段落，今天开始了集合的学习，其中的重要分支，list中的ArrayList。 ArrayList类中经常使用的方法有： add（Object） -增加ArrayList中的元素 get（n） -取元素，n为元素的下标 indexOf（） -显示元素下标 isEmpty（） -判断ArrayList中元素是否为空 clear（） -清空所有元素 remove（Objec
关于ArrayList源码的一些自我理解以及解析（七）：函数式接口在ArrayList中的使用
GhostPaints的博客
02-15 182
之前把ArrayList的大部分源码都阅读了一遍，接下来就一口气理解完剩下的几个方法。 @Override public boolean removeIf(Predicate&lt;? super E&gt; filter) { Objects.requireNonNull(filter); // figure out which element...
Java集合类（ ArrayList LinkedList HashMap底层实现）
kaylee_study的博客
07-01 458
最近在复习数据结构，于是把java集合类重新复习一遍~~ ArrayList的底层实现： public class MyArrayList { //实质是一个数组 private Object[] ElementData; //集合大小[注：集合大小用size表示，数组大小才有length] private int size; //构造函数 没有...
Java HashMap ArrayList 实现原理浅析
u012361112的博客
06-25 349
一、数组 1. 数组常用排序算法有冒泡排序，选择排序，插入排序，快速排序，归并排序，堆排序。 冒泡排序关键思想是相邻两个元素交换，所以有两层循环，外面循环控制交换趟数，里面循环控制相邻两个元素交换，里层循环从左想要扫描交换时，结果只能是最大的放在最右端，所以内循环关键在于j的终止条件：for(int j = 0; j < length - i - 1; j++)。冒泡排序基本时间复杂度都是o(n^2)，至于o(n)的说法，是需要加1个flag，即第一次内循环结束时，如果没有元素交换，则flag=t
词典的实现(1)--Map的底层实现
weixin_30849403的博客
06-13 108
1，词典是这样的一种数据结构：它能根据给定的键(索引值,key)来查找其对应的值(value)是否存在，在JAVA中主要由java.util.HashMap来完成该功能。如电话本就是词典的一个具体实例，其中名字作为键，电话号码作为值。客户端可以通过构造一个电话本来进行查询。本系列文章自己编程实现了Map这一数据结构，模拟实现了词典的功能，并给出了词典的两个具体应用---①根据姓名查找电话号码；②统...
2020-09-15 JAVA面试题整理
weixin_44038860的博客
09-15 2886
2020年字节跳动Java面试题附答案解析 前言 个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、 丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！ 本篇分享的面试题内容包括：Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Redis、MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、Linux 等技术栈。 一、Java基础系列面试题 1、面
Java面试题-进阶篇(2022.4最新汇总)
weixin_45698637的博客
04-05 6550
Java面试题-进阶篇 1. 基础篇 2. JVM篇 3. 多线程&并发篇 4. Spring篇 5. SpringBoot篇 6. SpringCloud篇 7. Mybatis篇 8. Mysql篇 9. Redis篇 10. RabbitMQ篇 11. ElasticSearch基础篇 12. Linux篇
词典的实现(2)-借助顺序表(数组)实现词典
weixin_30552811的博客
06-16 101
一，思路 1，词典实现类ArrayDictionary.java肯定要implements 词典的接口DictionaryInterface.java（参考：http://www.cnblogs.com/hapjin/p/4573826.html）。其次，为了序列化，还要implements Serializable接口 2，由于词典中的每个元素是一个键值对。因此，需要将查找键 和 值 封装在...
Java集合框架详解与核心类库
集合框架包括多种接口和实现类，它们构成了一个完整的体系，便于开发者根据需求选择最适合的数据结构。 首先，集合（Collection）是Java中的一个接口，它是所有单值容器的基础，比如List、Set等。集合框架允许...
Java知识点概览
qq_48403611的博客
08-03 3491
java后端开发常见面试题总结
ym——Andorid-15k+的面试题。
热门推荐
陈宇明
08-07 2万+
最近才开的博客，希望大家多多关注，andorid开发也做了3年有余了，也面试很多加企业，借此机会分享一下，我们中遇到过的问题以及解决方案吧，希望能够对正在找工作的andoird程序员有一定的帮助。学完本人博客发表《ym--andorid从零开始教程》+面试题目全理解，年薪18w以上绝对没问题。 特别献上整理过的50道面试题目 1.listView的优化方式 重用conve
2022年Java 工程师面试题
weixin_42572320的博客
03-03 2609
第 1 页 共 485 页 目录 1、什么是 Mybatis？............................................................................... 33 2、Mybaits 的优点：............................................................................... 33 3、MyBatis 框架的缺点：.............................
Java后端社招面试个人总结
nalanmingdian的博客
08-12 3207
近期面了一些后端的内容，准备先对其中一些内容进行总结下，便于个人加深理解。行文可能仅支持个人能看懂理解就行。如有理解不到位的地方请谅解。终结面试后再来一一回顾整理。当然，友情提示下：面试前最好是提前做好项目亮点和难点、个人优点和缺点、为什么找工作的介绍准备，在面试中不断总结提炼，形成较好的表述。会持续更新到换工作结束 JVM JVM内存区域是什么样的？各有什么内容？ JVM内存区域包含以下几部分： 程序计数器：线程私有。当前线程所执行字节码的行号指示器，便于线程切换后回到正确的执行位置，无O.
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 637
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1125
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 781
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 464
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java数据结构学习：线性表的存储结构与ArrayList实现
本文主要讨论了Java中线性表的存储结构以及代码实现，包括线性表的基本概念、顺序存储结构和ArrayList类的使用。 线性表是一种常见的数据结构，它的特点是数据元素之间存在一对一的关系，即每个元素都有一个前驱...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值