分类

Java学习_Java核心类

JAVA学习网 2020-12-25 19:28:01
  • 字符串和编码
    • 字符串在String内部是通过一个char[]数组表示的，因此，可以按下面的写法： 
      String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});
    • Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。
    • Java编译器在编译期，会自动把所有相同的字符串当作一个对象放入常量池。
    • 两个字符串比较，必须总是使用equals()方法。
    • 要忽略大小写比较，使用equalsIgnoreCase()方法。
    • String还提供了isEmpty()和isBlank()来判断字符串是否为空和空白字符串。
    • 拼接字符串使用静态方法join()，它用指定的字符串连接字符串数组。 
      String[] arr = {"A", "B", "C"};
String s = String.join("***", arr); // "A***B***C"
    • 字符串提供了formatted()方法和format()静态方法，可以传入其他参数，替换占位符，然后生成新的字符串。 
      1 public class Main {
2     public static void main(String[] args) {
3         String s = "Hi %s, your score is %d!";
4         System.out.println(s.formatted("Alice", 80));
5         System.out.println(String.format("Hi %s, your score is %.2f!", "Bob", 59.5));
6     }
7 }
    • 要把任意基本类型或引用类型转换为字符串，可以使用静态方法valueOf()。 
      1 String.valueOf(123); // "123"
2 String.valueOf(45.67); // "45.67"
3 String.valueOf(true); // "true"
4 String.valueOf(new Object()); // 类似java.lang.Object@636be97c
    • new String(char[])创建新的String实例时，它并不会直接引用传入的char[]数组，而是会复制一份，所以，修改外部的char[]数组不会影响String实例内部的char[]数组，因为这是两个不同的数组。
    • 那我们经常使用的UTF-8又是什么编码呢？因为英文字符的Unicode编码高字节总是00，包含大量英文的文本会浪费空间，所以，出现了UTF-8编码，它是一种变长编码，用来把固定长度的Unicode编码变成1～4字节的变长编码。通过UTF-8编码，英文字符'A'的UTF-8编码变为0x41，正好和ASCII码一致，而中文'中'的UTF-8编码为3字节0xe4b8ad。

  • StringBuilder

    • String虽然可以直接拼接字符串，但是，在循环中，每次循环都会创建新的字符串对象，然后扔掉旧的字符串。
    • 为了能高效拼接字符串，Java标准库提供了StringBuilder，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象。
    • StringBuilder还可以进行链式操作。 
       1 public class Main {
 2     public static void main(String[] args) {
 3         var sb = new StringBuilder(1024);
 4         sb.append("Mr ")
 5           .append("Bob")
 6           .append("!")
 7           .insert(0, "Hello, ");
 8         System.out.println(sb.toString());
 9     }
10 }
    • 查看StringBuilder的源码，可以发现，进行链式操作的关键是，定义的append()方法会返回this，这样，就可以不断调用自身的其他方法。
    • 对于普通的字符串+操作，并不需要我们将其改写为StringBuilder，因为Java编译器在编译时就自动把多个连续的+操作编码为StringConcatFactory的操作。在运行期，StringConcatFactory会自动把字符串连接操作优化为数组复制或者StringBuilder操作。
    • public StringBuilder delete​(int start, int end)
  • StringJoiner
  • 包装类型
    • 自动装箱（Auto Boxing）
    • 所有的包装类型都是不变类。 
      1 //源码
2 public final class Integer {  
3     private final int value;
4 }

    • 我们把能创建“新”对象的静态方法称为静态工厂方法。Integer.valueOf()就是静态工厂方法，它尽可能地返回缓存的实例以节省内存。创建新对象时，优先选用静态工厂方法而不是new操作符。

    • 程序设计的一个重要原则：数据的存储和显示要分离。

    • 处理无符号整型

  • JavaBean

    • class的定义都符合这样的规范：

      • 若干private实例字段；
      • 通过public方法来读写实例字段。 
        // 读方法:
public Type getXyz()
// 写方法:
public void setXyz(Type value)
      • boolean字段比较特殊，它的读方法一般命名为isXyz()。 
        // 读方法:
public boolean isChild()
// 写方法:
public void setChild(boolean value)

      • 把一组对应的读方法（getter）和写方法（setter）称为属性（property）。例如，name属性：

        • 对应的读方法是String getName()
        • 对应的写方法是setName(String)
        • 只有getter的属性称为只读属性（read-only）
        • 只有setter的属性称为只写属性（write-only枚举一个JavaBean的所有属性，可以直接使用Java核心库提供的Introspector。 
      •  1 import java.beans.*;
 2 
 3 public class Main {
 4     public static void main(String[] args) throws Exception {
 5         BeanInfo info = Introspector.getBeanInfo(Person.class);
 6         for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
 7             System.out.println(pd.getName());
 8             System.out.println("  " + pd.getReadMethod());
 9             System.out.println("  " + pd.getWriteMethod());
10         }
11     }
12 }
13 
14 class Person {
15     private String name;
16     private int age;
17 
18     public String getName() {
19         return name;
20     }
21 
22     public void setName(String name) {
23         this.name = name;
24     }
25 
26     public int getAge() {
27         return age;
28     }
29 
30     public void setAge(int age) {
31         this.age = age;
32     }
33 }

        输出：
        age
          public int Person.getAge()
          public void Person.setAge(int)
        class
          public final native java.lang.Class java.lang.Object.getClass()
          null
        name
          public java.lang.String Person.getName()
          public void Person.setName(java.lang.String)
  • 枚举类
    • Java中，我们可以通过static final来定义常量。但使用这些常量来表示一组枚举值的时候，有一个严重的问题就是，编译器无法检查每个值的合理性。定义的常量仍可与其他变量比较。 
       1 class Weekday {
 2     public static final int SUN = 0;
 3     public static final int MON = 1;
 4     public static final int TUE = 2;
 5     public static final int WED = 3;
 6     public static final int THU = 4;
 7     public static final int FRI = 5;
 8     public static final int SAT = 6;
 9 }
10 
11 //可编译下列代码
12 if (weekday == 6 || weekday == 7) {   //Weekday定义的常量范围是0~6，并不包含7，编译器无法检查不在枚举中的int值；
13     if (tasks == Weekday.MON) {
14         // TODO:
15     }
16 }
    • 定义枚举类是通过关键字enum实现的，只需依次列出枚举的常量名。enum常量本身带有类型信息，即Weekday.SUN类型是Weekday（第二代码块），编译器会自动检查出类型错误。 
       1 public class Main {
 2     public static void main(String[] args) {
 3         Weekday day = Weekday.SUN;
 4         if (day == Weekday.SAT || day == Weekday.SUN) {
 5             System.out.println("Work at home!");
 6         } else {
 7             System.out.println("Work at office!");
 8         }
 9     }
10 }
11 
12 enum Weekday {
13     SUN, MON, TUE, WED, THU, FRI, SAT;
14 }
       1 public class Main {
 2     public static void main(String[] args) {
 3         Weekday day = Weekday.SUN;
 4         System.out.println(day.getClass());
 5     }
 6 }
 7 
 8 enum Weekday {
 9     SUN, MON, TUE, WED, THU, FRI, SAT;
10 }
    • 使用enum定义的枚举类是一种引用类型。比较要使用equals()方法，但enum类型的每个常量在JVM中只有一个唯一实例，所以可以直接用==比较。

    • enum定义的类型就是class，有以下几个特点：

      • 定义的enum类型总是继承自java.lang.Enum，且无法被继承；
      • 只能定义出enum的实例，而无法通过new操作符创建enum的实例；
      • 定义的每个实例都是引用类型的唯一实例；
      • 可以将enum类型用于switch语句。
    • enum是一个class，每个枚举的值都是class实例，因此，这些实例有一些方法：
      • name() 返回常量名    
        String s = Weekday.SUN.name(); // "SUN"

      • ordinal()　返回定义的常量的顺序，从0开始计数

        int n = Weekday.MON.ordinal(); // 1
      • values() 返回枚举类中所有的值。
      • 枚举跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 访问修饰符，所以外部无法调用。enum的构造方法要声明为private，字段强烈建议声明为final。
         1 public class Main {
 2     public static void main(String[] args) {
 3         Weekday day = Weekday.SUN;
 4         if (day.dayValue == 6 || day.dayValue == 0) {
 5             System.out.println("Today is " + day + ". Work at home!");
 6         } else {
 7             System.out.println("Today is " + day + ". Work at office!");
 8         }
 9     }
10 }
11 
12 enum Weekday {
13     MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");
14 
15     public final int dayValue;
16     private final String chinese;
17 
18     private Weekday(int dayValue, String chinese) {
19         this.dayValue = dayValue;
20         this.chinese = chinese;
21     }
22 
23     @Override
24     public String toString() {
25         return this.chinese;
26     }
27 }
      • 枚举类中的抽象方法实现，需要枚举类中的每个对象都对其进行实现。 
         1 public class Test{
 2     public static void main(String[] args) {
 3         for (Color c:Color.values()){
 4             System.out.print(c.getColor() + "、");
 5         }
 6     }
 7 }
 8 
 9 enum Color{
10     RED{
11         public String getColor(){//枚举对象实现抽象方法
12             return "红色";
13         }
14     },
15     GREEN{
16         public String getColor(){//枚举对象实现抽象方法
17             return "绿色";
18         }
19     },
20     BLUE{
21         public String getColor(){//枚举对象实现抽象方法
22             return "蓝色";
23         }
24     };
25     public abstract String getColor();//定义抽象方法
26 }
      • switch内使用（枚举开关的大小写标签必须是枚举常量的非限定名称，通俗的讲，就是不带类名，如不能是Weekday.MON，而是MON） 
         1 public class Main {
 2     public static void main(String[] args) {
 3         Weekday day = Weekday.SUN;
 4         switch(day) {
 5         case MON:
 6         case TUE:
 7         case WED:
 8         case THU:
 9         case FRI:
10             System.out.println("Today is " + day + ". Work at office!");
11             break;
12         case SAT:
13         case Weekday.SUN:
14             System.out.println("Today is " + day + ". Work at home!");
15             break;
16         default:
17             throw new RuntimeException("cannot process " + day);
18         }
19     }
20 }
21 
22 enum Weekday {
23     MON, TUE, WED, THU, FRI, SAT, SUN;
24 }
  • 纪录类
    • String、Integer等类型都是不变类，一个不变类具有以下特点：
      • 定义class时使用final，无法派生子类；
      • 每个字段使用final，保证创建实例后无法修改任何字段。
    • Java 14开始，引入了新的Record类。 
       1 public class Main {
 2     public static void main(String[] args) {
 3         Point p = new Point(123, 456);
 4         System.out.println(p.x());
 5         System.out.println(p.y());
 6         System.out.println(p);
 7     }
 8 }
 9 
10 public record Point(int x, int y) {}
      public record Point(int x, int y) {}

//把上述定义改写为class，相当于以下代码：

public final class Point extends Record {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int x() {
        return this.x;
    }

    public int y() {
        return this.y;
    }

    public String toString() {
        return String.format("Point[x=%s, y=%s]", x, y);
    }

    public boolean equals(Object o) {
        ...
    }
    public int hashCode() {
        ...
    }
}

       

    • 编译器默认按照record声明的变量顺序自动创建一个构造方法，并在方法内给字段赋值。假设Point类的x、y不允许负数，我们就得给Point的构造方法加上检查逻辑。

      public record Point(int x, int y) {
    public Point {
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException();
        }
    }
}

//方法public Point {...}被称为Compact Constructor，它的目的是让我们编写检查逻辑，编译器最终生成的构造方法如下：

public final class Point extends Record {
    public Point(int x, int y) {
        // 这是我们编写的Compact Constructor:
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException();
        }
        // 这是编译器继续生成的赋值代码:
        this.x = x;
        this.y = y;
    }
    ...
}

    • 作为record的Point仍然可以添加静态方法。一种常用的静态方法是of()方法，用来创建Point。

       1 public record Point(int x, int y) {
 2     public static Point of() {
 3         return new Point(0, 0);
 4     }
 5     public static Point of(int x, int y) {
 6         return new Point(x, y);
 7     }
 8 }
 9 
10 //这样我们可以写出更简洁的代码：
11 
12 var z = Point.of();
13 var p = Point.of(123, 456);
      　　
阅读(799) 评论(0)