Java 找到一个数字的范围的最佳方法是什么？

我正在研究一个折扣要求，用户应该根据订单金额获得折扣

比如说,

订购1000至5000件商品-给予10%的折扣

订购5000至10000件商品-给予15%的折扣

订购10000至15000件商品-给予20%的折扣

这些是我数据库中的详细信息

根据我的订单金额找到折扣百分比的最佳方法是什么。我试着在一个对象列表中设置它们，然后迭代它们，找到它所属的范围，然后得到那个百分比

---

但这似乎是一个漫长的过程。请告诉我是否有比这更好的方法。

这是我的Java解决方案。如果您想直接使用SQL，请完全同意。但不管怎样，这里有一些代码！：）

我会使用带有“折扣”值的关键“金额”的LinkedHashMap。它是链接的，所以当您遍历它时，它会保持从最高到最低的顺序。如果您的值>=迭代密钥数量，则应用值折扣并中断循环

Map<Integer,Integer> map = new LinkedHashMap<>();

public void discount() {
    map.put(10000,20);
    map.put(5000,15);
    map.put(1000,10);

    System.out.println(discount(11000));
    System.out.println(discount(5100));
    System.out.println(discount(1100));
    System.out.println(discount(100));
}

private int discount(int value) {
    for (Map.Entry<Integer,Integer> entrySet : map.entrySet()) {
        if (value >= entrySet.getKey()) {
            return entrySet.getValue();
        }
    }
    return 0;
}

---

使用数据库。假设是SQL：

表

折扣

MIN    MAX    REDUCTION
---    ---    -------
1000   5000   10
5001   10000  15
10001  150000 25

SQL查询

select reduction
from discounts
where @amount between MIN and MAX

---

这是一个商业应用程序，你要写还是只是一个示例应用程序

在这种情况下，它只是一个示例应用程序： 为什么不实现一个故障排除方法：

因此

DiscountRanges.GROUPCLOWERBOUND.getValue（）

为您提供了组C的值

Pro：

• 幻数封装在枚举中

Con：

• 到目前为止还没有

JAVA8解决方案：

公共类折扣计算器{
映射规则=新建LinkedHashMap（）；
整数折扣（整数金额）{
可选o=规则
.entrySet（）
.stream（）
.filter（x->x.getKey（）.test（金额））
.map（x->x.getValue（））
.findFirst（）；
返回（o.isPresent（））？o.get（）：0；
}
公共折扣计算器（）{
规则.put（x->x>=10000&&x<15000,20）；
规则.put（x->x>=5000,15）；
规则.put（x->x>=1000,10）；
}
}

Pro：

• 因为它们是

  lambdas

  ，所以您可以自由地设计复杂的谓词，而不仅仅是检查边界；e、 g.您可以包括

  模算术

  ，以创建更复杂的比例。也许编写代码要比设计复杂的查询好得多

Con：

但是，如果这些范围已经在数据库中，则根本不需要硬编码它们

---

如果您在数据库中已经有了条件（以一种易于查询的方式），@Dave的答案最适合您的需要：只需从数据库中选择即可。

金额和折扣%之间是否存在数学关系？如果您的数据库中有这些详细信息，为什么不直接查找它们并跳过列表/迭代部分呢？哦，我刚刚注意到数据库中有……可能使用了一些SQL:）我会让Hibernate或其他框架担心缓存问题，然后使用

从表中选择折扣，其中priceminPrice

oh，您使用了性能标签。您每秒申请的折扣是多少？：）初始化映射时：（1）建议声明的类型（左侧）是接口。（2） 无需在右侧指定泛型类型

Map Map=newlinkedhashmap（）

Oops，是的。我通常使用底图类型。只是一个“打字错误”

select reduction
from discounts
where @amount between MIN and MAX

int getDiscount(int amount){
    if (amount >= 10000 && amount <= 15000) return 20;
    if (amount >= 5000) return 15;
    if (amount >= 1000) return 10;
    return 0;
}

int getDiscount(int amount){
    if (isDiscountGroupA) return 20;
    if (isDiscountGroupB) return 15;
    if (isDiscountGroupC) return 10;
    return 0;
}

bool isDiscountGroupA(int amount){
    if (amount >= 10000 && amount <= 15000) return true;
}


bool isDiscountGroupB(int amount){
    if (amount>5000) return true;
}

bool isDiscountGroupC(int amount){
    if (amount>1000) return true;
}

public enum DiscountRanges {

    DISCOUNTGROUPAUPPERBOUND(15000),
    DISCOUNTGROUPALOWERBOUND(10000),
    DISCOUNTGROUPBLOWERBOUND(5000),
    DISCOUNTGROUPCLOWERBOUND(1000);

    private final int boundary;
    DiscountRanges(int boundary) { this.boundary=boundary; }
    public int getValue() {return boundary;};

}

public class DiscountCalculator {

    Map<Predicate<Integer>, Integer> rules=new LinkedHashMap<Predicate<Integer>, Integer>();

    Integer getDiscount(int amount){
        Optional<Integer> o= rules
                .entrySet()
                .stream()
                .filter(x->x.getKey().test(amount))
                .map(x->x.getValue())
                .findFirst();
        return (o.isPresent())?o.get():0;
    }

    public DiscountCalculator() {
        rules.put(x -> x >= 10000 && x < 15000, 20);
        rules.put(x -> x >= 5000, 15);
        rules.put(x -> x >= 1000, 10);

    }

}