Java中的小知识点总结(一)

Java中的小知识点总结(一)

1.占位符

• String.format()：该方法中有效占位符为 %s、%d、%c 等。
• MessageFormat.format()：该方法中有效占位符为 ｛?｝。? 为非负整数。

import java.text.MessageFormat;

public class Main {
    public static void main(String[] args) {
        //type1
        System.out.println(String.format("数字:%d,字符串:%s", 1, "abc"));
        //type2
        System.out.println(MessageFormat.format("数字:{0},字符串:{1}", 1, "abc"));
    }
}

2.字符串的比较

• 该比较是在Java7之后版本运行的。（Java 7 之后常量池在堆里）

2.1 创建字符串 = 和 new 的区别

• 通过 s1=“abc”; 创建字符串时，字符串被存在常量池中，s1指向常量池中字符串的地址。
• 通过s2=new String(“abc”); 创建字符串时，首先字符串被存在常量池中，然后在堆中保存字符串的副本，最后s2指向堆中字符串地址。

        String s1 = "abc";
        String s2 = new String("abc");

        System.out.println(s1==s2);//false

2.2 字符串在常量池中和堆中的区别

• 常量池中的字符串对象是唯一的。
• 堆中的字符串对象是不唯一的。

		String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        String s4 = new String("abc");

        System.out.println(s1 == s2);//true
        System.out.println(s3 == s4);//false

2.3 intern()方法

• 若字符串存在于常量池中，intern()方法会返回一个对象引用，该对象引用指向常量池中的字符串。

		String s1 = "abc";
        String s2 = new String("abc");

        System.out.println(s1 == s2.intern());//true

• 若字符串不存在于常量池中，intern()方法首先会在常量池中保存该字符串对象的引用，然后返回一个对象引用，该对象引用指向常量池中的引用。

        String s1 = new String("ab")+new String("cd");//1
        System.out.println(s1 == s1.intern());//true

        String s2 = new String("ab")+new String("cd");//2
        System.out.println(s2 == s2.intern());//false

        System.out.println(s1 == s2.intern());//true

        /**
         * 执行完1时，常量池中存在"ab"和"cd"；堆中存在"abcd"；s1指向堆中"abcd"的地址。
         * s1.intern()执行，因为常量池中并不存在"abcd"，所以会将堆中"abcd"的引用保存在常量池中。
         * 此时常量池中存在的是："ab"和"cd"和一个象征"abcd"引用,这个引用指向的是堆中保存的"abcd"。
         * 所以： s1 和 s1.intern() 实际指向同一个对象。
         */
        /**
         * 执行2后，常量池中存在的是："ab"和"cd"和一个象征"abcd"引用（s1的）；
         * 堆中存在两个"abcd"对象（一个s1的，一个s2的）。
         * s2.intern()执行，因为常量池中存在一个象征"abcd"引用，
         * 会返回一个对象引用，该对象引用指向那个象征"abcd"引用；
         * 实际上，s2.intern()返回的对象引用指向的是堆中的"abcd"（s1的）。
         * 所以： s2 和 s2.intern() 实际指向非同一个对象；
         * s1 和 s2.intern() 实际指向同一个对象。
         */

2.4 使用中间变量也会返回指向堆中对象的引用

• **" "**形式的字符串相加，在编译阶段会被直接合并。eg.“ab”+“cd”—>“abcd”。
• 通过中间变量，字符串相加，在编译阶段不会被合并处理，会返回堆中对象的引用。(类似new)

        String s1 = "ab";
        String s2 = "ab"+"cd";
        String s3 = s1 +"cd";
        String s4 = "abcd";

        System.out.println(s2==s3);//false
        System.out.println(s2==s4);//true

3.System.identityHashCode()

• 该方法是System类中的静态方法，根据对象内存地址来计算哈希值。
• 可以用来判断两个引用对象是否指向同一实例。(在2中可以判断字符串是否是同一对象)

        String s1 = new String("ab")+new String("cd");
        String s2 = new String("ab")+new String("cd");

        System.out.println(System.identityHashCode(s1));//1349393271
        System.out.println(System.identityHashCode(s1.intern()));//1349393271
        System.out.println(System.identityHashCode(s2));//1338668845
        System.out.println(System.identityHashCode(s2.intern()));//1349393271

4.赋值中的技巧

4.1 可读性增强

//java7之后支持
//可以使用下划线分割，获得更好的可读性
int x=1_000_000;

//可以省略小数点前的数字
float y=.5f;

4.2 类型提升

//+、-、*、/、~会导致类型提升
byte x = 2;
byte y = +x;		//错误
byte y = (byte) +x;	//正确

4.3 StringBuffer和StringBuilder

• String对象会存在常量池中，如果对字符串多次操作（比如：拼接），最好使用StringBuffer或StringBuilder，使其操作完成后再转为String对象。
• StringBuffer：同步方法。
• StringBuilder：异步方法。

5.嵌套类

5.1 静态嵌套类

• 静态嵌套类可以有静态成员。

• 静态嵌套类只能访问外部类的静态成员。

• 举例：

  public class Outer {
  	private static int value = 10;
  
  	protected static class Nested {
  		public int getValue() {
  			return value;
  		}
  	}
  }
  

• 访问方式：

  public static void main(String[] args) {
  		Outer.Nested nested=new Outer.Nested();
  		System.out.println(nested.getValue());
  }

5.2 内部类

• 内部类不可以有静态成员。
• 内部类可以访问外部类的静态和非静态成员，包括私有成员。

5.2.1 成员内部类

• 举例：

  public class Outer {
      private int value = 10;
  	
  	private static int staticValue=11;
  
  	protected  class Nested {
  		public int getValue() {
  			// 可以访问外部类的非静态、静态、私有成员
  			return value+staticValue;
  		}
  	}
  }
  

• 访问方式：

  public static void main(String[] args) {
  		Outer outer=new Outer();
  		Outer.Nested nested=outer.new Nested();
  		System.out.println(nested.getValue());
  }
  

5.2.2 局部内部类

• 局部内部类作用域位于代码块之中。例如：if语句块、while语句块等。

• 举例：

  public interface Logger {
      void log(String message);
  }
  
  public class Outer {
      String time = LocalDateTime.now().format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
      
      public Logger getLogger() {
  		class LoggerImpl implements Logger {
  			@Override
  			public void log(String message) {
  				System.out.println(time + " : " + message);
  			}
  		}
  		return new LoggerImpl();
  	}
  }
  

• 访问方式：

  public static void main(String[] args) {
      Outer outer=new Outer();
      Logger logger=outer.getLogger();
      logger.log("Hello!");
  }
  

5.2.3匿名内部类

• 匿名内部类没有名称，用于实现接口。

• 接口：

  public interface Logger {
      void log(String message);
  }
  

• 举例：

  public static void main(String[] args) {
      Logger logger=new Logger() {
          @Override
          public void log(String message) {
              System.out.println("Hello "+message);
          }
      };
      logger.log("world！");
  }
  

6.参考资料

• GitHub