小编Pau*_*ton的帖子

这个问题主要不是关于字符串.出于学术上的好奇心,我想知道final变量上的修饰符如何改变程序的行为.以下示例显示了它是可能的.

打印这些线条 true

final String x = "x";
System.out.println(x + x == "xx");

但这些线条打印出来 false

String x = "x";
System.out.println(x + x == "xx");

除了String实习之外,如果final从变量声明中删除修饰符,还有其他任何可能导致程序行为发生变化的事情吗？我假设程序使用或不使用修饰符进行编译.

请不要投票将其关闭为比较使用==在Java中声明为final的字符串的副本.我理解这个String例子.

我问是否有任何其他原因删除final修饰符可以有所作为.请有人链接到答案或回答问题.谢谢.

我昨天发现你可以创建一个看起来像这样的Java for循环

for (int j = 0; j < myArray.length; System.out.println(j), j++ ) {

/* code */

}

这对我来说真的很不寻常.何时编码可接受/有用？

该方法的文档getClass()中Object说:

实际结果的类型是Class<? extends |X|>其中|X|是静态类型在其上的getClass称为表达的擦除.

那么为什么foo编译但不是bar？

static void foo(String s) {
    try {
        Class<? extends String> clazz = s.getClass();
    } catch (Exception e) {

    }
}

static <T> void bar(T t) {
    try {
        Class<? extends T> clazz = t.getClass();
    } catch (Exception e) {

    }
}

编辑

我接受了yshavit的答案,因为它清楚地回答了我的问题,但我仍然很想知道他们为什么这样定义它.他们可以将它定义为具有类型Class<? extends T>,其中T是静态类型的表达式.我不清楚为什么在这个阶段删除类型信息是必要的.如果类型是有意义的List<String>,但不是如果它是T.我会向任何解释这个问题的答案进行投票.

我对这些注释的正确使用感到困惑.

android.support.annotation.NonNull;
android.support.annotation.Nullable;

文档中的信息@NonNull说:

表示参数,字段或方法返回值永远不能为空.

在参数的情况下,这意味着什么,什么都没有阻止你通过null？

例如,假设我有一个类MyObject,并且实例可能有也可能没有标题.

public final class MyObject {

    private String title = null;

    public void setTitle(String title) {
        if (title == null)
            throw new NullPointerException();
        this.title = title;
    }

    public void clearTitle() {
        title = null;
    }
}

这里我null用来表示标题的缺失,但这是一个实现细节,所以我不想要一种方法来设置和清除标题.

如果我将该字段标记title为@Nullable,android studio告诉我该参数setTitle应该也应该被标记@Nullable(但这与我想要的相反).

如果我将参数标记到setTitle方法,因为@NonNull我得到一个警告条件title == null总是false.

在这种情况下,这些注释的正确用法是什么？如果@NonNull指的是参数可以永远null是错用它来指应该 …

我有2个Java类.

class A {
 String name;
 List<B> numbers;
}

class B {
 Integer number;
}

我希望得到A类的独特之处并将其中的B列表连接起来.

例如,假设我有一个包含以下对象的List.

List<A>{
 name = "abc"
 List<B>{1,2}

 name= "xyz"
 List<B>{3,4}

 name = "abc"
 List<B>{3,5}
}

结果应该是:

List<A>{
 name = "abc"
 List<B>{1,2,3,5}

 name="xyz"
 List<B>{3,4}
}

任何帮助,将不胜感激.

注意:我想使用Java 8流实现此功能.

谢谢

根据KeyboardView.OnKeyboardActionListener.onRelease()SDK文档,"对于重复的键,这只被调用一次".但是,如果我设置isRepeatable真要与Android Softkeyboard比如"一"键,和日志onPress(),onKey()以及onRelease()方法调用,我得到重复的预期,但我遵守以下日志,只需按一下/复读/释放顺序:

I/SoftKeyboard(31467): onPress: 97
I/SoftKeyboard(31467): onKey: 97
I/SoftKeyboard(31467): onRelease: 97
I/SoftKeyboard(31467): onKey: 97
I/SoftKeyboard(31467): onRelease: 97
I/SoftKeyboard(31467): onKey: 97
I/SoftKeyboard(31467): onRelease: 97
I/SoftKeyboard(31467): onKey: 97
I/SoftKeyboard(31467): onRelease: 97
I/SoftKeyboard(31467): onKey: 97
I/SoftKeyboard(31467): onRelease: 97

如何确定触摸设备的确切释放时间？感谢:D.

编辑(Paul Boddington编辑30/07/2015)

虽然我不是OP,但我想提供一个显示问题的完整示例.

MyActivity:

public class MyActivity extends Activity {

    private static final String TAG = "MyActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);
        KeyboardView keyboardView = (KeyboardView) findViewById(R.id.keyboard_view);
        keyboardView.setKeyboard(new Keyboard(this, R.xml.keyboard));
        keyboardView.setOnKeyboardActionListener(new KeyboardView.OnKeyboardActionListener() …

我正在尝试编写一个方法,在列表列表中查找对象的索引并利用并行性.这是我的代码.

// returns [i, j] where lists.get(i).get(j) equals o, or null if o is not present.
public static int[] indices(List<? extends List<?>> lists, Object o) {
    return IntStream.range(0, lists.size())
                    .boxed()
                    .flatMap(i -> IntStream.range(0, lists.get(i).size()).mapToObj(j -> new int[]{i, j}))
                    .parallel()
                    .filter(a -> {
                        System.out.println(Arrays.toString(a));     // For testing only
                        return Objects.equals(o, lists.get(a[0]).get(a[1]));
                    })
                    .findAny()
                    .orElse(null);
}

当我运行以下代码时

List<List<String>> lists = Arrays.asList(
        Arrays.asList("A", "B", "C"),
        Arrays.asList("D", "E", "F", "G"),
        Arrays.asList("H", "I"),
        Collections.nCopies(5, "J")
);
System.out.println("Indices are " + Arrays.toString(indices(lists, "J")));

输出是这样的

[0, 0] …

我想使用一个，List<E>但我唯一要使用的方法是

E remove(int index)

我对此方法（已E删除）的返回值感兴趣。我永远不需要这种方法remove(E e)。

我唯一需要的构造函数是一个Collection<? extends E>。

如果List为ArrayList，则该remove(int index)方法具有时间复杂度O（n），因为您必须在将删除的元素向左移一个位置之后对元素进行随机排序。

如果List为a LinkedList，则该remove(int index)方法也具有时间复杂度O（n），因为尽管花费O（1）的时间来更改元素上的链接，但是您必须index通过遍历来找到索引处的元素List。

如果我只对使用该remove(int index)方法感兴趣，是否可以编写List<E>针对该方法优化的实现，以使该remove(int index)方法的时间复杂度优于O（n）？

Android工作室似乎认为SparseArray价值观不可能null.

当我写作

public static void foo() {
    SparseArray<Object> sparseArray = new SparseArray<Object>();
    sparseArray.put(0, null);
    if (sparseArray.valueAt(0) == null)
        Log.d("MyClass", "Hello World");
}

我收到了警告

条件'sparseArray.valueAt(0)== null'始终为'false'

我只想知道我需要提出什么注释或评论来消除警告.我不想禁用检查,只是摆脱这个特殊的警告.谢谢.

我正在尝试编写一个方法来获取Collection使用a 的模式Comparator.

有人可以告诉我为了编译这个我需要做些什么改变吗？我不想改变签名.

static <T> T mode(Collection<? extends T> collection, Comparator<? super T> comparator) {
    return collection.stream()
                     .collect(Collectors.groupingBy(t -> t, () -> new TreeMap<>(comparator), Collectors.counting()))
                     .entrySet()
                     .stream()
                     .reduce(BinaryOperator.maxBy(Comparator.comparingLong(Map.Entry::getValue)))
                     .map(Map.Entry::getKey)
                     .orElseThrow(IllegalArgumentException::new);
}

编辑

事实证明我只是使用了错误的版本.这不能使用编译javac 1.8.0_25.确切的三条错误消息是:

Error:(40, 47) java: incompatible types: inferred type does not conform to upper bound(s)
inferred: java.lang.Object
upper bound(s): T,java.lang.Object

Error:(43, 45) java: incompatible types: cannot infer type-variable(s) T
(argument mismatch; invalid method reference
  method getValue in interface java.util.Map.Entry<K,V> cannot be applied …