C#到Java延迟敏感类转换，在我的例子中TreeMap会取代SortedList吗？

我正在用Java复制一个C#类。（我是Java新手。）

我的类需要跟踪与双精度相关的int值。然后，它需要创建一个警报（int），每当一个值在double的下方或上方交叉时

需要立即调用Alerter.LatencySensitiveAction（），它是对延迟敏感且时间关键的代码。DoubleMap类的目的是尽可能快地调用LatencySensitiveAction（）

DoubleMap.OnData（）是类的延迟敏感方法（如下所示）

树形图有意义吗？我在C#中使用SortedList。我正在寻找一个关联集合，它以排序顺序存储键/值对，并具有快速遍历功能

我被告知这段Java代码

for (Map.Entry<Double,Alerter> entry : mAscend.entrySet() )

for（Map.Entry:mAscend.entrySet（））

无效，因为它创建了一个新对象。我应该用什么来代替

所以基本上，我要问的是，使用什么集合可以将double和int关联起来，是按排序顺序存储的，按顺序遍历集合的最快方法是什么

我相信我的C#代码（如下）可以完成这项工作，需要帮助将其转换为Java。如果你认为我的C#代码也可以改进。。请告诉我。。泰

Java代码：

public class DoubleMap {

    TreeMap<Double,Alerter> mAscend, mDecend, mHoldAscend, mHoldDecend;

    public DoubleMap()
    {
        mAscend = new TreeMap<Double, Alerter>();
        mDecend = new TreeMap<Double, Alerter>(new ReverseComparator());
    }

    public void Add(boolean rAscend, double value, int size)
    {
        TreeMap<Double,TradeOrder> list = rAscend ? mAscend : mDecend;

        Alerter to = list.get(value);
        if ( to != null )
        {
            Alerter.size += size;
        }
        else 
        {
            to = new Alerter (size);           
            list.put(value, to);
        }
    }

    public void Remove(boolean rAscend, double value, int size)
    {
        TreeMap<Double,TradeOrder> list = rAscend ? mAscend : mDecend;

        Alerter to = list.get(value);
        if ( to != null )
        {
            long nsize = to.size - size;
            if ( nsize <= 0 )
                list.remove(value);
            else
                to.size = nsize;
        }
    }

    public void Ondata(double rValue)
    {
        for (Map.Entry<Double,Alerter> entry : mAscend.entrySet() )
        {
            if ( entry.getKey() > rValue )
                break;

            entry.getValue().LatencySensitiveAction();

            if ( mHoldAscend == null )
                mHoldAscend = new TreeMap<Double,Alerter>(mHoldAscend);
            mAscend.remove(entry.getKey());
        }

        for (Map.Entry<Double,TradeOrder> entry : mDecend.entrySet() )
        {
            if ( entry.getKey() < rValue )
                break;

            entry.getValue().LatencySensitiveAction();

            if ( mHoldDecend == null )
                mHoldDecend = new TreeMap<Double,TradeOrder>(mHoldDecend);
            mHoldDecend.remove(entry.getKey());
        }

        if ( mHoldAscend != null )
        {
            mAscend = mHoldAscend;
            mHoldAscend = null;
        }

        if ( mHoldDecend != null )
        {
            mDecend = mHoldDecend;
            mHoldDecend = null;
        }

    }
}

公共类DoubleMap{
马塞德、梅德森德、莫尔德森德、莫尔德森德、莫尔德森德；
公共双地图（）
{
mAscend=newtreemap（）；
mDecend=newtreemap（newreversecomparator（））；
}
公共void Add（布尔rAscend，双值，整数大小）
{
TreeMap list=rAscend？mAscend:mDecend；
Alerter to=list.get（值）；
如果（到！=null）
{
Alerter.size+=大小；
}
其他的
{
to=新警报（大小）；
列表。放置（值，到）；
}
}
公共void Remove（布尔rAscend，双值，整型大小）
{
TreeMap list=rAscend？mAscend:mDecend；
Alerter to=list.get（值）；
如果（到！=null）
{
long nsize=to.size-大小；
if（nsize右值）
打破
entry.getValue（）.LatencySensitiveAction（）；
如果（mHoldAscend==null）
mHoldAscend=新树映射（mHoldAscend）；
remove（entry.getKey（））；
}
对于（Map.Entry:mDecend.entrySet（））
{
if（entry.getKey（）

C#代码：

公共类DoubleMap
{
私人分类列表mAscend，mDecend，mHoldAscend，mHoldDecend；
公共双地图（）
{
mAscend=新的分类列表（）；
mDecend=新的排序列表（新的下降比较器（））；
}
公共无效添加（布尔拉森、双右值、长rSize）
{
var list=rAscend？mAscend:mDecend；
警报；
if（list.TryGetValue（右值，输出到））
{
to.Size+=rSize；
}
其他的
{
to=新警报（rSize）；
列表。添加（右值，至）；
}
}
公共无效删除（布尔-拉森、双右值、长rSize）
{
var list=rAscend？mAscend:mDecend；
警报；
if（list.TryGetValue（右值，输出到））
{
长nqty=至尺寸-rSize；
如果（nqty r值）
打破
pair.Value.LatencySensitiveAction（）；
如果（mHoldAscend==null）
mHoldAscend=新分类列表（mAscend）；
mHoldAscend.Remove（配对键）；
}
foreach（mDecend中的var对）
{
if（pair.Key

如果您只进行遍历，为什么要使用地图？不能在少于O（n）的时间内执行遍历

我建议您创建一个对象来封装订单，并查看集合的PriorityQueue

如果需要进行范围搜索，还可以查看TreeSet（如果值是唯一的）或TreeMap。（但请注意，您必须以某种方式进行迭代，才能从这些类中获得排序输出。）

编辑

您确定审阅者的意思是for（Map.Entry:mAscend.entrySet（））的

效率低下，而不是for循环中的代码吗？每次匹配一对时，您都在执行新的集合创建（这本身不是一项便宜的工作，在时间敏感的代码中肯定不是一件好事）。你在你的C#代码里也在做同样的事情

试试这个：

Code Deleted; See history


编辑2

我意识到您的实现实际上比必要的慢得多，因为它完全依赖于树映射来进行排序和查找。下面是一个更快的实现：

public class DoubleMap {
    HashMap<Double, Alerter> mAscend, mDescend;
    PriorityQueue<Double> pricesAscending, pricesDescending;

    public DoubleMap()
    {
        pricesAscending = new PriorityQueue<Double>(100);
        pricesDescending = new PriorityQueue<Double>(100, new ReverseComparator());
    }

    public void Add(boolean rAscend, double value, int size)
    {
        Map<Double, Alerter> map = rAscend ? mAscend : mDescend;

        Alerter to = map.get(value);
        if ( to != null )
        {
            Alerter.size += size;
        }
        else 
        {
            to = new Alerter (size);           
            map.put(value, to);
            pricesAscending.offer(value);
            pricesDescending.offer(value);
        }
    }

    public void Remove(boolean rAscend, double value, int size)
    {
        Map<Double, Alerter> map = rAscend ? mAscend : mDecend;

        Alerter to = map.get(value);
        if ( to != null )
        {
            long nsize = to.size - size;
            if ( nsize <= 0 )
                map.remove(value);
                pricesAscending.remove(value);
                pricesDescending.remove(value);
            else
                to.size = nsize;
        }
    }

    public void Ondata(double rValue)
    {
        while (pricesAscending.peek() < rValue) {
            mAscend.getValue(pricesAscending.peek()).LatencySensitiveAction();

            mAscend.remove(pricesAscending.poll());
        }

        while (pricesDescending.peek() > rValue) {
            mDescend.getValue(pricesDescending.peek()).LatencySensitiveAction();

            mDescend.remove(pricesDescending.poll());
        }
    }
}

公共类DoubleMap{
HashMap mAscend，mDescend；
优先队列价格搜索，价格搜索；
公共双打
public class DoubleMap {
    HashMap<Double, Alerter> mAscend, mDescend;
    PriorityQueue<Double> pricesAscending, pricesDescending;

    public DoubleMap()
    {
        pricesAscending = new PriorityQueue<Double>(100);
        pricesDescending = new PriorityQueue<Double>(100, new ReverseComparator());
    }

    public void Add(boolean rAscend, double value, int size)
    {
        Map<Double, Alerter> map = rAscend ? mAscend : mDescend;

        Alerter to = map.get(value);
        if ( to != null )
        {
            Alerter.size += size;
        }
        else 
        {
            to = new Alerter (size);           
            map.put(value, to);
            pricesAscending.offer(value);
            pricesDescending.offer(value);
        }
    }

    public void Remove(boolean rAscend, double value, int size)
    {
        Map<Double, Alerter> map = rAscend ? mAscend : mDecend;

        Alerter to = map.get(value);
        if ( to != null )
        {
            long nsize = to.size - size;
            if ( nsize <= 0 )
                map.remove(value);
                pricesAscending.remove(value);
                pricesDescending.remove(value);
            else
                to.size = nsize;
        }
    }

    public void Ondata(double rValue)
    {
        while (pricesAscending.peek() < rValue) {
            mAscend.getValue(pricesAscending.peek()).LatencySensitiveAction();

            mAscend.remove(pricesAscending.poll());
        }

        while (pricesDescending.peek() > rValue) {
            mDescend.getValue(pricesDescending.peek()).LatencySensitiveAction();

            mDescend.remove(pricesDescending.poll());
        }
    }
}