小编Mar*_*eel的帖子

既然true falseC 中没有布尔类型，那么表达式的x == y计算结果是什么，什么时候为真，什么时候为假？

如果它的计算结果分别为 1 和 0，它们是整数，为什么我们不能case在switch语句中使用s这样的表达式？

这背后的正确原因是：

1. case 只允许整数表达式或计算为整数的表达式，而 x == y 不会计算为整数（我不知道如何计算）？或者
2. 如果 switch 允许像 case 这样的表达式x==y，那么多个 case很有可能最终具有相同的值，即，无论何时，我们都会得到 1，因此多个这样的 case 将评估为 1 或 0；这在 switch 语句中是不允许的。

一切运行良好。结束部分给出ORA-02291错误。不确定是什么导致了该错误，因为我认为所有代码都运行良好。这是在 Oracle SQL developer 中制作的，错误消息是 ORA-02291。我希望有人能给我一个答案。请帮我。

代码：

CREATE TABLE comm_customer
( 
Customer_Id int NOT NULL,
Customer_Name VARCHAR(50) NOT NULL,
Address VARCHAR(255) NOT NULL,
Billing_Address VARCHAR(255) NOT NULL,
city VARCHAR(255) NOT NULL,
country VARCHAR(255) NOT NULL, 
phone INT NOT NULL,
primary key(Customer_id)
);

CREATE TABLE comm_orders
(
order_Id INT NOT NULL,
Customer_id INT NOT NULL,
order_date DATE NOT NULL,
amount DECIMAL(5,2) NOT NULL,
Order_status VARCHAR(20) NOT NULL,
primary key(order_id),
FOREIGN KEY (customer_id ) REFERENCES comm_customer(customer_id)
);

CREATE TABLE comm_products …

我需要用 -50 到 50 之间的随机数填充数组，并且需要使用 Math.random()。这是我当前的代码：

double[] randomNums = new double[5];

for (int i = 0; i < randomNums.length; i++) {
    randomNums[i] = 100 * Math.random() - 50;
}
for (double i: randomNums) {
    System.out.println(i + ',');
}

输出：

double[] randomNums = new double[5];

for (int i = 0; i < randomNums.length; i++) {
    randomNums[i] = 100 * Math.random() - 50;
}
for (double i: randomNums) {
    System.out.println(i + ',');
}

为什么这个数字会超过 50？

我的理解是 x++ == 0 首先运行。但是在计算 (y = y++ / x) == 0 时 x 仍然是 -1？否则它将被零除。我以为输出会是-5，但 eclipse 说是 5。我要疯了。

public static void main(String[] args){
        
    int x = -1;
    int y = 5;
    boolean s = (x++ == 0) && ((y = y++ / x) == 0);
    System.out.println(x + y);
}

我正在尝试使用 Java JDBC 通过以下查询更新 SQL 表 UPDATE PLAYER SET FIRST_NAME ='king', LAST_NAME ='guy', ADDRESS ='', PROVINCE ='', POSTAL_CODE ='', PHONE_NUMBER ='' WHERE PLAYER_ID=7;

但我收到错误消息

java.sql.SQLSyntaxErrorException: ORA-00933: SQL 命令未正确结束

这是我的java代码

String update= updatetf.getText();
String fname = fnametf.getText();
String lname = lnametf.getText();
String addr = addresstf.getText();
String province = provincetf.getText();
String pcode= pcodetf.getText();
String phone= phonetf.getText();

        try {
            Statement stm = connection.createStatement();

            String sql = "UPDATE PLAYER SET "+
                    "FIRST_NAME ='"+ fname + "', "
                    +"LAST_NAME ='" + lname + "', " …

我有一个数组列表：

ArrayList<int[]> al1 = 
   0 = [1,1,1,1,1]
   1 = [0,1,0,1,1]
   2 = [0,0,0,0,0]
...

并且方法必须返回 int[]，如下所示：

1,1,1,1,1,0,1,0,1,1,0,0,0,0,0

怎么做？

我正在尝试将此 for 循环和 if 条件转换为 Java 流、过滤和收集

final List<Optional<String>> students = listofstudents.get();

final List<String> finalist = new ArrayList<>(students.size());

for(int i=0; i<students.size(); i++) {
    if(students.get(i).isPresent()) {
        finalist.add(students.get(i).get());
    }
    else {
        finalist.add(null);
    }
}

我试过这个：

List<String>result = null;

students.stream()
        .filter(e -> e.isPresent())
        .map(e->result.add(e))
        .orElse(result.add(null)
        .collect(Collectors.toList());

然而，这是完全错误的。我无法让它按预期工作

有人可以告诉我应该如何使用流、过滤器、收集来做到这一点吗？

我想通过我的构造函数添加方法并在之后使用它：

RegularAxis lon = new RegularAxis(){
    public String returnHello(){
         return "hello";
    }
};

lon.returnHello();

我无法访问我的新方法。还有其他方法吗？

我正在通过 SonarQube 扫描我的代码，它显示此代码气味“迭代“entrySet”而不是“keySet””。我尝试过，但我无法弄清楚。

示例代码：

public Set<Date> getAccountShiftDate(Map<String, Set<String>> shiftDatesMap, List<Groups> shiftSchedule) {

    // set that has the account shift dates 
    Set<Date> accountShiftDatesTemplate = new Hashset<>();

    // iterate on accounts
    for (String accounts : shiftDatesMap.keySet()) {
        //get group of an account
        Optional <Groups> shiftOptional = shiftList
                                             .stream()
                                             .filter(g -> StringUtils.equalsIgnoreCase(accounts,g.getLongName()))
                                             .findFirst();
        // ...

有人可以给我一个参考来理解这一点。

可以看出（请参见下面重写的测试用例），当由其工具编译和运行时，254 元方法的方法句柄在 Java 17 中占用的内存少于 Java 11 中的内存。

由于 Java 版本11到17的发行摘要中没有宣传与方法句柄或反射相关的功能，所以我很好奇：哪些变化有助于减少内存消耗？

这是一个重写的测试用例ArityLimits.java：

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Supplier;

class ArityLimits
{
    public static void main(String[] args) throws Throwable
    {
        // Pick an implementation with the 1st argument, e.g. core.
        final Invocable invocable = (args.length > 0
                    && args[0].equalsIgnoreCase("core"))
            ? new CoreInvoker(ArityLimits::new)
            : new HandleInvoker(ArityLimits::new,
                MethodHandles.privateLookupIn( …