‘济’宁景点:String「的那」些事

2020-03-18 3 views 0

扫一扫用手机浏览

目录[

  • String‘《的特点》’?
  • String“<的构造“方法”>”?
  • String“的常”<用>“方法”?

String‘《的特点》’?

《通过》查看String({类}的<源码>我们得知):String {类}被[final关键字修饰,{这即是 说[明}String{类}‘《的特点》’就是:〖字符串对『象』一旦被〗初始“化就不会被改变”。(注意):<此处是字符串对『象』《「“「〖〖而〗〗」”」》不>【是字】符串引<用>。也即是说:


String s = "abc";   // s{引<用>变《量》指向了} 值[为"abc"『<的对『象』>』

s = "cba";    // s(引<用>变《量》又指)向了 值[为"cba"『<的对『象』>』,(但是上面 值[为)"abc"『<的对『象』>』的 值[并未改变

(那么)String {类}被[final‘修饰有什么好处【呢】?第一【个】好处是【安全】, 因为[final《保证不管怎样操作》,(它的 值[【都是】不变的);第二【个】好处就是【高效】, 因为[只有String{类}是不可变{类}时,我们才能实现字符串常「《量》池」。试想如果String“{类}”是可变{类},『当多【个】字符串引<用>变《量》』‘指’向同一【个】字符串对『象』时,「字符串对『象』改」变后就会<引起>多【个】字符串引<用>变〖《量》内容的改〗变,『这显然不符合我』们的预期。「我们可以」通过下面的代码来验证字符串常「《量》池」「的存(在)」:


CLass Demo {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";

        Demo d1 = new Demo();
        Demo d2 = new Demo();
        System.out.println(s1 == s2);     // 1
        System.out.println(d1 == d2);
    }
}

『我们知道』:「如果是两【个】」引<用>变《量》使<用>"=="进行比较,(那么)比较的是两【个】对『象』 的地址 值[[,1(处的代码输出结果为)"true", 说[明s1引<用>变《量》『和』s2引<用>变《量》指向的是同一【个】对『象』,也就验证了字符串常「《量》池」「的存(在)」。字符串常「《量》池」其实就是“字符‘串的’一【个】”缓冲区,《「“「〖〖而〗〗」”」》"(缓存)"‘可以’提高系统“性能”,(那么)即是说字符串常「《量》池」的使<用>‘可以’提高系统“性能”。常「《量》池」‘《的特点》’就(在)于:『如果池中没有则创建』,如果池中有就直接使<用>《池中》的。

String内部实际存储结构为char{数} 组[。<《下面为》>jdk1.8『版本的』String<源码>:


public final class String
        iMPlements java.io.Serializable, Comparable<String>, CharSequence {

    // <用>于存储字符‘串的’ 值[
    private final char value[];

    // <用>于(缓存)字符‘串的’hashcode
    private int hash; // Default to 0

    // else code
    // ... ...
}

『我们需要(注意)编译器会』对String‘做一些优’化,「比 如下[列代码」:


class Demo {
    public static void main(String[] args) {
        String s1 ="Ja"+"va";
        String s2 = "Java";
        System.out.println(s1 == s2);
    }
}

String“<的构造“方法”>”?

String{是一【个】{类}},《所以》我们(除)了使<用>String s1 = "abc"{方}式创建字符串对『象』之「外」,{还可以}通过String{类}“<的构造“方法”>”进行创建。《通过》查看jdk【(文档)我】们发现String{类}
《有下面这样的构造函{数}》:

<我们需>要(注意)这两种创《建方式的区别》:


class Demo {
    public static void main(String[] args) {
        String s1 = Newstring("Java");   // 1
        String s2 = s1.intern();         // 2
        String s3 = "Java";              // 3
        System.out.println(s1 == s2);
        System.out.println(s2 == s3);
    }
}

1『处代码的含义是』:(在)堆内存中使<用>new的方式创建了一【个】字符串对『象』并把地址 值[赋给了引<用>变《量》s1,「并」且该对『象』(在)创建的时{候接收了一【个】字符}串对『象』;《「“「〖〖而〗〗」”」》2『处代码的含义是』:‘(在)堆内存中创建一【个】’变《量》s2,如果调<用>intern(){才会把此字符串保存到}字符串常「《量》池」中;3『处代码的含义是』:(在)字符串常「《量》池」中创建(了一【个】 值[为)"Java"的字符串对『象』,并把该对『象』 的地址 值[[赋给了引<用>变《量》s3;《所以》3<处的代>码最终只创建了一【个】对『象』,《「“「〖〖而〗〗」”」》1‘处’的代码有可能创建一【个】(字符串常「《量》池」中有字符串对『象』"Java")也有可能创建两【个】(字符串常「《量》池」中没有字符串对『象』"Java")。这三【个】引<用>变《量》(在)JVM中存储的位置 如下[:

(注意):(在)JDK6.0<及之前版>本,字符串常「《量》池」是放(在)“方法”区中,《「“「〖〖而〗〗」”」》(在)JDK7.0版本,字符串常「《量》池」被移到了‘堆中’。

《我们可以看到》引<用>变《量》s1『和』引<用>变《量》s2‘的’内容其实是相等的,【都是】"Java",‘于是如果我们只想’比较两者的内容时,就可以使<用>equals()。


class Demo {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

这里需要(注意),Object{类}中equals()的<源码>是下面这样的:


public boolean equals(Object obj) {
    return (this == obj);   // 比较的还是对『象』 的地址 值[[
}

《「“「〖〖而〗〗」”」》String{类}对该“方法”进行了覆盖,<源码>是这样的:


public boolean equals(Object anObject) {
    // 对『象』引<用>“相同”直接“返”回 true
    if (this == anObject) {
        return true;
    }

    // 判断需要对比的 值[是否为String{类}型,<如果不是>则直接“返”回false
    if (anObject instanceof String) {   
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            // 把两【个】字符串都转换为 char 【{数} 组[对比】
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;

            // 循环比对两【个】字符‘串的’每一【个】字符
            while (n-- != 0) {

                // 如果其中有一【个】字符不〖相等就〗 true false,“否则”继续对比
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

String{类}有几【个】很常<用>“<的构造“方法”>”, 如下[:


// char[]为参{数}“<的构造“方法”>”
public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}

// byte[]为参{数}“<的构造“方法”>”
public String(byte bytes[]) {
    this(bytes, 0, bytes.length);
}

// string为参{数}“<的构造“方法”>”
public String(String orIGinal) {
    this.value = original.value;
    this.hash = original.hash;
}

// StringBuffer为参{数}“<的构造“方法”>” 
public String(StringBuffer buffer) {
    synchronized(buffer) {
        this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
    }
}

// StringBuilder为参{数}“<的构造“方法”>”  
public String(StringBuilder builder) {
    this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

String“的常”<用>“方法”?

《通过》查看jdk(文档),《我们可以看到》String{类}有很多“方法”,将其中常<用>的“方法”分为下面几{类}:

  • <用>于获取:

1.1 获取字符串中字符的【个】{数}(长度):
        int length();
1.2 根据位置获取字符:
        char charAt(int index);
1.3 根据字符获取(在)字符串中的第一次出现的位置:
        int indexOf();    // (注意)此“方法”的有多种重『载形式』
  • <用>于转换

1.1 将字符串变成字符串{数} 组[({字}符‘串的’切割):
        String[]  split(String regex);   // (注意)此“方法”涉及到正则“表达式”
1.2 将字符串中的字母转成<大小>写:
        String toUpperCase():【大写】
        String toLowerCase():{小写}
1.3 “将字符串”中的内容进行<替换>:
        String replace();
1.4 ‘将字’符串两端的空格去(除):
        String trim();
           
  • <用>于判断

1.1 ‘判断字’符串中是否包含「指定字符串」:
        boolean contains(string str);
  • <用>于比较

1.1 比较两【个】字符串:
        int compareTo(String anotherString)

// <《下面为》>compareTo“方法”的<源码>
public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;

    // 对比每一【个】字符
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];

        // 如果字符不〖相等就〗“返”回差 值[
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

【可以】看出compareTo()『和』equals()【都是】<用>于比较两【个】字符‘串的’, 并且当[equals()“返”回true【或者是】compareTo()“返”回0时,则表示两【个】字符串完全“相同”。这两【个】“方法”的区别(在)于:compareTo()《接收的是》String{类}型的参{数},《「“「〖〖而〗〗」”」》equals()可以接收一【个】Object{类}型的参{数};compareTo()的“返”回 值[为int,《「“「〖〖而〗〗」”」》equals()“返”回 值[为Boolean。

,

诚信(在)线娱乐

诚信(在)线(原诚信(在)线官网)现已开放阳光(在)线手机版、阳光(在)线电脑客户端下载。阳光(在)线娱乐游戏公平、【公开】、【公正】,<用>实力赢取信誉。

皇冠体育网站内容转载自互联网,如有侵权,联系皇冠APP下载删除。

本文链接地址:http://www.wx-gangguan.com/post/943.html

相关文章

发表评论