java基础知识点2

String.intern()

使用String.intern()可以保证相同内容的字符串共享相同的内存,如果您有“ john”出现1000次的名称列表，则通过实习可以确保实际上仅分配了一个“ john”内存

String s1 =new String("aaa");
String s2 = new String("aaa");
System,out.println(s1 == s2);          //false
String s3= s1.intern();
System.out.println(s1.intern() == s3); //true

如果是采用 "bbb" 这种使用双引号的形式创建字符串实例，会自动地将新建的对象放入 String Pool 中。

String s4 = "bbb";
String s5 = "bbb";
System.out.println(s4 == s5);  // true
  

    

“ interned”字符串存储在JVM中的特殊内存区域中。该内存区域通常具有固定的大小，并且不属于存储其他数据的常规Java堆的一部分。由于大小固定，可能会在此永久内存区域中填满所有字符串，从而导致难看的问题（无法加载类和其他内容）。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。Java 7，字符串常量池被移到 Native Method 中。

运算

参数传递

Java 的参数是以值传递的形式传入方法中，而不是引用传递。

以下代码中 Dog dog 的 dog 是一个指针，存储的是对象的地址。在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中改变指针引用的对象，那么这两个指针此时指向的是完全不同的对象，一方改变其所指向对象的内容对另一方没有影响。

class Dog{
    String name;

    Dog(String name){
        this.name = name;
    }
    String getName(){
        return this.name;
    }

    void setName(String name){
        this.name = name;
    }

    String getObjectAddress(){
        return super.toString();
    }
}

public class PassByValueExample {
    public static void main(String[] args) {
        Dog dog = new Dog("A");
        System.out.println(dog.getObjectAddress());//Dog@14ae5a5
        System.out.println(dog.getName());//A
        func(dog);
        System.out.println(dog.getObjectAddress());//Dog@14ae5a5
        System.out.println(dog.getName());//A
    }

    private static void func(Dog dog){
        System.out.println(dog.getObjectAddress());//Dog@14ae5a5
        dog = new Dog("B");
        System.out.println(dog.getObjectAddress());//Dog@131245a
        System.out.println(dog.getName());//B
    }
}

但是如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容。

class PassByValueExample {
    public static void main(String[] args) {
        Dog dog = new Dog("A");
        func(dog);
        System.out.println(dog.getName());          // B
    }

    private static void func(Dog dog) {
        dog.setName("B");
    }
}

float 与 double

1.1 字面量属于 double 类型，不能直接将 1.1 直接赋值给 float 变量，因为这是向下转型。Java 不能隐式执行向下转型，因为这会使得精度降低。

// float f = 1.1;
  
    

1.1f 字面量才是 float 类型。

float f = 1.1f;

    

隐式类型转换

直到今天，我还以为例如：

i += j;

只是以下方面的捷径：

i = i + j;

但是，如果我们尝试这样做：

int i = 5;
long j = 8;

然后i = i + j;将不会编译，但i += j;会编译良好。

这是否意味着实际上i += j;是此类事情的捷径 i = (int) (i + j)

基本上当我们写

i += l; 

编译器将此转换为

i = (int)(i + l);

1 是 int 类型，它比 short 类型精度要高，因此不能隐式地将 int 类型下转型为 short 类型。

short s1 = 1;
// s1 = s1 + 1;
  
   
    

但是使用 += 运算符可以执行隐式类型转换。

s1 += 1;
  
    
    

1

上面的语句相当于将 s1 + 1 的计算结果进行了向下转型:

s1 = (short) (s1 + 1);
  

java基础知识点2

原文：https://www.cnblogs.com/tyy8/p/14358660.html