移除在java的hashmap中不起作用？

大家好，我一直在试图解决这个问题，但无法解决，问题是删除在hashmap中不起作用

请参阅下面的代码

 package com.org.common;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@SuppressWarnings("unused")
class Workindays {
    public static int findNoOfDays(int year, int month, int day) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month - 1, day);
        int days = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        return days;
    }
    public static Map<String, String> getHolydaysMap(int year, int month, int day) {
        //connect with database and check whether the date is holyday query is = SELECT * FROM holiday_calendar h WHERE date >='2008-10-01' AND date <='2008-10-30' AND type='Fixed';
        Map<String, String> holydaysMap = new LinkedHashMap<String,String>(); 

        holydaysMap.put("20","17-04-2012");
        holydaysMap.put("10","25-04-2012");
        return holydaysMap;
    }
    public static Map<String, String> getWorkingDaysMap(int year, int month, int day){
        int totalworkingdays=0,noofdays=0;
        String nameofday = "";
        ConcurrentHashMap<String,String> workingDaysMap = new ConcurrentHashMap<String,String>();
        Map<String,String> holyDayMap = new LinkedHashMap<String,String>();
        noofdays = findNoOfDays(year,month,day);
        holyDayMap = getHolydaysMap(year,month,day);

        for (int i = 1; i <= noofdays; i++) {
            Date date = (new GregorianCalendar(year,month - 1, i)).getTime(); // year,month,day
            SimpleDateFormat f = new SimpleDateFormat("EEEE");
            nameofday = f.format(date);
            String formatedDate = i+"-"+month+"-"+year;
            if(!(nameofday.equals("Saturday") || nameofday.equals("Sunday"))){
                workingDaysMap.put(String.valueOf(i),formatedDate);
                totalworkingdays++;
            }
        }
        workingDaysMap.put("totalworkingdays", String.valueOf(totalworkingdays));

        System.out.println("removeHolyday : "+removeHoliday(workingDaysMap,holyDayMap));
        return workingDaysMap;
    }
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static Map removeHoliday(ConcurrentHashMap daysMap, Map holydayMap) {
        Iterator<Map.Entry> holyDayiterator = holydayMap.entrySet().iterator();
        while (holyDayiterator.hasNext()) {
            Map.Entry holyDayEntry = holyDayiterator.next();

            Iterator<Map.Entry> daysiterator = daysMap.entrySet().iterator();
            while (daysiterator.hasNext()) {
                Map.Entry daysEntry = daysiterator.next();
                 if(daysEntry.getKey().equals(holyDayEntry.getKey()))
                      daysMap.remove(holyDayEntry.getKey());
            }
        }
        return daysMap;
    }
    @SuppressWarnings({ "rawtypes" })
    public static void main(String[] args) {
        String delimiter = null, dateValues[] = null, startDate = "01-04-2012";
        int year = 0,month=0,day=0,totalworkingdays = 0;
        Map workingDaysMap = new LinkedHashMap<String,String>();

        startDate = "01-04-2012";
        delimiter = "-";
        dateValues = startDate.split(delimiter);

        year = Integer.parseInt(dateValues[2]);
        month = Integer.parseInt(dateValues[1]);
        day = Integer.parseInt(dateValues[0]);

        workingDaysMap = getWorkingDaysMap(year, month, day);
        //System.out.println("workingdays map : "+workingDaysMap);

    }
}

我刚刚给出了用以下方法测试的样本值

getHolydaysMap

请帮忙

编辑： 感谢大家花了宝贵的时间回答问题，向上投票和向下投票。我已经更改了代码，现在运行良好

更新的工作代码

问候 安东尼

---

如果条件失败，那么它将爆发，而不是在地图的其余部分循环，您不需要说明您遇到的具体错误，但需要做一些一般性的评论

您的break语句在“if”之外，因此代码将通过，然后在第一个键之后退出while循环。换句话说，您实际上并没有遍历所有键

其次，您不需要迭代映射并测试匹配的键，调用remove将为您完成这项工作

---

第三（作为一个关注点），在对映射进行迭代时从映射中删除项将导致下一次循环中迭代器出现异常。在这种特殊情况下不突出显示，因为break语句可以避免出现错误，但值得注意的是，在您的removeHoliday方法中，您需要使用parantises；您需要以下内容：

if (Integer.parseInt(daysEntry.getKey().toString()) == Integer.parseInt(holyDayEntry.getKey().toString())) {
    daysMap.remove( Integer.parseInt(holyDayEntry.getKey().toString()));
    break;
}

代替

if (Integer.parseInt(daysEntry.getKey().toString()) ==     Integer.parseInt(holyDayEntry.getKey().toString()))
    daysMap.remove( Integer.parseInt(holyDayEntry.getKey().toString()));
break;

---

考虑重写

removeHolydays

，如下所示：

而不是

if (Integer.parseInt(daysEntry.getKey().toString()) ==     Integer.parseInt(holyDayEntry.getKey().toString()))
    daysMap.remove( Integer.parseInt(holyDayEntry.getKey().toString()));
break;

  public static Map removeHolyday(Map daysMap, Map holydayMap) {
    Iterator<Map.Entry> holyDayiterator = holydayMap.entrySet().iterator();
    while (holyDayiterator.hasNext()) {
        Map.Entry holyDayEntry = holyDayiterator.next();
        Iterator<Map.Entry> daysiterator = daysMap.entrySet().iterator();

        while (daysiterator.hasNext()) {
            Map.Entry daysEntry = daysiterator.next();
            if (Integer.parseInt(daysEntry.getKey().toString()) == Integer.parseInt(holyDayEntry.getKey().toString()))
                daysMap.remove( Integer.parseInt(holyDayEntry.getKey().toString()));
            break;
        }
    }
    return daysMap;
}

publicstaticmap removeHolyday（Map daysMap，Map holydayMap）{
迭代器holyDayiterator=holydayMap.entrySet（）.Iterator（）；
while（holyDayiterator.hasNext（））{
Map.Entry holyDayEntry=holyDayiterator.next（）；
迭代器daysiterator=daysMap.entrySet（）.Iterator（）；
while（daysiterator.hasNext（））{
Map.Entry daysEntry=daysiterator.next（）；
if（Integer.parseInt（daysEntry.getKey（）.toString（））==Integer.parseInt（holyDayEntry.getKey（）.toString（））
daysMap.remove（Integer.parseInt（holyDayEntry.getKey（）.toString（））；
打破
}
}
返回日映射；
}

应该是：

public static Map<Integer, String> remove(Map<Integer, String> daysMap, Map<Integer, String> holydayMap){
     for(Integer i : holydayMap.keySet())
         daysMap.remove(i);
     return daysMap;
}

公共静态映射移除（映射日映射、映射holydayMap）{
for（整数i:holydayMap.keySet（））
daysMap.remove（i）；
返回日映射；
}

---

这将消除将

中断

放在错误位置的错误，正如

ejb\u guy所指出的那样

您可以使用ConcurrentHashMap来执行此操作

公共静态映射removeHolyday（ConcurrentHashMapDaysMap，MapHolydayMap）{

编辑：使用以下代码执行以下操作：

public static Map removeHoliday(ConcurrentHashMap daysMap, Map holydayMap) {
        Iterator<Map.Entry> holyDayiterator = holydayMap.entrySet().iterator();
        while (holyDayiterator.hasNext()) {
            Map.Entry holyDayEntry = holyDayiterator.next();
            if(daysMap.containsKey(holyDayEntry.getKey())){
                daysMap.remove(holyDayEntry.getKey());
            }
        }
        return daysMap;
    }

publicstaticmap removeHoliday（ConcurrentHashMapDaysMap，MapHolydayMap）{
迭代器holyDayiterator=holydayMap.entrySet（）.Iterator（）；
while（holyDayiterator.hasNext（））{
Map.Entry holyDayEntry=holyDayiterator.next（）；
if（daysMap.containsKey（holyDayEntry.getKey（））{
daysMap.remove（holyDayEntry.getKey（））；
}
}
返回日映射；
}

请缩短您的问题。Stackoverflow不会通读所有代码。我也不明白您给出的代码示例的每一点，但您确定Holyday映射中的键是整数实例吗？“HashMap.remove”不工作？！你的意思是，你的代码不工作…对吗？getKey->Integer->int->Integer转换非常可疑…首先，你需要开始使用泛型。你必须执行

Integer.parseInt（holyDayEntry.getKey（）.toString（））

无处不在，因为你的地图被定义为

Map

而不是

Map

+1对我来说似乎是正确的答案。也就是说，这个方法太复杂了。不需要内部循环。不需要检查

containsKey

，如果找不到键，remove将不会做任何事情。当只有是否使用了键？当每个循环都使用

时，无需使用
迭代器
。
public static Map removeHoliday(ConcurrentHashMap daysMap, Map holydayMap) {
        Iterator<Map.Entry> holyDayiterator = holydayMap.entrySet().iterator();
        while (holyDayiterator.hasNext()) {
            Map.Entry holyDayEntry = holyDayiterator.next();
            if(daysMap.containsKey(holyDayEntry.getKey())){
                daysMap.remove(holyDayEntry.getKey());
            }
        }
        return daysMap;
    }