Java 导入HashMap时出错

嗨，我正在使用eclips indigo开发我的项目，我的包中出现了错误，就像这样

这条线上有多个标记 -无法解析类型java.util.Map$条目。它间接引用自 必需。类文件 -无法解析类型java.util.Map$条目。它间接引用自 必需。类文件

有人知道我在java类中导入

Hashmap

，

util.map，common.collect.map

时出错的原因吗

package info.sample.project;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import org.json.JSONException;
import org.json.JSONObject;
import com.google.common.collect.Maps;

 @ServerEndpoint("/chat")
  public class SocketServer {

   // set to store all the live sessions
   private static final Set<Session> sessions = Collections
        .synchronizedSet(new HashSet<Session>());

  // Mapping between session and person name
private static final HashMap<String, String> nameSessionPair = new    HashMap<String, String>();

private JSONUtils jsonUtils = new JSONUtils();

// Getting query params
public static Map<String, String> getQueryMap(String query) {
    Map<String, String> map = Maps.newHashMap();
    if (query != null) {
        String[] params = query.split("&");
        for (String param : params) {
            String[] nameval = param.split("=");
            map.put(nameval[0], nameval[1]);
        }
    }
    return map;
}

/**
 * Called when a socket connection opened
 * */
@OnOpen
public void onOpen(Session session) {

    System.out.println(session.getId() + " has opened a connection");

    Map<String, String> queryParams = getQueryMap(session.getQueryString());

    String name = "";

    if (queryParams.containsKey("name")) {

        // Getting client name via query param
        name = queryParams.get("name");
        try {
            name = URLDecoder.decode(name, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        // Mapping client name and session id
        nameSessionPair.put(session.getId(), name);
    }

    // Adding session to session list
    sessions.add(session);

    try {
        // Sending session id to the client that just connected
        session.getBasicRemote().sendText(
                jsonUtils.getClientDetailsJson(session.getId(),
                        "Your session details"));
    } catch (IOException e) {
        e.printStackTrace();
    }

    // Notifying all the clients about new person joined
    sendMessageToAll(session.getId(), name, " joined conversation!", true,
            false);

}

/**
 * method called when new message received from any client
 * 
 * @param message
 *            JSON message from client
 * */
@OnMessage
public void onMessage(String message, Session session) {

    System.out.println("Message from " + session.getId() + ": " + message);

    String msg = null;

    // Parsing the json and getting message
    try {
        JSONObject jObj = new JSONObject(message);
        msg = jObj.getString("message");
    } catch (JSONException e) {
        e.printStackTrace();
    }

    // Sending the message to all clients
    sendMessageToAll(session.getId(), nameSessionPair.get(session.getId()),
            msg, false, false);
}

/**
 * Method called when a connection is closed
 * */
@OnClose
public void onClose(Session session) {

    System.out.println("Session " + session.getId() + " has ended");

    // Getting the client name that exited
    String name = nameSessionPair.get(session.getId());

    // removing the session from sessions list
    sessions.remove(session);

    // Notifying all the clients about person exit
    sendMessageToAll(session.getId(), name, " left conversation!", false,
            true);

}

/**
 * Method to send message to all clients
 * 
 * @param sessionId
 * @param message
 *            message to be sent to clients
 * @param isNewClient
 *            flag to identify that message is about new person joined
 * @param isExit
 *            flag to identify that a person left the conversation
 * */
private void sendMessageToAll(String sessionId, String name,
        String message, boolean isNewClient, boolean isExit) {

    // Looping through all the sessions and sending the message individually
    for (Session s : sessions) {
        String json = null;

        // Checking if the message is about new client joined
        if (isNewClient) {
            json = jsonUtils.getNewClientJson(sessionId, name, message,
                    sessions.size());

        } else if (isExit) {
            // Checking if the person left the conversation
            json = jsonUtils.getClientExitJson(sessionId, name, message,
                    sessions.size());
        } else {
            // Normal chat conversation message
            json = jsonUtils
                    .getSendAllMessageJson(sessionId, name, message);
        }

        try {
            System.out.println("Sending Message To: " + sessionId + ", "
                    + json);

            s.getBasicRemote().sendText(json);
        } catch (IOException e) {
            System.out.println("error in sending. " + s.getId() + ", "
                    + e.getMessage());
            e.printStackTrace();
        }
    }
}
   }

package info.sample.project；
导入java.io.IOException；
导入java.io.UnsupportedEncodingException；
导入java.net.url解码器；
导入java.util.Collections；
导入java.util.HashMap；
导入java.util.HashSet；
导入java.util.Map；
导入java.util.Set；
导入javax.websocket.OnClose；
导入javax.websocket.OnMessage；
导入javax.websocket.OnOpen；
导入javax.websocket.Session；
导入javax.websocket.server.ServerEndpoint；
导入org.json.JSONException；
导入org.json.JSONObject；
导入com.google.common.collect.Maps；
@ServerEndpoint（“/chat”）
公共类SocketServer{
//设置为存储所有实时会话
私有静态最终集会话=集合
.synchronizedSet（新HashSet（））；
//会话和人名之间的映射
私有静态最终HashMap nameSessionPair=新HashMap（）；
私有JSONUtils JSONUtils=新JSONUtils（）；
//获取查询参数
公共静态映射getQueryMap（字符串查询）{
Map Map=Maps.newHashMap（）；
if（查询！=null）{
字符串[]params=query.split（&）；
for（字符串参数：params）{
字符串[]nameval=param.split（“”）；
map.put（nameval[0]，nameval[1]）；
}
}
返回图；
}
/**
*当套接字连接打开时调用
* */
@奥诺彭
公共开放（会议）{
System.out.println（session.getId（）+“已打开连接”）；
Map queryParams=getQueryMap（session.getQueryString（））；
字符串名称=”；
if（queryParams.containsKey（“名称”））{
//通过查询参数获取客户端名称
name=queryParams.get（“name”）；
试一试{
name=urldecker.decode（名称，“UTF-8”）；
}捕获（不支持的编码异常e）{
e、 printStackTrace（）；
}
//映射客户端名称和会话id
nameSessionPair.put（session.getId（），name）；
}
//将会话添加到会话列表
添加（会话）；
试一试{
//正在向刚刚连接的客户端发送会话id
session.getBasicRemote（）.sendText(
jsonUtils.getClientDetailsJson（session.getId（），
“您的会话详细信息”）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
//通知所有客户新加入的人员
sendMessageToAll（session.getId（），名称，“joined conversation！”，true，
假）；
}
/**
*从任何客户端接收新消息时调用的方法
* 
*@param消息
*来自客户端的JSON消息
* */
@OnMessage
公共void onMessage（字符串消息、会话）{
System.out.println（“来自“+session.getId（）+”的消息：“+Message”）；
字符串msg=null；
//解析json并获取消息
试一试{
JSONObject jObj=新的JSONObject（消息）；
msg=jObj.getString（“消息”）；
}捕获（JSONException e）{
e、 printStackTrace（）；
}
//将消息发送到所有客户端
sendMessageToAll（session.getId（），nameSessionPair.get（session.getId（）），
味精，假，假）；
}
/**
*方法在连接关闭时调用
* */
@一次
公共void onClose（会话）{
System.out.println（“Session”+Session.getId（）+“已结束”）；
//正在获取退出的客户端名称
String name=nameSessionPair.get（session.getId（））；
//从会话列表中删除会话
会话。删除（会话）；
//通知所有客户端人员退出
sendMessageToAll（session.getId（），名称，“left conversation！”，false，
正确的）；
}
/**
*方法向所有客户端发送消息
* 
*@param sessionId
*@param消息
*要发送给客户端的消息
*@param isNewClient
*标识消息是关于新加入人员的标志
*@param-isExit
*标识某人离开对话的标志
* */
私有void sendMessageToAll（字符串sessionId、字符串名称、，
字符串消息、布尔值isNewClient、布尔值isExit）{
//在所有会话中循环并单独发送消息
用于（会话s：会话）{
字符串json=null；
//检查消息是否与新加入的客户端有关
if（isNewClient）{
json=jsonUtils.getNewClientJson（sessionId、名称、消息、，
sessions.size（））；
}else if（isExit）{
//检查对方是否离开了对话
json=jsonUtils.getClientExitJson（sessionId、名称、消息、，
sessions.size（））；
}否则{
//正常聊天信息
json=jsonUtils
.getSendAllMessageJson（会话ID、名称、消息）；
}
试一试{
System.out.println（“将消息发送到：+sessionId+”，”
+json）；
s、 getBasicRemote（）.sendText（json）；
}捕获（IOE异常）{
System.out.println（“发送时出错。“+s.getId（）+”，”
+e.getMessage（））；
e、 printStackTrace（）；
}
}
}
}

也尝试导入

java.util.Map.Entry

。

能否显示导致错误的代码？是Map.Entry，不是Map.Entry。