小编GBl*_*ett的帖子

因此，通读文档会指出，如果声明一个以L结尾的int常量，它将改为读取long值。这是我的问题：这与将类型命名为很长的名称之间有什么区别吗？例如：

int x = 100L;
VS.
long x = 100;

同样的事情？

到目前为止,我正在尝试创建一个ArrayList共享相同方法的对象,我想按顺序调用它ArrayList.

到目前为止代码是这样的

public class Shape extends Application {
   public void do(GraphicsContext canvas, int size, Color color){
     ;
   } 
}


public class Triangle extends Shape {
   @Override
   public void do(GraphicsContext canvas, int size, Color color){
      canvas.setFill(Color.WHITE);
      double[] xs = {60,80.0,50.0};
      double[] ys = {60,120.0,50.0};
      canvas.fillPolygon(xs,ys,3);
   }
}

并且自动启动的主要类是这样的

public class Main {
    public void drawForegroundContent(GraphicContext canvas){
       ArrayList<Shape> shpes = new ArrayList<Shape>();
       Triangle t = new Triangle();
       shapes.add(t);
       shapes.add(t);

       for (Shape k : shapes){
          k.do(canvas,CoreColor.BLACK, 80);
       }
    } …

Employee john = new Employee("John", "Brown", 32, 100);
Employee camila = new Employee("Camila", "Smith", 25, 101);
Employee pat = new Employee("Pat", "Hanson", 23, 102);

List<Employee> employeeList = List.of(john, camila, pat);

List该List.of()方法生成什么类型的.是一个ArrayList还是一个LinkedList？

我了解到所有具有相同值的图元都具有相同的值，identityHashCode所以我想获取identityHashCode一些图元。因此，当我尝试使用具有相同值的2个双精度值时，它给出了不同的结果，identityHashCode我做了以下操作：

int xInt=5;
int yInt=5;

System.out.println(System.identityHashCode(xInt));//output:1867083167
System.out.println(System.identityHashCode(yInt));//output:1867083167

double double1=5;
double double2=5;


System.out.println(System.identityHashCode(double1));//output:1915910607

System.out.println(System.identityHashCode(double2));//output:1284720968

具有相同值的两个整数具有相同的值，identityHashCode但具有相同值的两个双精度值却具有不同的identityHashCode原因？

我想编写一个获取Queue和参数(int)的函数,该函数删除Queue中与参数相等的var.这是我的代码:

 public static void remove_it( Queue <Integer> q, int x)
{

    Queue <Integer> temp = new LinkedList<Integer>();
    boolean found = false;
    if (!q.isEmpty())
    {
        if (q.peek()==x)
            found = true;
        temp.add(q.remove());
    }

   boolean b;
    if (found)
    {
     b = true;

    while (!temp.isEmpty())
    {
        if (temp.peek() == x  && b)
            {
                temp.remove();
                b = false;
            }
        else
            q.add(temp.remove());
    }
   }

    }

但是,它随时删除队列的第一个变量......为什么？

我在Userservice.java文件“类型类型为'S'的推断类型为'S'的错误中没有得到此错误；” 我不知道在说什么，应该在哪里更改..请检查我的文件并给我一些建议

在此处输入图片说明

package com.therealdanvega.service;

import com.therealdanvega.domain.User;
import com.therealdanvega.repository.UserRepository;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public Iterable<User> list() {
        return userRepository.findAll();
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public void save(List<User> users) {
        userRepository.save(users);
    }
}

用户

package com.therealdanvega.domain;


import lombok.AllArgsConstructor;
import lombok.Data;

import javax.persistence.*;

@Data
@AllArgsConstructor
@Entity
public class User {

    @Id
    @GeneratedValue( strategy = GenerationType.AUTO )
    private Long id;
    private String name; …

下午好 ！

我正在尝试制作某种圆形堆栈。它应该像一个普通的 LIFO 堆栈，但没有明显的限制。它应该消除或跳过当时引入的第一个元素，而不是达到最大容量！

例如：

假设我们有一个包含 3 个元素的堆栈：stack[3]

我们通过将 3 个元素“推入”内部来填充它：push[a], push[b], push[c]。

但随后我们需要添加第四个和第五个元素：push[d], push[e]。

标准堆栈会说堆栈已达到极限，无法添加更多元素。

但我想要一个循环堆栈，它将消除或跳过aand b，记住c，dande并输出e，dand c；

该项目是在 ESP32 上的 PlatformIO 中完成的，因此我无法访问 C++ STL，即使可以访问，我也认为仅为 1 个堆栈编译这么大的库是没有意义的。即使曾经有一段时间我认为我应该编译一个类似的库来让我访问stackor deque，但那个时候已经过去了，因为现在我感觉自己像一个无法解决数学问题的白痴。这已经困扰我一个多星期了。

我在网上找到的只是以下 FIFO 循环缓冲区：

class circular_buffer {
public:
    explicit circular_buffer(size_t size) :
        buf_(std::unique_ptr<T[]>(new T[size])),
        max_size_(size)
    {

    }

    void put(T item)
    {
        std::lock_guard<std::mutex> lock(mutex_);

        buf_[head_] = item;

        if(full_) {
            tail_ …

ArrayList<String> indirizzi = new ArrayList<String>();
for(int i=0; i<n; i++) {
    String ind = in.nextLine();
    indirizzi.get(i).add(ind);
}

该add(String)类型的方法未定义String.

这个程序给我上面的错误.

我不明白为什么.

在这个程序中,我试图返回一个新字符串,该字符串由添加的新字母和旧字母组成(如果不符合约束条件).我不知道如何修复我的代码,以便正确打印.非常感谢任何帮助或建议!

这里有些例子:

str:"asdfdsdfjsdf",单词:"sdf",c:"q"

应该返回"aqdqjq",我得到"asdqqq"

str:"aaaaaaaa",字:"aaa",c:"w"

应该返回"wwaa",截至目前我的代码只返回"ww"

public static String replaceWordWithLetter(String str, String word, String c) 

    String result = "";
    int index = 0;

    while (index < str.length() )
    {
        String x = str.substring(index, index + word.length() );
        if (x.equals(word))
        {
            x = c;
            index = index + word.length();
        }
        result = result + x;
        index++;
    }
    if (str.length() > index)
    {
        result = result + str.substring(index, str.length() - index);
    }
    return result;
 }

有没有办法用两个单词(或更多)创建一个where语句,但它们与给出的单词的顺序不一样？

select 
    i.ITEM_NUMBER as Item,
    min(i.ITEM_DESCRIPTION) as Description,
    i.ORGANIZATION_CODE as Org,
    max(m.MANUFACTURER_NAME) as Manufacturer,
    max(m.MANUFACTURERS_PARTNUMBER) as Partnumber
from mis.XXEAM_INVENTORY_REPORT_WITH_LOCATORS_CONSIGNED_MATERIAL_AND_CATEGORIES_TBL i
left outer join 
    mis.XXEAM_MANUFACTURING_PART_NUMBERS_TBL m on i.ITEM_NUMBER = m.ITEM_NUMBER
where 
    i.ITEM_DESCRIPTION like '%ALLEN BRADLEY%PLC%' 
group by i.ORGANIZATION_CODE, i.ITEM_NUMBER

我想在上面的描述文本中搜索'%ALLEN BRADLEY%PLC%'或'%PLC%ALLEN BRADLEY%'.我想避免使用OR语句,因为数据集很大并且查询可能需要很长时间.

通配符可以超过两个,我只以这两个为例.在我看来,我会更喜欢为第一个单词获取数据集,然后从该数据集中获取第二个单词.也许唯一的方法是选择进入临时表.