菜鸡的Java笔记 第十三 String 类的两种实例化方法

String 类的两种实例化方法
 String 类的两种实例化方式的区别
 String 类对象的比较
 Stirng 类对象的使用分析

/*    1.String 类的两种实例化方式的区别
        String 并不是一个基本数据类型，它本身属于一个类（首字母大写）
        但是这个类在设计的过程之中加入了一些java 自己的特殊支持，所以对于这个类的对象实例化方式就有两种形式
        
        直接赋值：String 对象 = “内容”：
        构造方法：public Stirng(Stirng s);

class Book{
    private String title;
    public Book(String t){
        title = t;
    }
}

Book 类的构造：public Book(String t);
String 类的构造：public String(String s);
        
        范例：直接赋值

public class stringClass{
    public static void main(Stirng args[]){
        Stirng str = "Hello";
        str = str+ "World";
        System.out.println(str);
    }
}

范例：构造方法

public class stringClass{
    public static void main(Stirng args[]){
        Stirng str = new String ("Hello");
        str = str+ "World";
        System.out.println(str);
    }
}

至少现在通过执行结果来讲,Stirng 类的两种实例化方式都是可用的
*/

/*    2. String 的相等比较
        如果说现在有两个 int 型的变量，那么要进行相等比较的判断，则直接使用“==”即可
        范例：两个int比较

public class stringClass{
    public static void main(String args){
        int x = 10;
        int y = 10;
        System.out.println(x==y);

    }
}

发现两个利用直接赋值实现的程序，那么使用“==”的时候可以正常的进行相等判断
        但是如果现在将同样的操作形式用在String 上呢？

public class stringClass{
    public static void main(String args){
        String x = "hi";
        String y = new String("hi");
        String z = y;  // 引用传递
        System.out.println(x==y);  // false
        System.out.println(y==z);  // true
        System.out.println(x==z);  // false

    }
}

通过现在执行可以发现一个非常严重的问题，此时字符串的内容实际上都是相同的，而在使用 “==”比较之后发现有的比较结果是false，那么为什么呢？
        发现在程序中如果使用“==”比较的只是两个对象（任意的引用类型）堆内存地址数值，属于数值内容的比较并不是堆内存中保存内容的比较，那么要想进行String 对象内容的比较则可以利用String 类中提供的一个方法完成
            字符串比较（暂时将此方法进行修改）：public boolcan equals(String str)
            范例：利用equals（）实现字符串内容的比较

public class stringClass{
    public static void main(String args){
        String x = "hi";
        String y = new String("hi");
        String z = y;  // 引用传递
        System.out.println(x.equals(y));  // true
        System.out.println(y.equals(z));  // true
        System.out.println(x.equals(z));  // true
　　}
}

由于内容是可控的因素，而地址是不可控的因素，所以在日后的开发之中，只要是字符串的比较都使用equals()方法完成，绝对不可能出现“==”
        面试题：请解释在String比较中“==”与“equals”的区别？
            “==”：是java本身提供的关系运算符，可以进行数值比较
            “equals”：是String类自己定义的方法，用于进行字符串内容的比较
*/

/*    3.String 匿名对象
        任何的编程语言都不会提供有字符串这一数据类型，字符串的描述在很多语言之中都使用字符数组表示，而在JAVA的设计之初为了解决这样的问题，专门提供了一个String类来进行描述。
        但是随着发展，为了能够让程序变得更加的易于开发，所以在java里面也提供了双引号声明的数据，而这些数据，在java中并不是普通的变量，而是属于String类的匿名对象
        范例：验证匿名对象

public class stringClass{
    public static void main(String args[]){
        String str = "hello";
        System.out.println(str.equals("hello"));
    }
}  // 通过

public class stringClass{  // 换过来
    public static void main(String args[]){
        String str = "hello";
        System.out.println("hello".equals(str));  // 这里的 “hello” 就是匿名对象
    }
}

现在发现，此时已经可以通过字符串调用 equals()方法，那么就证明一点，字符串的确是String类的匿名对象那么之前的“String 字符串对象= “字符串”：”，本质就是为一个字符串的匿名对象起了一个名字
            
            经验：
                如果现在假设你的开发有这样一种需求;用户输入一些指令，而后根据输入指令判断要执行的操作，那么此时就存在有两种做法：
            一;

public class stringClass{
    public static void main(String args[]){
        String input = "run"; // 假设为输入的数据
        if(input.equals("run")){
            System.out.println("********开始**********");
            System.exit(1); // 程序结束
        }
    }
}  //  通过

既然input 的内容是用户输人的，那么就有可能不输入如果不输人内容就有可能为null 则null调用equals（）方法就有可能出现错误，很明显如果要想解决这样的问题，最初的方案一定是追加判断
            如果觉得以上的 null的判断多余，那么就可以进一步利用 equals() 方法的功能，，因为匿名对象永远不可能为null。所以可以采用颠倒的模式
                
            二：

public class stringClass{
    public static void main(String args[]){
        String input = "null"; // 假设为输入的数据
        if("run".equals(input)){
            System.out.println("********开始**********");
        }
    }
}

首先字符串的匿名对象永远不可能是null，并且在equals（）方法里面支持有null的验证，所以如果发现有比较的内容为null返回的就是false
                字符串常量= String类的匿名对象
                比较字符串内容是否相同时，将常量写在前面
*/

/*    String 类两种实例化对象的区别（核心）
        声明：在开发之中如果发现，有多种方式可以实现同一结果，那么就有可能出现面试题
        此时对于String 类的 实例化方式出现有两种，那么这两种方式到底该使用那一种，以及每种方式的区别是什么
        
        分析一：String类对象直接实例化的形式
            直接赋值是现在为止看见最多的

public class stringClass{
    public static void main(String args[]){
        String str = "hello";
        System.out.println(str);
    }
}

开辟一块堆内存空间，并且一个栈内存将直接指向该堆内存空间
            
        范例：继续观察直接赋值

public class stringClass{
    public static void main(String args){
        String x = ("holle");
        String y = ("holle");
        String z = ("nihao");
        System.out.println(x==y);  // true
        System.out.println(y==z);  // false
        System.out.println(x==z);  // false
    }
}

解释：关于对象池的概念（Object Pool）
                在java设计的过程之中为了方便用户的代码编写开发，针对与几个特殊的类使用了共享设计的思路，其中String就是属于其中的一员
                这种设计思路是java 自己的支持，而且只针对直接赋值的方式
                在使用直接赋值实例化String类对象的操作之中，字符串的内容定义之后实际会自动将其保存在一个对象池之中，
                而后如果现在有其他的字符串对象也采用了直接赋值的形式，并且内容与之前的字符串完全相同，
                那么不会开辟新的堆内存空间，而是通过对象池找到已有的堆内存空间地址，直接引用即可，所以就会造成若干个字符串直接赋值之后，
                当内容相同时地址是完全相同的，所以“==”的结果也是相同的，这样的设计就是共享设计模式
    
        分析二：利用构造方法实例化对象
            以下面的程序为分析依据：

public class stringClass{
    public static void main(String args[]){
        String str = new String("hello");
        System.out.println(str);
    }
}

如果采用了构造方法进行String类对象的实例化操作，那么最终将产生两块堆内存空间其中有一块是垃圾空间
            如果现在使用了构造方法进行String类的对象实例化还会牵扯到入池的问题
            范例：没有入池

public class stringClass{
    public static void main(String args[]){
        String stra = new String("hello"); // 构造方法
        String strb = "hello";  //  直接赋值
        System.out.println(stra == strb);  // false
    }
}

现在的代码之中，发现如果使用了构造方法进行String 类对象实例化，那么所产生的对象将不会保存在对象池之中，也就是说此对象无法重用
                如果现在用户需要让这个对象入池，则只能通过手工的方式完成
                    手工入池：public String intern()

public class stringClass{
    public static void main(String args[]){
        String stra = new String("hello").intern(); // 构造方法  手工入池
        String strb = "hello";  //  直接赋值
        System.out.println(stra == strb);  // true
    }
}

面试题：请解释String类两种对象的实例化区别？
                直接赋值（String 对象名称 = “字符串”：）;只会开辟一块堆内存空间，并且对象可以自动入池以供其他对象重复使用
                构造方法（String 对象名称 = new String（“字符串”））：会开辟两块堆内存空间，并且其中有一块堆内存将成为垃圾，同时产生的实例化对象不会自动入池，需要利用intern（）方法手工入池

*/

/*    字符串一旦声明则不可改变
        之前学习过一个“+”，利用这一概念可以实现字符串改变
            范例：分析代码

public class stringClass{
    public static void main(String args[]){
        String str = "Hello";  //  直接赋值
        str += "World";
        str=str+"!!!";
        System.out.println(str); // Hello World !!!
    }
}

可以发现整个的操作流程之中，都是String类对象的引用发生着改变，而字符串的内容没有改变，这样的操作会形成垃圾。
            正因为如此，所以在实际开发中，以下的操作禁止出现

public class stringClass{
    public static void main(String args[]){
        String str = "";
        for(int x = 0;x<1000;x++){
            str +=x;
        }
        System.out.println(str);
    }
} 

这种代码会“重新改变引用”1000次，并且会大量产生垃圾，也就是说String不适合频繁修改
*/
/*    总结
        1.String 开发中都使用直接赋值，并且不要频繁修改
        2.字符串内容比较时使用equals()方法
*/