小编pol*_*nts的帖子

这不是功课.

第1部分

是否可以编写泛型方法,如下所示:

<T extends Number> T plusOne(T num) {
    return num + 1; // DOESN'T COMPILE! How to fix???
}

没有使用一堆instanceof和演员,这可能吗？

第2部分

以下3种方法编译:

Integer plusOne(Integer num) {
    return num + 1;
}   
Double plusOne(Double num) {
    return num + 1;
}
Long plusOne(Long num) {
    return num + 1;
}

是否有可能编写约束仿制药T只Integer,Double或Long？

是否有可能有一个Java printf语句,其输出是语句本身？

一些片段来说明:

// attempt #1
public class Main {
public static void main(String[] args) {

System.out.printf("something");

}
}

这打印something.

因此,尝试#1的输出并不完全是printf尝试#1中的语句.我们可以尝试这样的事情:

// attempt #2
public class Main {
public static void main(String[] args) {

System.out.printf("System.out.printf(\"something\");");

}
}

现在输出是 System.out.printf("something");

所以现在尝试#2的输出与输出#1中的语句匹配,但是我们回到了之前的问题,因为我们需要尝试#2的输出来匹配尝试#2中的语句.

那么可以写一个printf打印自己的单行语句吗？

如果我有一个我想要排序的元素列表,Java提供了两种方法来解决这个问题.

例如,假设我有一个Movie对象列表,我想按标题对它们进行排序.

我可以这样做的一种方法是通过调用静态java.util.Collections.sort()方法的单参数版本,并将我的电影列表作为单个参数.所以我会调用Collections.sort(myMovieList).为了使其工作,必须声明Movie类以实现java.lang.Comparable接口,并且必须在此类中实现所需的方法compareTo().

另一种排序方法是使用影片列表和java.util.Comparator对象作为参数调用静态java.util.Collections.sort()方法的双参数版本.我会调用Collections.sort(myMovieList,titleComparator).在这种情况下,Movie类不会实现Comparable接口.相反,在构建和维护影片列表本身的主类中,我将创建一个实现java.util.Comparator接口的内部类,并实现一个必需的方法compare().然后我将创建此类的实例并调用sort()的双参数版本.第二种方法的好处是您可以创建无限数量的这些内部类比较器,因此您可以以不同的方式对对象列表进行排序.在上面的例子中,

我的问题是,为什么麻烦学习两种方式在Java中进行排序,当Collections.sort()的双参数版本执行第一个单参数版本所做的所有事情时,还有一个额外的好处就是能够对列表的元素进行排序基于几个不同的标准？在编码时必须记住这一点.你有一个基本机制,用Java来排序列表来了解.

我需要使用分隔符拆分文本". ".例如,我想要这个字符串:

Washington is the U.S Capital. Barack is living there.

分为两部分:

Washington is the U.S Capital. 
Barack is living there.

这是我的代码:

// Initialize the tokenizer
StringTokenizer tokenizer = new StringTokenizer("Washington is the U.S Capital. Barack is living there.", ". ");
 while (tokenizer.hasMoreTokens()) {
      System.out.println(tokenizer.nextToken());

}

不幸的是输出:

Washington
is
the
U
S
Capital
Barack
is
living
there

有人可以解释发生了什么吗？

是否有正则表达式的风格,允许我计算*和+运算符匹配的重复次数？我特别想知道它是否可以在.NET平台下运行.

我想在文件中打印以下格式的输出..

1 Introduction                                              1
 1.1 Scope                                                  1
 1.2 Relevance                                              1
   1.2.1 Advantages                                         1
     1.2.1.1 Economic                                       2
   1.2.2 Disadvantages                                      2
2 Analysis                                                  2

我不能让页码在一行中垂直对齐.这该怎么做？？

如何使用正则表达式将字符串“abacda a”转换为字符串“1 b 2 cd 3 4”？

这可能吗？首选的风味是 Perl，但任何其他风味也可以。

s/a/ \????? /g

此C片段是合并算法实现的一部分:

out[i++] = (in1[i1] < in2[i2]) ? in1[i1++] : in2[i2++];

有人可以解释它是如何工作的吗？

鉴于我有一个包含两个构造函数的类:

public class TestClass {
    ObjectOne o1;
    ObjectTwo o2;

    public TestClass(ObjectOne o1) {
        // ..
    }

    public TestClass(ObjectTwo o2) {
        // ..
    }
}

请假设,这ObjectOne是一种interface类型,并且ObjectTwo implements ObjectOne.如果我打电话,会发生什么:

new TestClass(null);

如何确定调用的正确方法？谁决定了？Java和其他OOP语言之间是否存在差异？

假设我们有以下输入:

<amy>
(bob)
<carol)
(dean>

我们还有以下正则表达式:

<(\w+)>|\((\w+)\)

现在我们得到两场比赛(如rubular.com上所示):

• <amy>是匹配,\1捕获amy,\2失败
• (bob)是匹配,\2捕获bob,\1失败

这个正则表达式完成了我们想要的大部分内容,它们是:

• 它恰当地匹配打开和关闭括号(即没有混合)
• 它捕获了我们感兴趣的部分

但是,它确实有一些缺点:

• 重复捕获模式(即"主要"部分)
  • 这只是\w+在这种情况下,但一般来说这可能非常复杂,
    • 如果涉及反向引用,则必须为每个备用重新编号!
    • 重复使维护成为一场噩梦!(如果它改变了怎么办？)
• 这些组基本上是重复的
  • 根据哪些备用匹配,我们必须查询不同的组
    • 它只是\1或\2在这种情况下,但通常"主要"部分可以拥有自己的捕获组!
  • 这不仅不方便,而且可能存在不可行的情况(例如,当我们使用仅限于查询一个组的自定义正则表达式框架时)
• 如果我们也想要匹配等{...},情况会迅速恶化[...].

所以问题很明显:如何在不重复"主要"模式的情况下做到这一点？

注意:在很大程度上我对java.util.regex口味感兴趣,但欢迎其他口味.

附录

这部分没有什么新内容; 它只用一个例子说明了上面提到的问题.

让我们将上面的例子带到下一步:我们现在想要匹配这些:

<amy=amy>
(bob=bob)
[carol=carol]

但不是这些:

<amy=amy)   # non-matching bracket
<amy=bob>   # left hand side not equal to right hand side

使用替代技术,我们有以下工作(如rubular.com上所示): …