• Java常用类：String

    一、介绍

    String:不可变的Unicode字符序列

        例如:"Java"   就是4个Unicode字符J,a,v,a组成的

        Java没有内置的字符串类型,而是在标准的Java类库中提供了一个预定义的类String.每个用双引号括起来的字符串就是String类的一个实例.

         当使用+，实际是产生新的对象

    StringBuilder：可变字符序列，线程不安全，效率高（常用）
    StringBuffer：可变字符序列，线程安全，效率低

    （使用循环拼接字符串时，一定要用StringBuilder或者StringBuffer其中的一个）


    二、查看String的一小部分源码

    1
    2
    3
    4
    5
    6
    The <code>String</code> class represents character strings. All
     * string literals in Java programs, such as <code>"abc"</code>, are
     * implemented as instances of this class.
     * <p>
     * Strings are constant; their values cannot be changed after they
     * are created.

    String类存在于java.lang包中。上述大概意思：String是一个字符串，String的字面量也是String的一个实例。String它的值在创建以后是不能变的.....

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

    可以看出外部类是不能直接访问到这个value属性的，这个char value[]不可变

    以下是String的部分构造器：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    //默认构造器,当写下了String str =new String();的时候，其实内部是给了一个长度为0的char数组给value
        public String() {
          ...省略部分....
          this.value = new char[0];
        }
        //可以传递一个字符串，则直接把传递的字符串赋给了value
        public String(String original) {
          ...省略部分....
          this.value = v;
        }
        /**
        *也可以传递一个字符数组，例如：可以像下面这样
        *char[] c = {'a','b','c'};
        *String str = new String(c);
        */
        public String(char value[]) {
        int size = value.length;
        this.offset = 0;
        this.count = size;
        this.value = Arrays.copyOf(value, size);
        }

    String重载了很多构造器，不一一查看了。

    String的一些常用方法源码：还有很多其他的，不一一介绍了，使用起来都很简单。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    //length是直接返回的count
    public int length() {
       return count;
    }
    //isEmpty是直接判断count是否等于0
    public boolean isEmpty() {
       return count == 0;
    }
    //charAt是取char[] value中相应索引的值，count不在范围抛出数组索引越界异常
    public char charAt(int index) {
       if ((index < 0) || (index >= count)) {
           throw new StringIndexOutOfBoundsException(index);
       }
       return value[index + offset];
    }
    //substring
    public String substring(int beginIndex) {
        return substring(beginIndex, count);
    }
    //开始索引小于0,大于当前对象总长度，或者结束索引大于总长度，都抛出越界异常
    //否则，开始等于0，结束等于总长度，则重新new一个string对象
    public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > count) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        if (beginIndex > endIndex) {
            throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
        }
        return ((beginIndex == 0) && (endIndex == count)) ? this :
            new String(offset + beginIndex, endIndex - beginIndex, value);
    }
       
       
    //常用的equals方法（重写了父类的equals方法），是先比较对象是否为同一个对象。然后比较其内容是否都相等。
    public boolean equals(Object anObject) {
    if (this == anObject) {//首先比较当前对象和传来的对象是不是同一个对象
       return true;
    }
    if (anObject instanceof String) {//如果传来的对象是String的一个实例
       String anotherString = (String)anObject;
       int n = count;
       if (n == anotherString.count) {
       char v1[] = value;
       char v2[] = anotherString.value;
       int i = offset;
       int j = anotherString.offset;
       while (n-- != 0) {//数组每个元素对应比较
           if (v1[i++] != v2[j++])//如果有一个元素不相等，返回false
           return false;
       }
       return true;
       }
    }
    return false;
    }

    length、isEmpty、charAt、substring等等的就不做测试了，主要测试equals方法

    1
    2
    3
    String str = new String("abcd");
    String str2 = str;
    System.out.println(str.equals(str2));//返回结果：true，因为str和str2都指向了同一个new String("abcd");对象
    1
    2
    3
    4
    5
    String str = new String("abcd");
    String str2 = new String("abcd");
    System.out.println(str.equals(str2));//返回结果：true，此时str和str2指向的不是同一个对象，但是内容相等
    //但是如果直接==的话就是false
    System.out.println(str==str2);//因为不是同一个对象


    三、总结

    1、String是由final修饰的class，不可修改。内部的属性都是private的，不给外部访问。

    2、内部的主要操作就是操作的char value[]数组，这个value其实是可以修改的，但是jdk中没有提供接口供你修改。

    3、字符串比较需要使用equals方法，两个对象比较使用==

    4、部分常用方法，还有一些concat、replace、replaceFirst、replaceAll、split、toLowerCase、toUpperCase、trim、valueOf等等的方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //长度：直接返回count属性
    public int length()
    //是否空：直接return count==0
    public boolean isEmpty()
    //根据指定索引获取字符：如果index<0或者index>count都抛出*StringIndexOutOfBoundsException,否则直接返回char数组中对应的值
    public char charAt(int index)
    //如果传来的和调用的是同一个对象，返回true
    //然后遍历比较，如果传来对象的其中一个值跟调用的对象不等，就返回false
    public boolean equals(Object anObject)
    //substring先判断beginIndex < 0，beginIndex < 0，beginIndex >endIndex都会抛出异常
    //否则(beginIndex == 0) && (endIndex == count)成立的话直接返回this,不成立则new String
    public String substring(int beginIndex, int endIndex)

    5、值得一提的是，String的toString方法是直接返回的this

    6、String对象个数问题：

    1
    2
    3
    4
    5
    6
    7
    8
    String str="a";//总共一个对象a
    String str2=new String("a");//总共两个对象：一个new String，一个a
     
    String str="a";//这里一个对象
    for(int i=0;i<10;i++){
       str = str + i;//这里每循环一次都会创建一个对象
    }
    //以上执行完会出现11个对象
  • 相关阅读:
    基于物品的协同过滤推荐算法
    监督学习与非监督学习的区别
    深入了解当前ETL的一些基本技术
    基于hadoop的图书推荐
    基于KNN的相关内容推荐
    KNN算法的补充
    Confluence 6 升级中的一些常见问题
    Confluence 6 升级以后
    Confluence 6 在升级之前
    Windows 独立启动方式安装 Archiva
  • 原文地址：https://www.cnblogs.com/meet/p/4696255.html
Copyright © 2020-2023  润新知