使用java的API编写代码

使用java的API编写代码

JavaBean

在Java中，有很多class的定义都符合这样的规范：

• 若干private实例字段；
• 通过public方法来读写实例字段。

public class Person {
    private String name;
    private int age;

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

    public int getAge() { return this.age; }
    public void setAge(int age) { this.age = age; }
}

如果读写方法符合以下这种命名规范：

// 读方法:
public Type getXyz()
// 写方法:
public void setXyz(Type value)

那么这种class被称为JavaBean：

上面的字段是xyz，那么读写方法名分别以get和set开头，并且后接大写字母开头的字段名Xyz，因此两个读写方法名分别是getXyz()和setXyz()。

boolean字段比较特殊，它的读方法一般命名为isXyz()：

// 读方法:
public boolean isChild()
// 写方法:
public void setChild(boolean value)

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

• 对应的读方法是String getName()
• 对应的写方法是setName(String)

只有getter的属性称为只读属性（read-only），例如，定义一个age只读属性：

• 对应的读方法是int getAge()
• 无对应的写方法setAge(int)

类似的，只有setter的属性称为只写属性（write-only）。

很明显，只读属性很常见，只写属性不常见。

属性只需要定义getter和setter方法，不一定需要对应的字段。例如，child只读属性定义如下：

public class Person {
    private String name;
    private int age;

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

    public int getAge() { return this.age; }
    public void setAge(int age) { this.age = age; }

    public boolean isChild() {
        return age { "G","a","o" },{ "H","u","a","n"},{ "j","i","e"}};  
         String[][] name2 = {{ "G","a","o" },{ "H","u","a","n"},{ "j","i","e"}};
         System.out.println(Arrays.equals(name1,name2));// false  
         System.out.println(Arrays.deepEquals(name1,name2));// true。
 
什么时候使用 instanceof 运算符，什么时候使用 getClass() 有如下建议：
 
　　①、如果子类能够拥有自己的相等概念，则对称性需求将强制采用 getClass 进行检测。
 
　　②、如果有超类决定相等的概念，那么就可以使用 instanceof 进行检测，这样可以在不同的子类的对象之间进行相等的比较。
 
 
 
hashCode() 方法
 
在Java 中有几种集合类，比如 List,Set，还有 Map，List集合一般是存放的元素是有序可重复的，Set 存放的元素则是无序不可重复的，而 Map 集合存放的是键值对。
 
　　前面我们说过判断一个元素是否相等可以通过 equals 方法，没增加一个元素，那么我们就通过 equals 方法判断集合中的每一个元素是否重复，但是如果集合中有10000个元素了，但我们新加入一个元素时，那就需要进行10000次equals方法的调用，这显然效率很低。
 
　　于是，Java 的集合设计者就采用了 哈希表 来实现。
 
哈希算法也称为散列算法，是将数据依特定算法产生的结果直接指定到一个地址上。这个结果就是由 hashCode 方法产生。这样一来，当集合要添加新的元素时，先调用这个元素的 hashCode 方法，就一下子能定位到它应该放置的物理位置上。
 
　　①、如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；
 
　　②、如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了；
 
　　③、不相同的话，也就是发生了Hash key相同导致冲突的情况，那么就在这个Hash key的地方产生一个链表，将所有产生相同HashCode的对象放到这个单链表上去，串在一起（很少出现）。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。
 
 
　这里有 A,B,C,D四个对象，分别通过 hashCode 方法产生了三个值，注意 A 和 B 对象调用 hashCode 产生的值是相同的，即 A.hashCode() = B.hashCode() = 0x001,发生了哈希冲突，这时候由于最先是插入了 A，在插入的B的时候，我们发现 B 是要插入到 A 所在的位置，而 A 已经插入了，这时候就通过调用 equals 方法判断 A 和 B 是否相同，如果相同就不插入 B，如果不同则将 B 插入到 A 后面的位置。
 
　　一、hashCode 要求
 
　　①、在程序运行时期间，只要对象的（字段的）变化不会影响equals方法的决策结果，那么，在这个期间，无论调用多少次hashCode，都必须返回同一个散列码。
 
　　②、通过equals调用返回true 的2个对象的hashCode一定一样。
 
　　③、通过equasl返回false 的2个对象的散列码不需要不同，也就是他们的hashCode方法的返回值允许出现相同的情况。
 
　　因此我们可以得到如下推论：
 
　　两个对象相等，其 hashCode 一定相同;
 
　　两个对象不相等，其 hashCode 有可能相同;
 
　　hashCode 相同的两个对象，不一定相等;
 
　　hashCode 不相同的两个对象，一定不相等;
 
 　　这四个推论通过上图可以更好的理解。
 
　　二、hashCode 编写指导：
 
　　①、不同对象的hash码应该尽量不同，避免hash冲突，也就是算法获得的元素要尽量均匀分布。
 
　　②、hash 值是一个 int 类型，在Java中占用 4 个字节，也就是 232 次方，要避免溢出。
 
　　在 JDK 的 Integer类，Float 类，String 类等都重写了 hashCode 方法，我们自定义对象也可以参考这些类来写。
 
对于 Map 集合，我们可以选取Java中的基本类型，还有引用类型 String 作为 key，因为它们都按照规范重写了 equals 方法和 hashCode 方法。但是如果你用自定义对象作为 key，那么一定要覆写 equals 方法和 hashCode 方法，不然会有意想不到的错误产生。　　
 
 
 
toString() 方法
 
　　一个字符串和另外一种类型连接的时候，另外一种类型会自动转换成String类型，然后再和字符串连接。基础的数据类型int，float，double转换成字符串比较简单，按照它们的数字转换过来就成了，可以引用类型呢，Person p = new Person();一个字符串加上这个p，你就不知道要怎么把这个p转换成字符串了，因为这个p是一个引用类型。
 
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
 
　getClass().getName()是返回对象的全类名（包含包名）,Integer.toHexString(hashCode()) 是以16进制无符号整数形式返回此哈希码的字符串表示形式。
 
　　打印某个对象时，默认是调用 toString 方法，比如 System.out.println(person),等价于 System.out.println(person.toString())
 
 public class TestToString {
 
     public static void main(String[] args) {
         Dog d = new Dog();
         /**
          * 如果没有重写toString方法，那么输出来的默认的字符串内容是“类名+哈希编码”,
          * 如：dog=cn.galc.test.Dog@150bd4d
         * 这里的d就是一个引用类型，打印的时候，这个引用类型d会自动调用toString()方法将自己转换成字符串然后再与字符串”d:=”相连，
         * 然后一起被打印出来。d为什么可以自动调用toString()方法呢，Dog类里面也没有声明这个toString()方法。
          * 这是因为toString()方法是Object类里面的方法，而所有的类都是从Object类继承下来的，
          * Dog类当然也不例外，所以Dog类继承了Object类里面的toString()方法，
          * 所以Dog类的对象当然可以直接调用toString()方法了。
          * 但是Dog类对继承下来的toString()方法很不满意，
          * 因为使用这个继续下来toString()方法将引用对象转换成字符串输出时输出的是一连串令人看不懂的哈希编码。
          * 为了使打印出来的信息使得正常人都能看得懂，因此要在Dog类里面把这个继承下来的toString()方法重写，
          * 使得调用这个toString()方法将引用对象转换成字符串时打印出来的是一些正常的，能看得懂的信息。
          * 在子类重写从父类继承下来的方法时，从父类把要重写的方法的声明直接copy到子类里面来，
          * 这样在子类里面重写的时候就不会出错了。
          */
         System.out.println("dog="+d);//打印结果：dog=I’m a cool Dog
     }
 }
 
 class Dog{
     /**
      * 在这里重写了Object类里面的toString()方法后，
      * 引用对象自动调用时调用的就是重写后的toString()方法了，
      * 此时打印出来的显示信息就是我们重写toString()方法时要返回的字符串信息了，
      * 不再是那些看不懂的哈希编码了。
      */
     public String toString() {
         return "I’m a cool Dog";
     }
 }
 
　任何一个类都是从Object类继承下来的，因此在任何一个类里面都可以重写这个toString()方法。toString()方法的作用是当一个引用对象和字符串作连接的时候，或者是直接打印这个引用对象的时侯，这个引用对象都会自动调用toString()方法，通过这个方法返回一个表示引用对象自己正常信息的字符串，而这个字符串的内容由我们自己去定义，默认的字符串内容是“类名+哈希编码”。因此我们可以通过在类里面重写toString()方法，把默认的字符串内容改成我们自己想要表达的正常信息的字符串内容。
 
 
 
创建对象的5种方式
 
　　①、通过 new 关键字
 
　　这是最常用的一种方式，通过 new 关键字调用类的有参或无参构造方法来创建对象。比如 Object obj = new Object();
 
　　②、通过 Class 类的 newInstance() 方法
 
　　这种默认是调用类的无参构造方法创建对象。比如 Person p2 = (Person) Class.forName("com.ys.test.Person").newInstance();
 
　　③、通过 Constructor 类的 newInstance 方法
 
　　这和第二种方法类时，都是通过反射来实现。通过 java.lang.relect.Constructor 类的 newInstance() 方法指定某个构造器来创建对象。
 
　　Person p3 = (Person) Person.class.getConstructors()[0].newInstance();
 
　　实际上第二种方法利用 Class 的 newInstance() 方法创建对象，其内部调用还是 Constructor 的 newInstance() 方法。
 
　　④、利用 Clone 方法
 
　　Clone 是 Object 类中的一个方法，通过 对象A.clone() 方法会创建一个内容和对象 A 一模一样的对象 B，clone 克隆，顾名思义就是创建一个一模一样的对象出来。
 
　　Person p4 = (Person) p3.clone();
 
　　⑤、反序列化
 
　　序列化是把堆内存中的 Java 对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他网络节点（在网络上传输）。而反序列化则是把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。
 
 
 
clone()方法
 
clone方法的作用就是复制对象，产生一个新的对象，那么这个新的对象和原对象是什么关系。
 
 Java 中基本类型和引用类型的区别，基本类型也称为值类型，分别是字符类型 char，布尔类型 boolean以及数值类型 byte、short、int、long、float、double，引用类型则包括类、接口、数组、枚举等。
 
　　Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆中，通过栈中的引用指向堆中存放的数据。
 
 
　　上图定义的 a 和 b 都是基本类型，其值是直接存放在栈中的；而 c 和 d 是 String 声明的，这是一个引用类型，引用地址是存放在 栈中，然后指向堆的内存空间。
 
　　下面 d = c；这条语句表示将 c 的引用赋值给 d，那么 c 和 d 将指向同一块堆内存空间。
 
public class Person implements Cloneable{
    public String pname;
    public int page;
    public Address address;
    public Person() {}
    
    public Person(String pname,int page){
        this.pname = pname;
        this.page = page;
        this.address = new Address();
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
}
 
这是一个我们要进行赋值的原始类 Person。下面我们产生一个 Person 对象，并调用其 clone 方法复制一个新的对象。
 
注意：调用对象的 clone 方法，必须要让类实现 Cloneable 接口，并且覆写 clone 方法。
 
       Object 类提供的 clone 是只能实现 浅拷贝的。
 
@Test
public void testShallowClone() throws Exception{
    Person p1 = new Person("zhangsan",21);
    p1.setAddress("湖北省", "武汉市");
    Person p2 = (Person) p1.clone();
    System.out.println("p1:"+p1);
    System.out.println("p1.getPname:"+p1.getPname().hashCode());
    
    System.out.println("p2:"+p2);
    System.out.println("p2.getPname:"+p2.getPname().hashCode());
    
    p1.display("p1");
    p2.display("p2");
    p2.setAddress("湖北省", "荆州市");
    System.out.println("将复制之后的对象地址修改：");
    p1.display("p1");
    p2.display("p2");
}
 
　打印结果为：
 
　　首先看原始类 Person 实现 Cloneable 接口，并且覆写 clone 方法,它还有三个属性，一个引用类型 String定义的 pname，一个基本类型 int定义的 page，还有一个引用类型 Address ，这是一个自定义类，这个类也包含两个属性 pprovices 和 city 。
 
　　接着看测试内容，首先我们创建一个Person 类的对象 p1，其pname 为zhangsan,page为21，地址类 Address 两个属性为 湖北省和武汉市。接着我们调用 clone() 方法复制另一个对象 p2，接着打印这两个对象的内容。
 
　　从第 1 行和第 3 行打印结果:
 
　　p1:com.ys.test.Person@349319f9
 
　　p2:com.ys.test.Person@258e4566
 
　　可以看出这是两个不同的对象。
 
　　从第 5 行和第 6 行打印的对象内容看，原对象 p1 和克隆出来的对象 p2 内容完全相同。
 
　　代码中我们只是更改了克隆对象 p2 的属性 Address 为湖北省荆州市（原对象 p1 是湖北省武汉市） ，但是从第 7 行和第 8 行打印结果来看，原对象 p1 和克隆对象 p2 的 Address 属性都被修改了。
 
　　也就是说对象 Person 的属性 Address，经过 clone 之后，其实只是复制了其引用，他们指向的还是同一块堆内存空间，当修改其中一个对象的属性 Address，另一个也会跟着变化。
 
 
　　浅拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。
 
　    深拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，无论该字段是值类型的还是引用类型，都复制独立的一份。当你修改其中一个对象的任何内容时，都不会影响另一个对象的内容。
 
如何实现深拷贝
 
　　①、让每个引用类型属性内部都重写clone() 方法
 
　　既然引用类型不能实现深拷贝，那么我们将每个引用类型都拆分为基本类型，分别进行浅拷贝。比如上面的例子，Person 类有一个引用类型 Address(其实String 也是引用类型，但是String类型有点特殊，我们在 Address 类内部也重写 clone 方法。如下：
 
 public class Address implements Cloneable{
      private String provices;
      private String city;
      public void setAddress(String provices,String city){
          this.provices = provices;
          this.city = city;
      }
     @Override
     public String toString() {
         return "Address [provices=" + provices + ", city=" + city + "]";
     }
    @Override
     protected Object clone() throws CloneNotSupportedException {
         return super.clone();
     }
     
 }
 
Person.class 的 clone() 方法：
 
     @Override
     protected Object clone() throws CloneNotSupportedException {
         Person p = (Person) super.clone();
         p.address = (Address) address.clone();
         return p;
     }
 
　测试还是和上面一样，我们会发现更改了p2对象的Address属性，p1 对象的 Address 属性并没有变化。
 
　　但是这种做法有个弊端，这里我们Person 类只有一个 Address 引用类型，而 Address 类没有，所以我们只用重写 Address 类的clone 方法，但是如果 Address 类也存在一个引用类型，那么我们也要重写其clone 方法，这样下去，有多少个引用类型，我们就要重写多少次，如果存在很多引用类型，那么代码量显然会很大，所以这种方法不太合适。
 
　　②、利用序列化
 
　　序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。
 
　　注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。
 
//深度拷贝
public Object deepClone() throws Exception{
    // 序列化
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);

    oos.writeObject(this);

    // 反序列化
    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);

    return ois.readObject();
}
 
因为序列化产生的是两个完全独立的对象，所有无论嵌套多少个引用类型，序列化都是能实现深拷贝的。
 
 
 
String常用工具类 
String s=null;//null是未分配堆内存空间    String   a;//分配了一个内存空间,没存入任何对象    String   a="";//分配了一个内存空间,存了一个字符串对象
 
常用方法
 
public class StringTest {
public static void main(String[] args) {
	String str1 = new String();
	System.out.println(str1);
	String str2 = new String("asdf");
	System.out.println(str2);
	char[] value = {'a','b','c','d'};
	String str3 = new String(value);
	System.out.println(str3);
	String str4 = new String(value, 1, 2);
	System.out.println(str4);
	byte[] strb = new byte[]{65,66};
	String str5 = new String(strb);
	System.out.println(str5);
	String str = new String("asdfzxc");
	int strlength = str.length();
	System.out.println(strlength);
	char ch = str.charAt(4);//ch = z
	System.out.println(ch);
	//该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回
	String str6 = str.substring(2);//str2 = "dfzxc"
	System.out.println(str6);
	//该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。
	String str7 = str.substring(2,5);//str3 = "dfz"
	System.out.println(str7);
	
	String str8 = new String("abc");
	String str9 = new String("ABC");
	int a = str8.compareTo(str9);//a>0
	int b = str8.compareToIgnoreCase(str9);//b=0
	boolean c = str8.equals(str9);//c=false
	boolean d = str8.equalsIgnoreCase(str9);//d=true
	
	//相当于String str = "aa"+"bb"+"cc";
	String str10 = "aa".concat("bb").concat("cc");
	System.out.println(str10);
	
	String str11 = "I am a good student";
	//于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。
	int aa = str11.indexOf('a');//a = 2
	int bb = str11.indexOf("good");//b = 7
	//从fromIndex位置向后查找。
	int cc = str11.indexOf("w",2);//c = -1
	//区别在于该方法从字符串的末尾位置向前查找。
	int dd = str11.lastIndexOf("a");//d = 5
	int ee = str11.lastIndexOf("a",3);//e = 2
	
	String str00 = new String("asDF");
	String str111 = str00.toLowerCase();//str1 = "asdf"
	System.out.println(str111);
	String str222 = str00.toUpperCase();//str2 = "ASDF"
	System.out.println(str222);
	
	String str0 = "asdzxcasd";
	String str100 = str0.replace('a','g');//str1 = "gsdzxcgsd"
	String str200 = str0.replace("asd","fgh");//str2 = "fghzxcfgh"
	String str300 = str0.replaceFirst("asd","fgh");//str3 = "fghzxcasd"
	String str400 = str0.replaceAll("asd","fgh");//str4 = "fghzxcfgh"
	
    //另一种是通过正则表达式替换：
    String s = "A,,B;C ,D";
    s.replaceAll("[\\,\\;\\s]+", ","); // "A,B,C,D"

	String str33 = " a sd ";
    //使用trim()方法可以移除字符串首尾空白字符。空白字符包括空格，\t，\r，\n
	String str13 = str33.trim();
	System.out.println(str13);
    //另一个strip()方法也可以移除字符串首尾空白字符。它和trim()不同的是，类似中文的空格字符\u3000也会被移除：
    "\u3000Hello\u3000".strip(); // "Hello"
    " Hello ".stripLeading(); // "Hello "
    " Hello ".stripTrailing(); // " Hello"
    //String还提供了isEmpty()和isBlank()来判断字符串是否为空和空白字符串：
    "".isEmpty(); // true，因为字符串长度为0
    "  ".isEmpty(); // false，因为字符串长度不为0
    "  \n".isBlank(); // true，因为只包含空白字符
    " Hello ".isBlank(); // false，因为包含非空白字符
	
	String strR = "asdfgh";
	boolean aA = strR.startsWith("as");//a = true
	System.out.println(aA);
	boolean bB = strR.endsWith("gh");//b = true
	System.out.println(bB);
	
	String strC = "student";
	System.out.println(strC.contains("stu"));//true
	System.out.println(strC.contains("ok"));//false
	
	String strS = "asd!qwe|zxc#";
	String[] strss = str.split("!|#");
	//str1[0] = "asd";str1[1] = "qwe";str1[2] = "zxc";
	System.out.println(strss.toString()); 
	
    //拼接字符串使用静态方法join()，它用指定的字符串连接字符串数组：
    String[] arr = {"A", "B", "C"};
    String s = String.join("***", arr); // "A***B***C"

	//字符串转换为基本类型
	int n = Integer.parseInt("12");
	System.out.println(n);
	float f = Float.parseFloat("12.34");
	System.out.println(f);
	double D = Double.parseDouble("1.124");
	System.out.println(D);
	
	//基本类型转换为字符串类型
	String s111 = String.valueOf(12);
	System.out.println(s111);
	String s122 = String.valueOf(12.34);
	System.out.println(s122);
	
    //要把字符串转换为其他类型，就需要根据情况。例如，把字符串转换为int类型：
    int n1 = Integer.parseInt("123"); // 123
    int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255

    //要特别注意，Integer有个getInteger(String)方法，它不是将字符串转换为int，而是把该字符串对应的系统变量转换为Integer：
    Integer.getInteger("java.version"); // 版本号，11

	//进制转换
	String binaryString = Long.toBinaryString(7);
	System.out.println(binaryString);

    //转换为char[]
    String和char[]类型可以互相转换，方法是：

    char[] cs = "Hello".toCharArray(); // String -> char[]
    String s = new String(cs); // char[] -> String
    //如果修改了char[]数组，String并不会改变：
    public static void main(String[] args) {
        char[] cs = "Hello".toCharArray();
        String s = new String(cs);
        System.out.println(s);
        cs[0] = 'X';
        System.out.println(s);
    }
}

这是因为通过new String(char[])创建新的String实例时，它并不会直接引用传入的char[]数组，而是会复制一份，所以，修改外部的char[]数组不会影响String实例内部的char[]数组，因为这是两个不同的数组。
从String的不变性设计可以看出，如果传入的对象有可能改变，我们需要复制而不是直接引用。
 
 
在Java中，String是一个引用类型，它本身也是一个class。但是，Java编译器对String有特殊处理，即可以直接用"..."来表示一个字符串：
 
String s1 = "Hello!";
 
实际上字符串在String内部是通过一个char[]数组表示的，因此，按下面的写法也是可以的：
 
String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});
 
因为String太常用了，所以Java提供了"..."这种字符串字面量表示方法。
 
Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。
 
常量池
 
两种声明一个字符串对象的形式有两种：
 
　　①、通过“字面量”的形式直接赋值
 
String str = "hello";
 
　　②、通过 new 关键字调用构造函数创建对象
 
String str = new String("hello");
 
 
 
JVM 的内存分布：
 
 
　　①、程序计数器：也称为 PC 寄存器，保存的是程序当前执行的指令的地址（也可以说保存下一条指令的所在存储单元的地址），当CPU需要执行指令时，需要从程序计数器中得到当前需要执行的指令所在存储单元的地址，然后根据得到的地址获取到指令，在得到指令之后，程序计数器便自动加1或者根据转移指针得到下一条指令的地址，如此循环，直至执行完所有的指令。
 
　　②、虚拟机栈：基本数据类型、对象的引用都存放在这。线程私有。
 
　　③、本地方法栈：虚拟机栈是为执行Java方法服务的，而本地方法栈则是为执行本地方法（Native Method）服务的。在JVM规范中，并没有对本地方法栈的具体实现方法以及数据结构作强制规定，虚拟机可以自由实现它。在HotSopt虚拟机中直接就把本地方法栈和虚拟机栈合二为一。
 
　　④、方法区：存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。注意：在Class文件中除了类的字段、方法、接口等描述信息外，还有一项信息是常量池，用来存储编译期间生成的字面量和符号引用。
 
　　⑤、堆：用来存储对象本身的以及数组（当然，数组引用是存放在Java栈中的）。
 
在 JDK1.7 以后，方法区的常量池被移除放到堆中了，如下：
 
 
　　常量池：Java运行时会维护一个String Pool（String池）， 也叫“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。
 
　　①、字面量创建字符串或者纯字符串（常量）拼接字符串会先在字符串池中找，看是否有相等的对象，没有的话就在字符串池创建该对象；有的话则直接用池中的引用，避免重复创建对象。
 
　　②、new关键字创建时，直接在堆中创建一个新对象，变量所引用的都是这个新对象的地址，但是如果通过new关键字创建的字符串内容在常量池中存在了，那么会由堆在指向常量池的对应字符；但是反过来，如果通过new关键字创建的字符串对象在常量池中没有，那么通过new关键词创建的字符串对象是不会额外在常量池中维护的。
 
　　③、使用包含变量表达式来创建String对象，则不仅会检查维护字符串池，还会在堆区创建这个对象，最后是指向堆内存的对象。
 
 String str1 = "hello";
 String str2 = "hello";
 String str3 = new String("hello");
 System.out.println(str1==str2);//true
 System.out.println(str1==str3);//fasle
 System.out.println(str2==str3);//fasle
 System.out.println(str1.equals(str2));//true
 System.out.println(str1.equals(str3));//true
 System.out.println(str2.equals(str3));//true
 
　　对于上面的情况，首先 String str1 = "hello"，会先到常量池中检查是否有“hello”的存在，发现是没有的，于是在常量池中创建“hello”对象，并将常量池中的引用赋值给str1；第二个字面量 String str2 = "hello"，在常量池中检测到该对象了，直接将引用赋值给str2；第三个是通过new关键字创建的对象，常量池中有了该对象了，不用在常量池中创建，然后在堆中创建该对象后，将堆中对象的引用赋值给str3，再将该对象指向常量池。
 
 
红色的箭头，通过 new 关键字创建的字符串对象，如果常量池中存在了，会将堆中创建的对象指向常量池的引用。
 
 String str1 = "hello";
 String str2 = "helloworld";
 String str3 = str1+"world";//编译器不能确定为常量(会在堆区创建一个String对象)
 String str4 = "hello"+"world";//编译器确定为常量，直接到常量池中引用
 
 System.out.println(str2==str3);//fasle
 System.out.println(str2==str4);//true
 System.out.println(str3==str4);//fasle
 
　　str3 由于含有变量str1，编译器不能确定是常量，会在堆区中创建一个String对象。而str4是两个常量相加，直接引用常量池中的对象即可。
 
 
 
 
String作为参数的传递
 
参数为基本类型时是值传递， 参数为封装类型时是引用传递。
 
public class Test {
    public static void main(String[] args) {
        String str = "ab";
        changeString(str);
        System.out.println("str="+str);
    }
 
    private static void changeString(String str) {
        str = "cd";
    }
}
 
大家猜一下运行结果是什么呢？按照前面的例子，String应该是一个封装类型，它应该是引用传递，是可以改变值得， 运行的结果应该是”cd”。我们实际运行一下看看，
 
str=ab,这如何解释呢？难道String是基本类型？也说不通呀。
 
这就要从java底层的机制讲起了，java的内存模型分为 堆 和 栈 。
 
1.基本类型的变量放在栈里； 2.封装类型中，对象放在堆里，对象的引用放在栈里。
 
java在方法传递参数时，是将变量复制一份，然后传入方法体去执行。 这句话是很难理解的，也是解释这个 问题的精髓。我们先按照这句话解释一下基本类型的传递
 
虚拟机分配给num一个内存地址，并且存了一个值0.
虚拟机复制了一个num，我们叫他num’，num’和num的内存地址不同，但存的值都是0。
虚拟机讲num’传入方法，方法将num’的值改为1.
方法结束，方法外打印num的值，由于num内存中的值没有改变，还是0，所以打印是0.
我们再解释封装类型的传递：
 
虚拟机在堆中开辟了一个Product的内存空间，内存中包含proName和num。
虚拟机在栈中分配给p一个内存地址，这个地址中存的是1中的Product的内存地址。
虚拟机复制了一个p，我们叫他p’,p和p’的内存地址不同，但它们存的值是相同的，都是1中Product的内存地址。
将p’传入方法，方法改变了1中的proName和num。
方法结束，方法外打印p中变量的值，由于p和p’中存的都是1中Product的地址，但是1中Product里的值发生了改变， 所以，方法外打印p的值，是方法执行以后的。我们看到的效果是封装类型的值是改变的。
最后我们再来解释String在传递过程中的步骤：
 
虚拟机在堆中开辟一块内存，并存值”ab”。
虚拟机在栈中分配给str一个内存，内存中存的是1中的地址。
虚拟机复制一份str，我们叫str’，str和str’内存不同，但存的值都是1的地址。
将str’传入方法体
方法体在堆中开辟一块内存，并存值”cd”
方法体将str’的值改变，存入5的内存地址
方法结束，方法外打印str，由于str存的是1的地址，所有打印结果是”ab”
这样我们理解了java在方法传参的整个过程。其实还是上面那句比较重要的话。 java在方法传递参数时，是将变量复制一份，然后传入方法体去执行。
 
三句话总结一下：
 
1.对象就是传引用
 
2.原始类型就是传值
 
3.String，Integer, Double等immutable类型因为没有提供自身修改的函数，每次操作都是新生成一个对象，所以要特殊对待。可以认为是传值。
 
Integer 和 String 一样。保存value的类变量是Final属性，无法被修改，只能被重新赋值／生成新的对象。 当Integer 做为方法参数传递进方法内时，对其的赋值都会导致 原Integer 的引用被 指向了方法内的栈地址，失去了对原类变量地址的指向。对赋值后的Integer对象做得任何操作，都不会影响原来对象。
 
 
 
String的不可变性
 
不可变对象的创建一般满足5个原则：
 
1. 类添加final修饰符，保证类不被继承。 如果类可以被继承会破坏类的不可变性机制，只要继承类覆盖父类的方法并且继承类可以改变成员变量值，那么一旦子类以父类的形式出现时，不能保证当前类是否可变。
 
2. 保证所有成员变量必须私有，并且加上final修饰 通过这种方式保证成员变量不可改变。但只做到这一步还不够，因为如果是对象成员变量有可能再外部改变其值。所以第4点弥补这个不足。
 
3. 不提供改变成员变量的方法，包括setter 避免通过其他接口改变成员变量的值，破坏不可变特性。
 
4.通过构造器初始化所有成员，进行深拷贝(deep copy)
 
如果构造器传入的对象直接赋值给成员变量，还是可以通过对传入对象的修改进而导致改变内部变量的值。例如：
 
public final class ImmutableDemo {  
    private final int[] myArray;  
    public ImmutableDemo(int[] array) {  
        this.myArray = array; // wrong  
    }  
}
 
这种方式不能保证不可变性，myArray和array指向同一块内存地址，用户可以在ImmutableDemo之外通过修改array对象的值来改变myArray内部的值。 为了保证内部的值不被修改，可以采用深度copy来创建一个新内存保存传入的值。正确做法：
 
public final class MyImmutableDemo {  
    private final int[] myArray;  
    public MyImmutableDemo(int[] array) {  
        this.myArray = array.clone();   
    }   
}
 
5. 在getter方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝 这种做法也是防止对象外泄，防止通过getter获得内部可变成员对象后对成员变量直接操作，导致成员变量发生改变。
 
public final class String
    implements java.io.Serializable, Comparable, CharSequence
{
    /** The value is used for character storage. */
    private final char value[];
    /** The offset is the first index of the storage that is used. */
    private final int offset;
    /** The count is the number of characters in the String. */
    private final int count;
    /** Cache the hash code for the string */
    private int hash; // Default to 0
    ....
    public String(char value[]) {
         this.value = Arrays.copyOf(value, value.length); // deep copy操作
     }
    ...
     public char[] toCharArray() {
     // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }
    ...
}
 
可以观察到以下设计细节:
 
String类被final修饰，不可继承
string内部所有成员都设置为私有变量
不存在value的setter
并将value和offset设置为final。
当传入可变数组value[]时，进行copy而不是直接将value[]复制给内部变量.
获取value时不是直接返回对象引用，而是返回对象的copy.
这都符合上面总结的不变类型的特性，也保证了String类型是不可变的类。
 
 
 
String对象的不可变性的优缺点
 
1.字符串常量池的需要. 字符串常量池可以将一些字符常量放在常量池中重复使用，避免每次都重新创建相同的对象、节省存储空间。但如果字符串是可变的，此时相同内容的String还指向常量池的同一个内存空间，当某个变量改变了该内存的值时，其他遍历的值也会发生改变。所以不符合常量池设计的初衷。
 
2. 线程安全考虑。 同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。
 
3. 类加载器要用到字符串，不可变性提供了安全性，以便正确的类被加载。譬如你想加载java.sql.Connection类，而这个值被改成了myhacked.Connection，那么会对你的数据库造成不可知的破坏。
 
4. 支持hash映射和缓存。 因为字符串是不可变的，所以在它创建的时候hashcode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。
 
缺点：
 
String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。
 
Java为了避免在一个系统中产生大量的String对象，引入了字符串常量池。
 
创建一个字符串时，首先会检查池中是否有值相同的字符串对象，如果有就直接返回引用，不会创建字符串对象；如果没有则新建字符串对象，返回对象引用，并且将新创建的对象放入池中。但是，通过new方法创建的String对象是不检查字符串常量池的，而是直接在堆中创建新对象，也不会把对象放入池中。上述原则只适用于直接给String对象引用赋值的情况。
 
String str1 = new String("a"); //不检查字符串常量池的
 
String str2 = "bb"; //检查字符串常量池的
 
String还提供了intern()方法。调用该方法时，如果字符串常量池中包括了一个等于此String对象的字符串（由equals方法确定），则返回池中的字符串的引用。否则，将此String对象添加到池中，并且返回此池中对象的引用。
 
在JDK6中，不推荐大量使用intern方法，因为这个版本字符串缓存在永久代中，这个空间是有限了，除了FullGC之外不会被清楚，所以大量的缓存在这容易OutOfMemoryError。
 
之后的版本把字符串放入了堆中，避免了永久代被挤满。
 
虽然String对象将value设置为final,并且还通过各种机制保证其成员变量不可改变。但是还是可以通过反射机制的手段改变其值。例如：
 
    //创建字符串"Hello World"， 并赋给引用s
    String s = "Hello World"; 
    System.out.println("s = " + s); //Hello World

    //获取String类中的value字段
    Field valueFieldOfString = String.class.getDeclaredField("value");
    //改变value属性的访问权限
    valueFieldOfString.setAccessible(true);

    //获取s对象上的value属性的值
    char[] value = (char[]) valueFieldOfString.get(s);
    //改变value所引用的数组中的第5个字符
    value[5] = '_';
    System.out.println("s = " + s);  //Hello_World
 
打印结果为：
 
s = Hello World s = Hello_World
 
发现String的值已经发生了改变。也就是说，通过反射是可以修改所谓的“不可变”对象的
 
 
 
String,StringBuffer与StringBuilder的区别
 
String：对String类型的对象操作，等同于重新生成一个新对象，然后讲引用指向它；
 
StringBuffer：对StringBuffer类型的对象操作，操作的始终是同一个对象；
 
    public static void main(String[] args) {
        String str="123";
        str+="abc";
        System.out.println(str);
    }
 
 
public class TestStringBuffer {
 
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer("123");
        sb.append("abc");
        System.out.println(sb.toString());
    }
}
 
 
虽然可以直接拼接字符串，但是，在循环中，每次循环都会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分字符串都是临时对象，不但浪费内存，还会影响GC效率。
 
为了能高效拼接字符串，Java标准库提供了StringBuilder，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象：
 
StringBuffer里始终是一个对象；
 
总结下：假如定义的字符串内容基本不变或者很少变化，用String效率高；假如定义的字符串内容经常变动，要用StringBuffer；
 
      public static void main(String[] args) {
          //构造实例化
          StringBuffer strbu = new StringBuffer("hello world\t");
          char[] a = {'l','o','y','o','u'};
          //调用方法
          
          System.out.println(1+"\t"+strbu.append(true));            //append(boolean b);
         System.out.println(2+"\t"+strbu.append('a'));            //append(char b);
         System.out.println(3+"\t"+strbu.append(a));                //append(char[] b);
         System.out.println(4+"\t"+strbu.capacity());            //capacity();
         System.out.println(5+"\t"+strbu.charAt(10));            //charAt(int index);
         System.out.println(6+"\t"+strbu.delete(3, 9));            //delete(int start, int end);
         System.out.println(7+"\t"+strbu.insert(5, false));        //insert(int offset, boolean b);
         System.out.println(8+"\t"+strbu.substring(7));            //substring(int start)
         System.out.println(9+"\t"+strbu.reverse() );            //reverse()          
     }
 
运行结果
 
 
StringBuilder还可以进行链式操作：
 
public class Main {
    public static void main(String[] args) {
        var sb = new StringBuilder(1024);
        sb.append("Mr ")
          .append("Bob")
          .append("!")
          .insert(0, "Hello, ");
        System.out.println(sb.toString());
    }
}
 
如果我们查看StringBuilder的源码，可以发现，进行链式操作的关键是，定义的append()方法会返回this，这样，就可以不断调用自身的其他方法。
 
仿照StringBuilder，我们也可以设计支持链式操作的类。例如，一个可以不断增加的计数器：
 
public class Main {
    public static void main(String[] args) {
        Adder adder = new Adder();
        adder.add(3)
             .add(5)
             .inc()
             .add(10);
        System.out.println(adder.value());
    }
}

class Adder {
    private int sum = 0;

    public Adder add(int n) {
        sum += n;
        return this;
    }

    public Adder inc() {
        sum ++;
        return this;
    }

    public int value() {
        return sum;
    }
}
 
注意：对于普通的字符串+操作，并不需要我们将其改写为StringBuilder，因为Java编译器在编译时就自动把多个连续的+操作编码为StringConcatFactory的操作。在运行期，StringConcatFactory会自动把字符串连接操作优化为数组复制或者StringBuilder操作。
 
你可能还听说过StringBuffer，这是Java早期的一个StringBuilder的线程安全版本，它通过同步来保证多个线程操作StringBuffer也是安全的，但是同步会带来执行速度的下降。
 
StringBuilder和StringBuffer接口完全相同，现在完全没有必要使用StringBuffer。
 
 
 
StringJoiner
 
要高效拼接字符串，应该使用StringBuilder。
 
很多时候，我们拼接的字符串像这样：
 
// Hello Bob, Alice, Grace!
 
public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sb = new StringBuilder();
        sb.append("Hello ");
        for (String name : names) {
            sb.append(name).append(", ");
        }
        // 注意去掉最后的", ":
        sb.delete(sb.length() - 2, sb.length());
        sb.append("!");
        System.out.println(sb.toString());
    }
}
 
类似用分隔符拼接数组的需求很常见，所以Java标准库还提供了一个StringJoiner来干这个事：
 
import java.util.StringJoiner;
public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ");
        for (String name : names) {
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}
 
慢着！用StringJoiner的结果少了前面的"Hello "和结尾的"!"！遇到这种情况，需要给StringJoiner指定“开头”和“结尾”：
 
public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ", "Hello ", "!");
        for (String name : names) {
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}
 
那么StringJoiner内部是如何拼接字符串的呢？如果查看源码，可以发现，StringJoiner内部实际上就是使用了StringBuilder，所以拼接效率和StringBuilder几乎是一模一样的。
 
String.join()
 
String还提供了一个静态方法join()，这个方法在内部使用了StringJoiner来拼接字符串，在不需要指定“开头”和“结尾”的时候，用String.join()更方便：
 
String[] names = {"Bob", "Alice", "Grace"};
var s = String.join(", ", names);
 
 
 
String也是Immutable类的典型实现，拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。
 
 
初始String值为“hello”，然后在这个字符串后面加上新的字符串“world”，这个过程是需要重新在栈堆内存中开辟内存空间的，最终得到了“hello world”字符串也相应的需要开辟内存空间，这样短短的两个字符串，却需要开辟三次内存空间，不得不说这是对内存空间的极大浪费。为了应对经常性的字符串相关的操作，谷歌引入了两个新的类——StringBuffer类和StringBuild类来对此种变化字符串进行处理。
 
StringBuffer就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类，提供append和add方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列，把所有修改数据的方法都加上了synchronized。但是保证了线程安全是需要性能的代价的，和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
 
在很多情况下我们的字符串拼接操作不需要线程安全，这时候StringBuilder登场了，StringBuilder是JDK1.5发布的，它和StringBuffer本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。
 
StringBuffer 和 StringBuilder 二者都继承了 AbstractStringBuilder ，底层都是利用可修改的char数组(JDK 9 以后是 byte数组)。
 
所以如果我们有大量的字符串拼接，如果能预知大小的话最好在new StringBuffer 或者StringBuilder 的时候设置好capacity，避免多次扩容的开销。扩容要抛弃原有数组，还要进行数组拷贝创建新的数组。
 
我们平日开发通常情况下少量的字符串拼接其实没太必要担心，例如
 
String str = "aa"+"bb"+"cc";
 
像这种没有变量的字符串，编译阶段就直接合成"aabbcc"了，然后看字符串常量池（下面会说到常量池）里有没有，有也直接引用，没有就在常量池中生成，返回引用。
 
如果是带变量的，其实影响也不大，JVM会帮我们优化了。
 
1、在字符串不经常发生变化的业务场景优先使用String(代码更清晰简洁)。如常量的声明，少量的字符串操作(拼接，删除等)。
 
2、在单线程情况下，如有大量的字符串操作情况，应该使用StringBuilder来操作字符串。不能使用String"+"来拼接而是使用，避免产生大量无用的中间对象，耗费空间且执行效率低下（新建对象、回收对象花费大量时间）。如JSON的封装等。
 
3、在多线程情况下，如有大量的字符串操作情况，应该使用StringBuffer。如HTTP参数解析和封装等。
 
 
 
字符编码
 
在早期的计算机系统中，为了给字符编码，美国国家标准学会（American National Standard Institute：ANSI）制定了一套英文字母、数字和常用符号的编码，它占用两个字节，编码范围从0到127，最高位始终为0，称为ASCII编码。例如，字符'A'的编码是0x41，字符'1'的编码是0x31。
 
如果要把汉字也纳入计算机编码，很显然一个字节是不够的。GB2132标准使用两个字节表示一个汉字，其中第一个字节的最高位始终为1，以便和ASCII编码区分开。例如，汉字'中'的GB2312编码是0xd6d0。
 
类似的，日文有Shift_JIS编码，韩文有EUC-KR编码，这些编码因为标准不统一，同时使用，就会产生冲突。
 
为了统一全球所有语言的编码，全球统一码联盟发布了Unicode编码，它把世界上主要语言都纳入同一个编码，这样，中文、日文、韩文和其他语言就不会冲突。
 
字符编码的发展历程
 
　　①、ASCII 码
 
　　因为计算机只认识数字，所以我们在计算机里面的一切数据都是以数字来表示，因为英文字符有限，所以规定使用的字节的最高位是 0，每一个字节都是以 0-127 之间的数字来表示。比如 A 对应 65，a 对应 97。这便是 美国标准信息交换码，ASCII
 
String str = new String("Aa");
byte[] strASCII = str.getBytes("ASCII");
System.out.println(Arrays.toString(strASCII));//[65, 97]
 
　　②、GB2312 码
 
　　随着计算机在全球的普及，很多国家和地区都把自己的字符引入了计算机，比如汉字。此时发现一个字节能表示的数字范围太小，不能包含所有的中文汉字。那么就规定使用两个字节来表示一个汉字。
 
　　规定：原有的 ASCII 字符的编码保持不变，仍然使用一个字节表示，为了区别一个中文字符与两个 ASCII 码字符相区别。中文字符的每个字节最高位规定为 1（即中文的二进制是负数），这便是 GB2312 编码
 
String str = new String("Aa帅锅");
byte[] strASCII = str.getBytes("GB2312");
System.out.println(Arrays.toString(strASCII));//[65, 97, -53, -89, -71, -8]
 
　　③、GBK
 
　　由于中国汉字太多，在 GB2312 的基础上增加了更多的中文字符，这种编码是 GBK
 
问题：如果只是在中国，那么大家都认识汉字，但是如果是别的国家，而该国家的码表中是没有收录汉字的。那么计算机在显示的时候就为乱码或是别的字符
 
解决办法：为了解决各个国家因为本地化字符编码带来的影响，就把全世界所有的字符统一进行编码---Unicode 编码
 
　　此时某一个字符在全世界任何地方显示都是固定的，比如汉字 哥，在任何地方都是以十六进制 54E5 来表示。
 
　   Unicode 的字符编码都占有两个字节
 
　　④、UTF-8
 
　　是一种针对 Unicode 的可变长度字符编码，又称为 万国码，是 Unicode 的实现方式之一。编码中的第一个字节仍与 ASCII 兼容，这使得原来处理 ASCII 字符的软件无须或只需做少部分修改，即可继续使用。因此，它逐渐成为电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持 UTF-8 编码
 
String str = new String("Aa帅锅");
byte[] strASCII = str.getBytes("UTF-8");
System.out.println(Arrays.toString(strASCII));//[65, 97, -27, -72, -123, -23, -108, -123]
 
存储字母、数字：无论什么字符集都占有 1 个字节
 
存储汉字：GBK 家族占有 2 个字节。UTF-8 占有 3 个字节
 
　　　　   不能使用单字节的字符集（ASCII/ISO-8859-1）来存储中文
 
Unicode编码需要两个或者更多字节表示，我们可以比较中英文字符在ASCII、GB2312和Unicode的编码：
 
英文字符'A'的ASCII编码和Unicode编码：
 
         ┌────┐
ASCII:   │ 41 │
         └────┘
         ┌────┬────┐
Unicode: │ 00 │ 41 │
         └────┴────┘
 
英文字符的Unicode编码就是简单地在前面添加一个00字节。
 
中文字符'中'的GB2312编码和Unicode编码：
 
         ┌────┬────┐
GB2312:  │ d6 │ d0 │
         └────┴────┘
         ┌────┬────┐
Unicode: │ 4e │ 2d │
         └────┴────┘
 
那我们经常使用的UTF-8又是什么编码呢？因为英文字符的Unicode编码高字节总是00，包含大量英文的文本会浪费空间，所以，出现了UTF-8编码，它是一种变长编码，用来把固定长度的Unicode编码变成1～4字节的变长编码。通过UTF-8编码，英文字符'A'的UTF-8编码变为0x41，正好和ASCII码一致，而中文'中'的UTF-8编码为3字节0xe4b8ad。
 
UTF-8编码的另一个好处是容错能力强。如果传输过程中某些字符出错，不会影响后续字符，因为UTF-8编码依靠高字节位来确定一个字符究竟是几个字节，它经常用来作为传输编码。
 
在Java中，char类型实际上就是两个字节的Unicode编码。如果我们要手动把字符串转换成其他编码，可以这样做：
 
byte[] b1 = "Hello".getBytes(); // 按ISO8859-1编码转换，不推荐
byte[] b2 = "Hello".getBytes("UTF-8"); // 按UTF-8编码转换
byte[] b2 = "Hello".getBytes("GBK"); // 按GBK编码转换
byte[] b3 = "Hello".getBytes(StandardCharsets.UTF_8); // 按UTF-8编码转换
 
注意：转换编码后，就不再是char类型，而是byte类型表示的数组。
 
如果要把已知编码的byte[]转换为String，可以这样做：
 
byte[] b = ...
String s1 = new String(b, "GBK"); // 按GBK转换
String s2 = new String(b, StandardCharsets.UTF_8); // 按UTF-8转换
 
始终牢记：Java的String和char在内存中总是以Unicode编码表示。
 
对于不同版本的JDK，String类在内存中有不同的优化方式。具体来说，早期JDK版本的String总是以char[]存储，它的定义如下：
 
public final class String {
    private final char[] value;
    private final int offset;
    private final int count;
}
 
而较新的JDK版本的String则以byte[]存储：如果String仅包含ASCII字符，则每个byte存储一个字符，否则，每两个byte存储一个字符，这样做的目的是为了节省内存，因为大量的长度较短的String通常仅包含ASCII字符：
 
public final class String {
    private final byte[] value;
    private final byte coder; // 0 = LATIN1, 1 = UTF16
 
对于使用者来说，String内部的优化不影响任何已有代码，因为它的public方法签名是不变的。
 
小结
 
 
Java字符串String是不可变对象；
 
 
字符串操作不改变原字符串内容，而是返回新字符串；
 
 
Java使用Unicode编码表示String和char；
 
 
转换编码就是将String和byte[]转换，需要指定编码；
 
 
转换为byte[]时，始终优先考虑UTF-8编码。
 
字符的编码和解码
 
　　信息在计算机网络中传输是以字节的形式。那么如何变为字节？这就是编码的过程。那么计算机接收了这个编码，如何让使用者认识呢？那必须要将字节转换为人所识别的字符串形式，这就是解码的过程。
 
　　编码：将字符串转换为 byte 数组
 
　　解码：把 byte 数组转换为 字符串
 
注意：①、编码格式和解码格式必须一致，否则乱码
 
String str = new String("Aa帅锅");
        //编码操作
        byte[] strByte = str.getBytes("GBK");
        System.out.println(Arrays.toString(strByte));//[65, 97, -53, -89, -71, -8]
         
        //解码操作 
        //注意编码的字符集和解码的字符集格式必须一致（是其扩展字符集也可以），否则会乱码
        //第一种：编码格式为 GBK，解码格式为 ISO-8859-1  那么就会乱码
        String str2 = new String(strByte,"ISO-8859-1");
        System.out.println(str2); //Aa?§??
         
        //第二种：编码和解码格式一致
        String str3 = new String(strByte,"GBK");
        System.out.println(str3); //Aa帅锅
 
　②、有时候编码为和解码格式一致了，但是还是乱码，这是因为在数据在传输过程中经过服务器的处理，而这个服务器可能是外国人编写的，那么就会将数据转换为 别的字符格式，那么你如果还是直接转为自己想要的格式是会乱码的。
 
　　解决办法：先获取经过服务器之后的数据还原编码，然后在进行解码
 
String str = new String("Aa帅锅");
        //编码操作
        byte[] strByte = str.getBytes("UTF-8");
        System.out.println(Arrays.toString(strByte));//[65, 97, -27, -72, -123, -23, -108, -123]
         
         
        //中间经过了服务器的传输，编码格式转成了 ISO-8859-1
        String str2 = new String(strByte,"ISO-8859-1");
         
        //解码操作  ,此时如果直接进行解码，那么会乱码
        String str3 = new String(str2.getBytes(),"UTF-8");
        System.out.println(str3); //Aa???????
         
        //对于上面的乱码，我们必须先还原服务器之前的编码格式，然后在进行解码。那么就不会乱码
        byte[] strByte2 = str2.getBytes("ISO-8859-1");
        String str4 = new String(strByte2,"UTF-8");
        System.out.println(str4); //Aa帅锅
 
 
 
Integer常用工具类 
　　①、自动装箱
 
　　一般我们创建一个类的时候是通过new关键字，比如：
 
Object obj = new Object();
 
　但是对于 Integer 类，我们却可以这样：
 
Integer a = 128;
 
　　为什么可以这样，通过反编译工具，我们可以看到，生成的class文件是：
 
Integer a = Integer.valueOf(128);
 
　　这就是基本数据类型的自动装箱，128是基本数据类型，然后被解析成Integer类。
 
　　注意：自动装箱规范要求 byte