有一段代码会在某处引发错误：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final Logger logger = LoggerFactory.getLogger(getClass());
...
catch (IOException e)
{
logger.error("IOException occurred while method M1 was running ", e);
}
在程序的某个时刻，它会记录数百行。 问题：如何让它只记录前 20 行？
众所周知，git中删除的分支是可以恢复的。我的情况很复杂，因为：
问题：是否可以恢复旧的NewB？问题是我在其中工作，但没有提交或索引。只是我切换到master的时候，是从-f切换的。
开启了公司的工作项目。而那里 - 文件pom.xml谎言。一是项目的根。还有一些在子文件夹中。
问题：我是否正确理解微服务架构意味着每个服务 -> 一个文件夹 -> 至少存在一个pom.xml. ? 如果不是，那么在一个 spring 项目中存在多个 pom.xml 原则上意味着什么？
我想使用 windows 命令行打开 stackoverflow 主页。这些命令start https://ru.stackoverflow.com/也explorer "https://ru.stackoverflow.com/" 对我不起作用，因为它们会在默认浏览器中打开该站点。我相信，由于命令行显示文本，这意味着它理论上可以显示（即使在使用 krakazyabry 的编码不佳的情况下）网页。
问题：可以用什么命令行打开网站，让网页的内容显示在命令行上？
哪一次我偶然发现了 github 上的代码，例如：
public List<Integer> meth(){
final ArrayList <Integer> arl = new ArrayList()<>;
... //Какая-то реализация
return arl;
}
或者像这样：
public map <Integer, Integer> meth(){
final HashMap <Integer, Integer> hmp = new HashMap()<>;
... //Какая-то реализация
return hmp;
}
在我潜意识的某个地方，我有一个遥远的理解，这是为多线程编程完成的。但它会给什么？
问题：为什么许多 github 上的程序员都创建本地集合final？
假设我有多个线程。所有具有不同输入的人都必须进入该方法
public int MyMeth(int x, int y){
... //какая-то реализация зависящая только от входных данных
return x*y;
}
如果它不使用任何全局变量并且不调用任何使用全局变量的函数，那么使这样的方法同步是否有意义（在多线程环境中） ？
假设我从 github 下载了一个基于 maven 构建的项目。启动后的第一刻，源目录被标记为常规文件夹，片刻之后它变成蓝色。测试一开始是灰色的，然后 IDE 将它们的目录标记为 TestSourceRoot 并变为绿色。
Intellij IDEA 是如何自动判断打开哪个文件夹应该用什么标记的？这些信息是否包含在某个文件中，或者 IDE 本身是否会在解析后猜测所有内容的位置？
有一个类：
public class Segment {
int start;
int finish;
public Segment(int start, int finish) {
this.start = start;
this.finish = finish;
}
}
此类覆盖equals和hashcode。该段定义了一个闭合区间，例如[5;5] - 一个点，[5; 8] - 四点5, 6, 7, 8。
您需要编写一个方法（使用 lambdas），该方法需要两个这些段的数组。在输出中，该方法应该给出一个合并的段数组，并且来自第二个数组的段肯定会到达那里，并且从第一个开始 - 只有那些没有被第二个数组重叠的段。第二段与第一段重叠。一个简单的例子 - 在第一个数组中的一个段[0; 10]，在第二个片段[5; 6]。输出是一个包含三个元素的数组 - [0;4]，[5; 6] , [7; 10]；由于听起来不清楚，所以我画了该方法应该做什么。
我还写了一个方法。在 O(nlog(n)) 中运行 - 大概。它的本质是：
一般来说，这个方法很长。
static ArrayList<Segment> overlap(ArrayList <Segment> one_in, ArrayList <Segment> two_in){
ArrayList <Segment> one = new ArrayList<>(one_in);
ArrayList <Segment> two = new ArrayList<>(two_in);
one.sort(base);
two.sort(base);
ArrayList <Segment> result = new ArrayList<>();
ListIterator <Segment> one_iter = one.listIterator();
ListIterator <Segment> two_iter = two.listIterator();
Segment s = null;
Segment t = null;
OUTER:
for(;one_iter.hasNext();)
{
s = one_iter.next();
two_iter=two.listIterator();
for(;two_iter.hasNext();){
t = two_iter.next();
if(t.start>s.finish) {
result.add(s);
one.remove(s);
one_iter=one.listIterator();
continue OUTER;
}
if(t.finish<s.start){
two.remove(t);
result.add(t);
two_iter = two.listIterator();
continue;
}
if(s.start<t.start){
result.add(new Segment(s.start, t.start-1));
if(t.finish>=s.finish){
// two.remove(t); //ew
// result.add(t);
two_iter = two.listIterator();
one.remove(s); //ew
one_iter=one.listIterator(); //ew
continue OUTER;
}
if(t.finish<s.finish){
result.add(t);
two.remove(t);
two_iter = two.listIterator();
s.start = t.finish+1;
continue;
}
}
else { //Не явно s.start>=t.start
if(t.finish>=s.finish)
{
if(!one_iter.hasNext()) {
result.addAll(two);
two.clear(); //Костыль - На случай кросс
}
one.remove(s);
one_iter=one.listIterator();
continue OUTER;
}
if(t.finish<s.finish){
s.start=t.finish+1;
result.add(t);
two.remove(t);
two_iter = two.listIterator();
}
}
}
}
result.addAll(two);
result.addAll(one);
return result;
}
问题：这样的方法可以接收两个数组，每个数组有一千个元素。如何使用流 API java 8简明扼要地重写它？可以做到吗？因此，没有完全绕过将每个与每个进行比较（ O(n^2) - 不满意，您需要 O(n*log(n))，在极端情况下为 O(n^1.1) ）。从更广泛的意义上说，问题是 - 有没有任何算法可以使用 java 8 工具快速重写旧的遗留代码？
我发现了一个不起作用的技巧：
<h1>you are <a>gay</a></h1>
a{
color;
}
我用谷歌搜索了英文堆栈 - 他们提供分别用不同的颜色为每个字母着色。但问题是，在同性恋旗帜中，条纹是水平的，而不是垂直的，所以垂直颜色看起来并不那么具有象征意义。有没有办法绕过这些限制，以便用户获得彩虹文本并且每个字符都是多色的？
假设我创建了一个集合
volatile ArrayList <Integer> vo_al = new ArrayList<>();
问题：我可以确定当我创建100个线程时，将读取和写入值到那里，线程不会破坏彼此的内存，但是一个线程会随着操作而改变
vo_al.add(2);
将立即对所有其他线程可见？
原则上在多线程编程中用 volatile 一词标记集合是否有意义？
有一个代码。我只想写一个空文件。
public class FileTest {
public static void main(String[] args) {
String fileName = "FileTest0.txt";
String path = "D://";
File file = new File(path, fileName);
}
}
而且该文件根本没有注册。在目录中的隐藏文件中，我也浏览了它-它不存在。但值得做一个最低限度的非空文件 - 在outputStream一切正常后向文件写入一些内容，在目录中找到一个新文件：
public class FileTest {
public static void main(String[] args) {
String fileName = "FileTest0.txt";
String path = "D://";
File file = new File(path, fileName);
try(ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(file))){
os.writeObject(new String("Долой самодержавие и престолонаследие"));
}catch (Exception e){
e.printStackTrace();
}
}
}
问题：为什么该命令new File不会自动导致创建新文件？为什么必须在其中写入一些内容才能在目录中创建新文件？
主题 - lambda 表达式，在模式的上下文中，责任链。我在网上遇到了这段代码：
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@FunctionalInterface
interface RequestHandler {
public abstract Request handle(Request r);
default RequestHandler setSuccessor(RequestHandler other) {
return (req) -> { //req - it's request
System.out.println("req instance of: " +req.getClass().getName());
return other.handle(this.handle(req));
};
}
}
public class Request {
String data;
public String getData() {
return data;
}
public Request(String data) {
this.data = data;
}
}
更详细地说——有一个类Request——它只包含一行，带有一个构造函数和一个 getter。有一个接口RequestHandler——它是一个请求处理程序。它有一个抽象方法handle——用于 lambda 表达式。还有一种方法setSuccessor——进行更深层次的操作。这是setSuccessor我想知道的方法。为什么它会编译？通过签名，它应该返回 RequestHandler，但在第一个返回 (req) 中 - 我发现 req 只是请求。（这行代码 System.out.println("req instance of: " +req.getClass().getName());说的是 Request 的 req 实例） 第二个return other.handle(this.handle(req));，不管怎么说，返回值也是 Request，而不是 RequestHandler！例如，表达式 RequestHandler r = other.handle(this.handle(req));- 表示类型不兼容。
摘要问题：该方法在哪里和哪一行setSuccessor设法返回了一个接口对象RequestHandler？
异常有一个层次结构java，其顶部是一个类Throwable。
问题：编译错误（例如，我没有在必要的地方放置分号）是类的对象Throwable吗？如果编译错误不是类Throwable对象，IDE在编译不正确的程序文本时会抛出什么类对象？
让“res”程序中有一个共享资源。假设有两个线程想要进入临界区：
void Meth(...){
... //Что нужно написать, чтобы на консоль вывелось сообщение, что тред (threadName) ждёт, когда
synchronized (res)//Здесь разделяемый ресурс
{
//some code
}
}
我是这样实现的，一切正常（恕我直言），但我有很大的疑问：
Class Resource {
boolean isBusy = false; //Флаг который бы переключался, если объект ресурса захватывался.
}
class A extend Thread{
String name;
static Resource res = new Resource(); //Создал объект ресурса
void Meth() throws InterruptedException {
try{
while(res.isBusy==true){
System.out.println("Потоку " + this.name + " приходится подождать.");
Thread.currentThread().sleep(7);
}
synchronized (res)//Здесь разделяемый ресурс
{
res.isBusy = true;
... //some code
res.isBusy = false;
}
catch (Exception e){ e.printStackTrace();}
}
}
如果十几个线程周期性地等待直到关键部分被释放，并且在等待的过程中它们必须通知程序员他们正在等待，这样的实现是否正常？我怀疑正确性，因为我正在轮询一个繁忙的对象，试图读取它的字段。所以你绝对可以做到而不用担心程序会崩溃？
java中是否有任何其他普遍接受的实现显示线程无法进入同步块的消息，因为它正在等待释放？
事情是这样的：
2019年12月19日，召开总统新闻发布会。电视频道“俄罗斯 24”的管理员在 youtube 上发布了4 小时的俄罗斯联邦总统弗拉基米尔·弗拉基米尔·普京的大型新闻发布会。
在评论中，人们（反复）抱怨说
“一旦有 50,000 个不喜欢（有时是 51,000 个），它们就会累积到 45,000 个（46、47）等等。”
我不敢相信这种胡说八道，但有这么多评论，我自己决定观察这种现象。
我测量了（没有截图）添加喜欢和不喜欢的动态。
МСК 22;21 19/12/2019
Лайков - 14 083
Дизлайков 50 722
Просмотров 683 317
15 分钟内：
Лайков + 95
Дизлайков +1 237
Просмотров + 14 218
对于每个喜欢，放 11 - 12 个不喜欢。22:23 1442个不喜欢被扭曲：
МСК 22;23
Лайков 14 101 (+18)
Дизлайков 49 328 (-1 442)
Просмотров 683 938 (+621)
23:08截图
截至23:08
14 366 👍🏻
51 970 👎🏻
在 23:38（左右），不喜欢的人下降了！
14 527 👍🏻
51 042 👎🏻
在 23:44，不喜欢也被降级：
23:44图片是这样的 14 583 (+55) 👍🏻 50 053 (-991!!!) 👎🏻
假设你质疑我的数据，那么我给你一个简单的实验：点击链接，在两分钟内取两个指标，计算好恶增长了多少。在我看来，任何相关时间段内的喜欢和不喜欢的比率都不会低于每个喜欢的 10 个不喜欢。
看起来像是敌人的阴谋，但我有简单的问题：
扭转厌恶的方法有哪些？在您看来，有关各方使用了什么扭曲方法？也许对所有事情都有一个平淡无奇的解释，例如“youtube上的服务器由于高流量而滞后”？
当局派我的同事康斯坦丁带着他必须提供的文件到附近的大楼。
问题：从信息论和其他计算机科学的角度来看，我们是否可以将康斯坦丁视为一种数据传输协议，将他周围的街道（在运动过程中）的寒冷视为一种信息传播媒介？
PS。这个问题不是为了好玩，我正在为计算机科学中的傻瓜编写培训手册。
亲爱的同事们！二+二不能对接。对于java中的空缺，他们主要提供编写Web服务器或android。例如，对hh.ru javaFx（gui 库）的请求显示实心零空缺。
事实证明有些奇怪 - Windows 应用程序java实际上不会编写，因为在本机语言中，С/C++一切都运行得更快。但尽管如此，android 开发几乎都在java. 开发人员似乎并不介意它java比本地语言慢。
问题是： 如何、为什么以及为什么会发生windows和andoidom 之间的这种偏见？对于android一切java，windows几乎没有。androida (与 ) 的哪些特性windows优先考虑使用java母语进行开发？
有一个代码，它编译：
public class EqualMeth {
private String name; //Приватное поле
public EqualMeth(String name) { //Конструктор
this.name = name;
}
public boolean equals(EqualMeth p) {
return p.name==this.name; //p.name вроде бы приватно
}
public static void main(String[] args) {
EqualMeth EQ = new EqualMeth("B");
EqualMeth FQ = new EqualMeth("B");
if(FQ.equals(EQ)){
System.out.println("FQ == EQ");
}
else{
System.out.println("FQ != EQ");
}
}
}
在出口处：FQ == EQ
在我看来，在 methodequals(EqualMeth p)中，有一个对p.name不应该可见的私有字段的请求。但是，编译器会看到它。此外，已知 == 运算符用于测试引用相等性。但是在输出中，它说名称FQ和EQ是相等的。
问题：为什么私有字段可见p.name？为什么编译器会这么认为
EQ.name == FQ.name
因为他们有不同的（在我看来）链接？
有一个代码：
public class A { }
public class B extends A { }
public class Test {
public static void main(String...args){
A a2 = new B(); //Восходящее преобразование.
B b1 = a2; // Ошибка компилляции. IncompatibleTypes. Нельзя конвертировать А к B
}
}
问题：为什么 类型引用B不想引用指向 class 对象的父类引用B？为什么B b1 = (B)a2;录制时一切都很完美？
我有一个IntellijIdea正在试验的项目（非常大）。有很多目录，每个目录中有很多类。而且我已经忘记了我昨天在哪里进行了更改。有什么办法可以找到我编辑的最后十个文件？还是连接版本控制系统后才能找到？