Java入门6（String和封装类）-526互联

使用第三方jar包，完成get/set操作

Lombok，结合特殊的注解，实现setter和getter的自动生成

导入jar包
使用插件Lombok
在类里import 即可使用

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

// 使用注解@Data，在类编译的时候，自动给class文件生成getter,setter,toString 以及其他方法
@Data
// 自动生成无参构造
@NoArgsConstructor
// 自动生成有参构造
@AllArgsConstructor
public class Person {
    private String name;
    private String sex;
    private int age;
}

系统常用类 String

// String类
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    ...

String 底层是使用char数组进行存储的，由于在String类中，char数组是用final修饰的，因此String类型的数据不可以被改变！！！

String str = "test01";
char[] cs = str.toCharArray();
// .toCharArray(),使用System.arraycopy方法，将String底层数组复制并输出给cs

构造方法

`String()`无参构造

// String无参构造 -- 空字符串
String tmp = new String();
// 创建出来的空字符串默认没有任何字符存储

`String(byte[] bytes)`字节数组（每一个字符所对应的字符集编码）作为参数

// 将字节数组，转化为字符数组，再将字符数组拼接存储到字符串中
byte[] bs = {65,66,67,68};
String tmp = new String(bs);

`String(char[] value)`char数组作为参数

// 将字符数组拼接存储到字符串中
char[] cs = {'a','q','c'};
String tmp = new String(cs);

`String (String original)`String字符串作作为参数 ---- 字符数组的引用传递

// 将目标字符串底层存储所使用的char数组的内存地址，传递给当前字符串对象所对应的字符数组引用
String tmp = new String("test");
// 等同于
// 使用等号赋值的字符串，默认会使用字符串常量池，来进行字符串对象的复用
String tmp = "test";

等号和new定义字符串的区别

// 通过等号赋值直接定义的字符串是存放在运行时常量池中的，内存地址相同
String tmp = "test";
String tmp1 = "test";
System.out.println(tmp.equals(tmp1)); // true
System.out.println(tmp == tmp1); // true

// 而用new定义的字符串，实在堆中创建，内存地址不同
String tmp = new String("test");
String tmp1 = new String("test1");
System.out.println(tmp.equals(tmp1)); // true
System.out.println(tmp == tmp1); // false

equals方法源码分析

内存地址判断 -> 长度判断 -> 逐位比较

// 源码
public boolean equals(Object anObject) {
    if (this == anObject) { // 判断两个对象内存地址是否相同
        return true;
    }
    if (anObject instanceof String) { // 判断传入的参数是不是String对象
        String anotherString = (String)anObject; // 向下转型，方便后续访问String特有的方法和属性
        int n = value.length; // 当前调用equals方法的字符串所对应的char数组的长度
        if (n == anotherString.value.length) { // 判断两个字符串的长度是不是一致
            char v1[] = value; // v1代表当前字符串所对应的char数组
            char v2[] = anotherString.value; // v2代表参数字符串所对应的char数组
            int i = 0;
            while (n-- != 0) { // 逐位比较
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

API方法

`str.charAt()`通过下表获取索引处的值

String tmp = "test";
System.out.println(tmp.charAt(3)); // t

`str.concat("...")`返回拼接结果，不改变str本身

String tmp = "test";
System.out.println(tmp.concat(" plus")); // test plus

`str.contains("...")`判断是否包含子字符串

String tmp = "test";
System.out.println(tmp.contains("es")); // true

`str.endsWith("...")`判断是不是以...结尾

String tmp = "test";
System.out.println(tmp.endsWith("st")); // true

`str.equalsIgnoreCase(String tmp)`比较时忽略大小写

String tmp = "test";
String tmp1 = "test01";
System.out.println(tmp.equalsIgnoreCase(tmp1)); // false

`str.indexof("...")`返回指定字符第一次出现时的索引值

String tmp = "test";
System.out.println(tmp.indexOf("t")); // 0

`str.indexof("...",index)`返回从index开始往后指定字符第一次出现时的索引值

String tmp = "test";
System.out.println(tmp.indexOf("t",2)); // 3

`str.isEmpty`当且仅当length()为0时返回true

String tmp = "test";
System.out.println(tmp.isEmpty()); // false

`str.toCharArray()`将字符串还原成char数组

String tmp = "test";
System.out.println(tmp.toCharArray()); // test

`str.split("...")`将字符串根据...拆分

String tmp = "This is a test";
String[] res = tmp.split(" ");
for (String i : res) {
    System.out.print(i + " \\ "); // This \ is \ a \ test \ 
}

`str.startsWith(...)`判断是否以指定字符串开头

String tmp = "This is a test";
System.out.println(tmp.startsWith("This")); // true

`str.substring()`字符串截取

String tmp = "This is a test";
// 一个参数确定开始位置
System.out.println(tmp.substring(3)); // s is a test
// 两个参数确定起止位置（左闭右开）
System.out.println(tmp.substring(3,8)); // s is

`str.toLowerCase() / str.toUpperCase()`将字符强制大小写

String tmp = "This is a test";
System.out.println(tmp.toLowerCase()); // this is a test
System.out.println(tmp.toUpperCase()); // THIS IS A TEST

`str.trim()`去除前面和后面的空格

String tmp = "    This is a test    ";
System.out.println(tmp.trim()); // This is a test

系统常用类 StringBuffer / StringBuilder

区别

StringBuffer：支持线程安全，性能相对较差

StringBuilder：不支持线程安全，性能相对较好

使用方式（StringBuilder为例）

// StringBuilder的底层数组比较String的数组，少了一个final修饰符，因此说明StingBuilder时可变的
// 构造方法：
// 无参构造
StringBuilder tmp = new StringBuilder();
// StringBuilder底层使用的是一个叫做value的字符数组(默认16个字符)
System.out.println(tmp.capacity()); // 16
// 如果不断的使用append方法进行字符串拼接，StringBuilder就会自动扩容
tmp.append("Hei bro, this is a test !");
System.out.println(tmp.capacity()); // 34

// 有参构造
// 如果出现有参构造，StringBuilder的容量会在初始化字符串的基础上加上16
StringBuilder tmp = new StringBuilder("This is a test");
System.out.println(tmp.capacity()); // 30

StringBuilder扩容机制

新数组容量 =（原数组的容量+1）*2 ：这种扩容机制会使扩容的次数越来越少，增加性能

// 如果StringBuilder需要扩容，就会定义一个新的char数组
// 新数组容量是（原数组的容量+1）*2
// 并且会将指向原数组的指针指向新数组，原数组会被GC进行回收
private int newCapacity(int minCapacity) {
    // overflow-conscious code
    int newCapacity = (value.length << 1) + 2;
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
        ? hugeCapacity(minCapacity)
        : newCapacity;
}

API方法(StringBuilder特殊的)

`str.capacity()`返回StringBuilder容量

`str.delete(a,b)`删除此序列的子字符串中的字符

// 删除子字符串之后，并不影响StringBuilder容量
StringBuilder tmp = new StringBuilder("This is a test");
System.out.println(tmp.delete(3,8)); // Thia test

`str.deleteCharAt(a)`删除指定下标的元素

`str.replace(a,b,...)` 用指定字符串替换指定区间

StringBuilder tmp = new StringBuilder("This is a test");
System.out.println(tmp.replace(4,8," have fun! ")); // This have fun! a test

`str.setCharAt()`设定指定位置的字符

StringBuilder tmp = new StringBuilder("This is a test");
tmp.setCharAt(4,'G');
System.out.println(tmp); // ThisGis a test

`str.toString()`创建一个新的String对象，去除尾部多余的空格

@Override
public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}
System.out.println(System.currentTimeMillis());

封装类

针对八种基本数据类型进行定义以及使用的，封装类有八个

基本数据类型	对应的封装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

赋值的两种使用方式

// 四种整型的封装类支持使用常量池技术（-128 ~ 127）
// 通过 = 号赋值的整数，会被存储在常量池中

// 等号直接赋值（常量池）
Integer tmp1 = 1;
// 使用构造方法（堆）
Integer tmp2 = new Integer(1);

Scanner键盘获取

// 导入包
import java.util.Scanner;
// 使用Scanner类创建一个对象
Scanner s = new Scanner(System.in);
// 获取系统输入
// 获取String类型数据
String input = s.nextline();
// 获取整型数据
int input = Integer.parseInt(s.nextLine());
// 获取浮点型数据
float input = Float.parseFloat(s.nextLine());

装箱和拆箱

装箱：将基本类型转换为封装类类型的过程

拆箱：将封装类类型转换为基本类型的过程

int a = 1;
Integer b = 1;
// 自动装箱
Integer tmp = a;
// 手动装箱
Integer tmp = new Interger(a);
// 自动拆箱
int tmp = b;
// 手动拆箱
int tmp = b.intValue();

String

Java

string java

stringbuilder stringbuffer string java

bigdecimal string number java

class java string date

malformed format string java

string format java

java string cause class

铁人三项铁人string java

indexof方法string java

练习题string java

526互联

Java入门6（String和封装类）

使用第三方jar包，完成get/set操作

Lombok，结合特殊的注解，实现setter和getter的自动生成

系统常用类 String

构造方法

String()无参构造

String(byte[] bytes)字节数组（每一个字符所对应的字符集编码）作为参数

String(char[] value)char数组作为参数

String (String original)String字符串作作为参数 ---- 字符数组的引用传递

等号和new定义字符串的区别

equals方法源码分析

API方法

str.charAt()通过下表获取索引处的值

str.concat("...")返回拼接结果，不改变str本身

str.contains("...")判断是否包含子字符串

str.endsWith("...")判断是不是以...结尾

str.equalsIgnoreCase(String tmp)比较时忽略大小写

str.indexof("...")返回指定字符第一次出现时的索引值

str.indexof("...",index)返回从index开始往后指定字符第一次出现时的索引值

str.isEmpty当且仅当length()为0时返回true

str.toCharArray()将字符串还原成char数组

str.split("...")将字符串根据...拆分

str.startsWith(...)判断是否以指定字符串开头

str.substring()字符串截取

str.toLowerCase() / str.toUpperCase()将字符强制大小写

str.trim()去除前面和后面的空格