首页 \ 问答 \ 字符串池与concat一起使用时的行为有所不同？(String Pool behaves differently when used with concat? [duplicate])

字符串池与concat一起使用时的行为有所不同？(String Pool behaves differently when used with concat? [duplicate])

 
  这个问题在这里已经有了答案：  
  
   String.intern（）如何工作以及它如何影响String池？ 1个答案  
  
 
String s1 = "Hello".concat("World");
String s3 = new String("HelloWorld"); //Line-2
String s2 = s1.intern();
System.out.println(s1 == s2); //false
System.out.println(s1 == s3); //false
System.out.println(s2 == s3); //false
 
 如果我删除了Line-2并比较s1 == s2，它将返回true。 任何人都可以解释我在Line-2之后的字符串池中究竟发生了什么？ 什么是在堆中的每一行和常量池中发生的？  
 据我所知，s1将在常量池中创建“HelloWorld”。 但仍然是s1 == s2是错误的？ 

 
 This question already has an answer here: 
  
   How does String.intern() work and how does it affect the String pool?  1 answer   
  
 
String s1 = "Hello".concat("World");
String s3 = new String("HelloWorld"); //Line-2
String s2 = s1.intern();
System.out.println(s1 == s2); //false
System.out.println(s1 == s3); //false
System.out.println(s2 == s3); //false
 
If I removed Line-2 and compare s1==s2, it will return true. Could anyone explain me what exactly happens in string pool after Line-2? And whats happening in each line in heap and in constant pool ? 
From what i understand s1 will create "HelloWorld" in constant pool. But still s1 == s2 is false ?

原文：https://stackoverflow.com/questions/48139521

更新时间：2023-11-21 10:11

最满意答案

 你的transform()方法必须覆盖超类中的通用抽象transform()方法，即你应该有这样的东西：  
public class MyAssembler extends AbstractAssembler {

    @Override
    public <T extends AbstractValue> void transform(T value) {

    }
}
 
 如果你想用一个实际的类型（例如MyValue ）来调用它，你应该这样做：  
MyValue value = new MyValue();
new MyAssembler().transfer(value);
 
 其中明确指定类型参数（ new MyAssembler().<MyValue>transfer(value); ）是可选的，因为它将由编译器推断。  
 
 如果你希望MyAssember的transform方法只能用于MyValue ，那么你应该这样做：  
public class MyAssembler extends AbstractAssembler<MyValue> {

    @Override
    public void transform(MyValue value) {

    }
}

Your transform() method must override the generic abstract transform() method in the super class, i.e. you should have something like: 
public class MyAssembler extends AbstractAssembler {

    @Override
    public <T extends AbstractValue> void transform(T value) {

    }
}
 
If you want to invoke it with an actual type (e.g. MyValue) you should do: 
MyValue value = new MyValue();
new MyAssembler().transfer(value);
 
where explicitly specifying the type-parameter (new MyAssembler().<MyValue>transfer(value);) is optional, as it will be inferred by the compiler. 
 
If you however wish MyAssember's transform method to work only with MyValue, then you should do: 
public class MyAssembler extends AbstractAssembler<MyValue> {

    @Override
    public void transform(MyValue value) {

    }
}

字符串池与concat一起使用时的行为有所不同？(String Pool behaves differently when used with concat? [duplicate])

最满意答案

相关问答

类型删除，覆盖和泛型(Type erasure, overriding and generics)[2023-04-11]

在使用泛型（Java）的扩展接口中覆盖方法契约？(Overriding a method contract in an extended interface that uses generics (Java)?)[2019-11-17]

为什么没有泛型？(Why no generics in Go?)[2022-03-18]

泛型方法覆盖8(Generics method overriding 8)[2021-07-18]

泛型的覆盖方法(Overriding method with Generics)[2022-04-19]

用非泛型实现覆盖泛型方法(Overriding generic methods with non-generic implementations)[2022-12-26]

用泛型错误覆盖方法(Overriding a Method with Generics Errors)[2023-12-12]

Java Generics：覆盖泛型方法，通配符速记？(Java Generics: Overriding generic methods, wildcard shorthand?)[2023-11-13]

泛型本身泛型(Generics itself Generics)[2022-11-14]

覆盖泛型(Overriding with generics)[2022-11-08]

相关文章

最新问答