java（六）--- java核心类

一、字符串和编码

1、String
java中 String 是一个应用类型，它本身是一个类，但是java编译器对 String 有特殊处理，可以直接用 “…” 来表示一个字符串

String S = "Hello world"; //引号中表示一个字符串

但实际上字符串在 String 内部是通过一个 char[] 数组表示的，因此写法可以是：

...
	String S2 = new String(new char[] {'H','e','l','l','o',' ','W','o','r','l','d','!'});
	System.out.println(S2); //Hello World!

//在java字符串一个重要特点是字符串不可变？

2、字符串比较
若想要比较两个字符串是否相同时，实际上是比较两字符串内容是否相同，所以必须使用 equals() 方法；不能使用 == 来判断

...skip...
 		String h1 = "abc";
		String h2 = "ABC".toLowerCase();
	
		System.out.println(h1 == h2);       //false
		System.out.println(h1.equals(h2));	//true

两个字符串比较时，必须要使用 equal() 方法；若比较忽略大小写的话使用 equalsIgnoreCase() 方法

...skip...
		String h1 = "abc";
		String h2 = "ABC";
		System.out.println(h1.equalsIgnoreCase(h2)); //true

String 类型中提供了多种方法来搜索子串、提取子串，常用的方法有：（注意：字符串是以 0 开始索引的）

	...skip...
		
		String A1 = "Chinese";
		//是否包含子串的方法;contains(option)
		System.out.println(A1.contains("ne"));   //true
		//indexOf(): 从开始搜索第一个位置
		System.out.println(A1.indexOf("e"));     //4
		//lastIndexOf(): 搜索最后出现的位置
		System.out.println(A1.lastIndexOf("e")); //6
		// startswith : 以什么开始
		System.out.println(A1.startsWith("Ch")); //true
		// endswith；以什么结束
		System.out.println(A1.endsWith("se"));   //true

3、去除首尾的空白字符
去掉首尾空白字符使用 trim() 方法。空白字符包空格，\t ，\r，\n:
需要注意的是 trim() 并没有改变字符串内容，而是返回了一个新的字典；strip() 方法也可以一处字符串首尾空白字符，他和 trim() 不同的是，类似中文空格 \u3000 也会被移除；但是 strip() 方法在java11及以上才能使用

在String中提过了isEmpty() 和 isBlank(）

isEmpty() //判断字符串长度是否为0
isBlank() //判断字符串是否为空白

4、替换子串
① 根据字符或字符串替换 replace() 方法

...skip...
		String s = "Hello";
		String m = s.replace("l", "w"); //把所有的字符‘l’ 替换成 ‘w’
		String m1 = s.replace("ll", ".."); //把所有子串‘ll’ 替换成 ‘..’
		System.out.println(m); //Hewwo
		System.out.println(m1); //He..o

② 通过正则表达式替换

		String r = "a,,b;c ,d";
		System.out.println(r.replaceAll("[\\,\\;\\s]+", ","); // a,b,c,d

5、分割字符串
分割字符串使用 split() 方法，并传入正则表达式：

package packagename;
import java.util.Arrays;
...skip...
		String S1 = "a,b,c,d";
		String[] S2 = S1.split("\\,"); // {"a","b","c","d"}
		System.out.println(Arrays.toString(S2)); //打印数组[a,b,c,d] 

6、拼接字符串
拼接字符串使用 join() 方法, 用指定的字符串连接字符串数组

...skip...
		String[] arrayss = {"a","b","c"};
		String S3 = String.join("+++", arrayss);
		
		System.out.println(S3);

输出;

7、类型转换
若要把任意的基本类型或引用类型转换为字符串，可以使用静态方法 valueOf()，这是重载的方法，编译器会自动根据参数自动选择合适的方法：

		//valueOf() 转换为字符串
		String.valueOf(123); //"123"
		//parseInt() 转换为 int 类型
		Integer.parseInt("123"); //123
		//parseBoolean() 转换为 boolean类型
		Boolean.parseBoolean("true"); //true

8、转换为char[]
String 与 char[] 类型相互转换

		//String 转换为  char[] 
		char[] S4 = "Hello".toCharArray();
		
		//char[] 转换为 String
		String S5 = new String(S4);

注意：转换编码就是将String和byte[]转换，需要指定编码；转换为byte[]时，始终优先考虑UTF-8编码

二、StringBuilder

java编译器对 String 做了特殊处理，使得可以使用 + 拼接字符串

package packagename;

public class Time {
    public static void main(String[] args){
        String S1 = "0";
        for (int i=1; i<10; i++){
            S1 = S1 + "," + i;
        }
        System.out.println(S1);
    }
}

输出：

虽然可以直接使用拼接字符串，但是在循环中，每次循环会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分自渡川都是临时对象，浪费内存影响效率；为了能高效拼接字符串，Java中提供了 StringBuilder ，他是一个可变的对象，可以预分配缓冲区，这样 StringBuilder 中新增的字符串，不会创建新的临时对象

public class StringBuilderss {
    public static void  main(String[] args){ 
        StringBuilder SB = new StringBuilder(1024); //创建对象StringBuilder，设置其容量为1024
        for(int i = 1; i < 10; i++){
            if( i > 1){
                SB.append(',');
            }
            SB.append(i);
        }
        System.out.print(SB);
    }
}

输出：

StringBuilder 可以链式操作

public class Stringbuildersstow {
    public static void  main(String[] args){
        StringBuilder SB2 = new StringBuilder();
        SB2.append("Hello")
                .append(" world")
                .append("!")
                .insert(0,"GOOD!"); // 指该字符串插入的位置，字符串的索引是从0开始的
        System.out.println(SB2.toString());
    }
}

输出：

三、StringJoiner

1、使用Stringbuilder 来添加 ，

public class StringJoinerss {
    public static void main(String[] args){
        String[] names = {"Bob","Alice","Tom"};
        StringBuilder sb = new StringBuilder();

        for (String name : names){
            sb.append("hello ");
            sb.append(name).append(",");
        }
        sb.delete(sb.length() - 1, sb.length()); //删除多余的 ，
        System.out.println(sb);
    }
}

输出：

2、使用 StringJoiner

import java.util.StringJoiner;

public class Joiners {
    public static void main(String[] args){
        String[] names = {"Tom","Alice","BOb"};
        StringJoiner sj = new StringJoiner(",","Hello ","!"); //分别表示 分隔符：，   前缀：Hello ； 后缀：！
        for(String name : names){
            sj.add(name);
        }
        System.out.println(sj);
    }
}

输出：

3、String.Join()

public class StringJoinss {
    public static void  main(String[] args){
        String[] names = {"Alice","Bob","Tom"};
        String sj = String.join(", ",names);
        System.out.println(sj);
        }
}

输出：

在用分隔符批结数组时 StringJoiner 或 String.Join（）更方便些；使用 StringJoiner 可以添加前缀和后缀

四、包装类型

1、包装类型
在 java 中的类型有两种
基本类型：byte，short，int，long，boolean，float，double，char
引用类型：class，interface
基本类型不能赋值为 null，但是 引用类型可以赋值为 null

如果想把一个 double 基本类型变成一个引用类型，可以定义一个 Double类：
如：

public class DoubleClass {
    public static void main(String[] args){
        Integer D = null;
        Integer D2 = new Integer(33);
        int D3 = D2.intValue();
        System.out.println(D3); //33

    }
}
class Integer{
    private int value;
    public Integer(int value){
        this.value = value;
    }

    public int intValue(){
        return this.value;
    }
}

在 java 中每个基本类型都有提供对应的包装类型了，可以直接使用不需要再去定义

boolean java.lang.Boolean
byte java.lang.Byte
short java.lang.Short
int java.lang.Integer
long java.lang.Long
float java.lang.Float
double java.lang.Double
char java.lang.Character

public class JavaLang {
    public static void main(String[] args){
        int i = 100;
        //通过 new 操作符创建 Integer 实例，不推荐编译器会有警告
        Integer n1 = new Integer(i);
		//通过静态方法 valurOf(int) 创建 Integer 实例
        Integer n2 = Integer.valueOf(i);
		//通过静态方法 valueOf（String）创建 Integer 实例
        Integer n3 = Integer.valueOf("100");

        System.out.println(n3.intValue()); //100
    }
}

2、自动封箱（Auto Boxing）
int 和 Integer 可以转换，Java 编译器可以帮助我们自动 在 int 和 Integer 之间转型
int 和 Integer 相互转型

int i = 100;
Integer n = Integer.valueOf(i);
int x = n.intvalue();

自动转型，下面这个过程就为 自动封箱的操作

java.lang.Integer n = 100; //编译器自动使用 Integer.valueOf(int)
int x = n; //编译器自动使用 Integer.value()

3、不变类
所有的包装类型都是不变类，Integer 的源码如下，为 fanal 修饰可知：

public final class Integer{
	public final int value;
}

在比较 Integer 实例时，需要注意的是不能使用 == 比较，因为 Integer 是引用类型，必须使用 equals() 方法

package packagename;

public class Conpare {
    public static void main(String[] args){
        java.lang.Integer x = 122;   //此JDK版本1.8，其他版本可是直接写  Integer var = 值
        java.lang.Integer y = 122;
        java.lang.Integer m = 123456;
        java.lang.Integer n = 123456;

        System.out.println(x == y); //true
        System.out.println(m == n); //false
        System.out.println(m.equals(n)); //true
        System.out.println(x.equals(y)); //true
    }
}

通过上面实例可以看出，"" 比较，前面较小的值 Integer 返回 true ，较大的 Integer 返回为 false ，因为 Integer 是不变类，编译器自动把 java.lang.Integer x = 122；自动变为 Integer.valueOf(122)；为了节省内存，Integer.value() 对于娇小的数，始终返回同一个实例，因此,"" 比较中，“恰好” 为true，必须使用 equals() 方法比较连个 Integer；
创建 Integer 有两种方法

方法1：java.lang.Integer n = new Integer(100);
方法2：java.lang.Integer n = Integer.valueOf(100);

方法2更好吗，把新的对象的静态方法称为静态工厂方法，Integer.valueOf() 就是静态工厂方法，返回的是缓存实例以节省内存

4、进制转换

Integer 类本身提供了大量的方法，如最常用的静态方法 parseInt() 可以把字符串解析成一个整数

public class paresIntss {
    public static void main(String[] args){
        int i1 = java.lang.Integer.parseInt("100");
        int i2 = java.lang.Integer.parseInt("100",16); //按照16进制解析
        
        System.out.println(i1);   //100
        System.out.println(i2);   //256
    }
}

所有整数和浮点数的包装类型都继承自 Number 。因此，可以非常方便的直接通过包装类型获取各种基本类型

public class Numberint {
    public static void main(String[] args){
        Number num = new java.lang.Integer("999");
        //获取byte，int，long，float，double
        byte b = num.byteValue();
        int i = num.intValue();
        long l = num.longValue();
        float f = num.floatValue();
        double d = num.doubleValue();

五、处理无符号整型（Unsigned）
java中，并没有无符号整型的基本类型，最高位是符号位，如：byte 是有符号整型 -128~ +127 ；如果把 byte 看作无符号整型，其返回就是 0 ~ 255.把负的 byte 按无符号整型转换 int ；

public class Unsdalhjfl {
    public static void main(String[] args){
        byte x = -1;
        byte y = 127;

        System.out.println(Byte.toUnsignedInt(x)); //255
        System.out.println(Byte.toUnsignedInt(y)); //127
    }
}

因为byte的 -1 的二进制表示是 11111111 ，以无符号整型转换后的 int 就是 255

五、javaBean

1、javaBean
在java中，很多 class 的定义都符合这样的规范：
若干 private 实例字段；
通过 public 方法来读写实例字段
如果读写方法符合以下这种命名规范：

//读方法
public Type getName()
//写方法
public void setName(Type value)

那么这种 class 被称为 JavaBean；以上的 name 字段，读写方法名分别以 get 和 set 开头，并且后接大写字母开头的字段名 Name，因此两个读写方法名分别是 getName() 和 setName()。
boolean 字段比较特殊，它的读方法一般命名为 isName()

2、JavaBean的作用
JavaBean 主要用来传递数据，即把一组数据组合成一个 JavaBean 便于传输。此外，javabean 可以方便地被 IDE 工具分析生活才能够读写属性的代码，主要用在图形界面的可视化设计中

六、枚举类

1、enum

public class Enumeration {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN; 
        if (day == Weekday.SAT || day == Weekday.SUN) {
            System.out.println("在家工作");
        } else {
            System.out.println("在办公室工作");
        }
    }
}

enum Weekday{
    SUN,MON,TUE,WED,THU,FRI,SAT
}

需要注意的是，定义枚举类的关键字是 enum 实现的，只需要依次列举枚举的常量名

2、enum的比较
使用 enum 定义的枚举类是一种引用类型。引用类型的比较，要使用 equals() 方法；但是 enum 类型可以例外，以为 enum 的每个常量在JVM 中只是一个唯一实例，所以可以直接使用 == 比较，equals()方法也可以进行比较，但是会多些一定的代码

3、enum类型
enum 定义的枚举类和其他的 class 是没有区别的，enum 定义的类型就是class，其特点有：
① enum 类型总是继承自 java.lang.Enum，是无法被继承的
② 只能定义出 enum 实例，而无法通过 new 操作符创建 enum 的实例
③ 定义每个实例都雷丁唯一实例
④ 可以将 enum 用于 switch 语句

name() 返回常量名

...skip...
 public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        String s = Weekday.SUN.name(); //返回常量名 
        ...skip...

输出：

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

		int n = Weekday.MON.ordinal();
        System.out.println(n);  //1