java String类介绍

对String的概述

String :代表字符串，java中其他字符串都是String的实例化过程。
public final class String extends Object
说明该字符串是继承于Object 而且是 final型不可继承。

字符串的赋值方式

String str = “abc”;
char data[] = {‘a’,‘b’,‘c’};String str = new String(data);
注意：字符串是常量，它们的值创建后就不能被更改。

String的构造方法

public String() 空参构造// 几乎没什么用因为string是不可变的。
public String(byte[] bytes) 将字节数组转化为字符串
public String(byte[] bytes,int index,int length) 把字节数组的一部分转化为字符串
public String(String original):把字符串常量转化为字符串

String 常见问题

1.判断定义为string类型的s1和s2是否相等
- String s1 = “abc";
- String s2 = “abc”;
- System.out.println(s1 == s2);//true
- System.out.println(s1.equals(s2));//true
2.判断定义为string类型的s1和s2是否相等
- String s1 = new String(“abc”);
- String s2 = “abc”;
- System.out.println(s1 == s2 );//false
- System.out.println(s1.equals(s2));//true
3.下面这句话中，在内存中创建了几个对象
- String s1 = new String(“abc”);//两个
4.判断定义为String类型的s1和s2是否相等
- String s1 = " a" + “b”+ “c”;
- String s2 = “abc”;
- System.out.println(s1 == s2);//true
- System.out.println(s1.equals(s2));//true
5.判断定义为String类型的s1和s2是否相等
- String s1 = “ab”;
- String s2 = “abc”;
- String s3 = s1+“c”;
- System.out.println(s3 == s2 );//false
- System.out.println(s3.equals(s2));//true

常见string的判断功能

boolean equals(Object obj):比较字符串的内容是否相同,区分大小写

//String 重写的toString()方法
 public boolean equals(Object anObject) {
        if (this == anObject) {		//如果地址相同
            return true;					//返回 true
        }
        if (anObject instanceof String) { //判断 anObject 是否为String类的对象  如果不是 返回false
            String anotherString = (String)anObject;//将anObject强转为String(安全)
            int n = value.length;  //拿对象的长度为n
            if (n == anotherString.value.length) { // 拿要判断的anotherString长度是否等于n
                char v1[] = value; //将对象的字符串数组给v1
                char v2[] = anotherString.value;//将要比较的字符串数组给v2
                int i = 0; // 一一比较 ，有一个不一样，那么直接返回false 
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;// 如果还没返回，那么证明正确。返回true
            }
        }
        return false;
    }

boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
boolean contains(String str):判断大字符串中是否包含小字符串

		s.contains(s2);//使用方法

    public boolean contains(CharSequence s) {
        return indexOf(s.toString()) > -1; //我们要调用indexOf()方法，这方法下面
        //有介绍 ，如果能找到那么返回下标值，否则返回-1(大于-1 那么就是存在)
    }

boolean startsWith(String str):判断字符串是否以某个指定的字符串开头

		s.startsWith(s0); //调用方法

public boolean startsWith(String prefix) {
        return startsWith(prefix, 0); //调用startsWith()方法，这里是有参数的，也是告诉
        //我们可以有从特定下标开始
    }
 public boolean startsWith(String prefix, int toffset) {
        char ta[] = value;	//拿调用者的字符数组
        int to = toffset;	//拿下表值 （这里我们是0）
        char pa[] = prefix.value;	//拿小串的字符数组
        int po = 0;
        int pc = prefix.value.length; // 拿小串的字符数组长度
        // Note: toffset might be near -1>>>1.
        if ((toffset < 0) || (toffset > value.length - pc)) {//如果下标为负，那么返回
        //false，如果两串的具体比较点，不一样长，那么返回false
            return false;
        }
        while (--pc >= 0) {//一一比较 如果有一个为false 返回false
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;//最后返回true
    }

boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾

		s.endsWith(s1);//调用方法

    public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }//其实都是用了一个startsWith(String str,int index)方法

boolean isEmpty():判断字符串是否为空。

    public boolean isEmpty() {
        return value.length == 0;
    }

String的获取功能

int length():获取字符串的长度。

//从上面的源码，我们也可以看出 ，String类是将String翻译为
//字符数组 private final char value[]  而且是final型的
    public int length() { //利用value长度来算
        return value.length;
    }

char charAt(int index):获取指定索引位置的字符

    public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];//换出数组后，再用数组索引
    }

int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
String substring(int start):从指定位置开始截取字符串,默认到末尾。

s.substring(0); // 使用方法

  public String substring(int beginIndex) {
        if (beginIndex < 0) {//如果索引小于0，报数组越界指针异常
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;//需要复制的长度
        if (subLen < 0) {//长度小于0，数组越界异常
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }									//value 数组 ，开始下标，数组长度

    public String(char value[], int offset, int count) {
        if (offset < 0) {//下标越界
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {//数组长度小于0，不合理 数组越界异常
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= value.length) {//长度为0，返回空数组，进而生成空字符串
                this.value = "".value;
                return;
            }
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {//开始点 大于原数组长度-count ，找不到
        //开始点，数组越界异常
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        //调用Arrays.copyOfRange方法复制 ,这里跨出了这个类，Arrays类可在我另外的
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

Arrays介绍

String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。

//和上面已经分析过

常见的字符串转化

byte[] getBytes():把字符串转换为字节数组。

//源码太多 我们还是先看用法吧
		s.getBytes();//返回字节数组

char[] toCharArray():把字符串转换为字符数组。

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);
        //这个方法 是java外的方法写的，按理来说更加高效
        return result;
    }

static String valueOf(char[] chs):把字符数组转成字符串。
static String valueOf(int i):把int类型的数据转成字符串。
- 注意：String类的valueOf方法可以把任意类型的数据转成字符串
String toLowerCase():把字符串转成小写。(了解)
String toUpperCase():把字符串转成大写。
String concat(String str):把字符串拼接。
Integer.parseInt(str);转化为整数（当然还有其他数据）

String类的其他功能

String的替换功能
- String replace(char old,char new)

  public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

* String replace(String old,String new)

//和上面一致

String的去除字符串两侧空格
- String trim()

  public String trim() {
        int len = value.length;//拿到字符串长度
        int st = 0;	
        char[] val = value;    /* avoid getfield opcode */
								//复制字符数组
        while ((st < len) && (val[st] <= ' ')) {//在数组长度内循环
            st++;
        }
        while ((st < len) && (val[len - 1] <= ' ')) {
            len--;
        }
        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
    }

String的按字典顺序比较两个字符串
- int compareTo(String str)

//如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返
//回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。
 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];	 //拿到各自的第k个字符
            char c2 = v2[k];
            if (c1 != c2) {	//比较字符如果不相等，那么相减得到一个数（当字符s1的k
            //字符大于s2的k字符时返回正数，反之返回负数）
                return c1 - c2;
            }
            k++;//如果相等 k++ 继续循环
        }
        return len1 - len2;
    }

int compareToIgnoreCase(String str)

// 和上面分析一致

对String的概述

字符串的赋值方式

String的构造方法

String 常见问题

常见string的判断功能

String的获取功能

常见的字符串转化

String类的其他功能

猜你喜欢