JavaSE进阶:432-459 String类方法/StringBuilder/StringBuffer/包装类

开始时间：2020-11-08

String类的常用方法

charAt

package BUPT20201108;

public class StringTest03 {
    public static void main(String[] args) {
        char c="程序员".charAt(2);
        System.out.println(c);
    }
}

输出为 员

String.compareTo

类似以C语言中的Strcmp

package BUPT20201108;

public class StringTest03 {
    public static void main(String[] args) {
        int result="abc".compareTo("avdc");
        System.out.println(result);
        int result2="a".compareTo("z");
        System.out.println(result2);
        int result3="a".compareTo("程序员");
        System.out.println(result3);
        //返回的是第一次出现不同位，这两位的asc码差值
    }
}

-20
-25
-31146

contains

求前者是否包含后者

        System.out.println("我是程序员".contains("程序员"));

返回true
要出现完整的一段才能返回true

endswith

判断当前字符串是否以某个字符串结尾

        System.out.println("coder.java".endsWith(".java"));

startsWith

判断是否以某个字符串开始

  System.out.println("java.com".startsWith("java"));

equalsIgnoreCase

比较字符串，忽略大小写

 System.out.println("abc".equalsIgnoreCase("AbC"));

返回true

getBytes

将字符串对象转为字节数组

        byte[] bytes = "abcd".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

indexOf

判断某个子字符串，在当前字符串中第一次出现处的索引

        System.out.println("abc.java".indexOf(".jeava"));

这种情况返回-1，其他时候返回第一次出现的索引值

isEmpty

返回字符串是否为空

        String s1="";
        System.out.println(s1.isEmpty());
        String s2=" ";
        System.out.println(s2.isEmpty());

true false
前面为空后面不是空
但这个空和null不同，null的话是返回空指针异常
当然也可以用
字符串.length来判断，如果长度为0也为空

注意的是，判断数组长度是length属性，判断字符串长度是length方法，前者没有括号，后者有

lastIndexof

返回最后一次出现的索引

System.out.println("javapythonc++javapythonc++javapythonc++".lastIndexOf("java"));

26

replace方法

替换字符串
String.replace(oldString,newString)

 System.out.println("javapythonc++javapythonc++".replace("java","JAVA"));

JAVApythonc++JAVApythonc++

split方法

String.split("XX ");
返回以个字符串数组

        String[] ymd="1980-1-1".split("-");
        for (int i = 0; i < ymd.length; i++) {
            System.out.println(ymd[i]);
        }

subString

截取字符串

System.out.println("javacwwww".substring(2,4));//左闭右开，包含2不包含4，长度为2

va

toCharArray()

将字符串转为char数组

       char[] chars = "我是程序员".toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

toLowerCase()

转小写

System.out.println("Java.COM".toLowerCase());

转大写

System.out.println("Java.COM".toUpperCase());

Trim()

去除前后空白
这个和VBA语法也很像，参考
https://blog.csdn.net/qq_43568982/article/details/103754190

System.out.println("  Java.COM  ".trim());

valueof

把不是字符串的东西转为字符串

package BUPT20201108;

public class StringTest04 {
    public static void main(String[] args) {
        String s1 = String.valueOf(true);
        String s2 = String.valueOf(3.14);
        System.out.println(s1);
        System.out.println(s2);
        //把boolean型或者是float等数据类型都转为字符串
    }
}

如果参数为对象，则返回转为字符串类型的内存地址

        String s3 = String.valueOf(new User());
        //调用了toString方法，输出对象内存地址
        System.out.println(s3);
    }
}

class User {
    public User() {
    }
}

其实输出到控制台上的数据，都是转为了String。展现在控制台上的都是字符串

StringBuffer和StringBuilder

Ctrl+Alt可以再点方法，能查看SUN写的源代码

可以参考
https://blog.csdn.net/qq_43568982/article/details/104605118

package Stringbuffer;

//实际开发中，如果频繁地字符串拼接，会很占方法区内存，造成内存空间的浪费，效率低下
//建议使用 java.lang.StringBuffer,不要再用加号  + 了
public class StringbufferTest01 {
    public static void main(String[] args) {
        //创建的数组时16个byte[]数组
        //可以自动扩容，但是最好给一个预估初始值，减少扩容次数
        StringBuffer stringBuffer = new StringBuffer();
        //用append来累加，append的父类没有final修饰，可以继续加。
        // String的被final修饰了
        stringBuffer.append("waaaaaaaaaaa");
        stringBuffer.append("abxxcxzccxzcx");
        stringBuffer.append(2321321);
        stringBuffer.append(true);
        System.out.println(stringBuffer);
        //初始化缓冲区
        StringBuffer sb=new StringBuffer(100);
        sb.append("world");
        sb.append(103);
        System.out.println(sb);
    }
}

StringBuffer和StringBuilder两者都可以实现追加功能，但是还是有点不同
StringBuffer中的方法都有：synchronized关键字修饰
表示在多线程环境运行下是安全的
而StringBuilder都没有，表示在多线程环境下运行是不安全的

package Stringbuffer;

public class StringBufferTest {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append(100);
        System.out.println(sb);
    }
}

包装类

八种基本数据类型不够用

package Test;

//Java为8种基本数据类型，准备了8种包装数据类型，8种包装类属于引用数据类型
public class IntegerTest {
    public static void main(String[] args) {
        //比如说调用doSome()方法，需要传一个数字进去
        //但是参数需要传Object进去，传int类不行
        //可以传一个包装类的数字进去\
        Myint myint=new Myint(10);
        //doSome()方法虽然不能直接传100，但是可以传100对应的包装类型
        doSome(myint);
    }

    public static void doSome(Object obj) {
        System.out.println(obj);//输出了内存地址，所以需要重写一下
    }
}

package Test;

public class Myint {
    int value;

    public Myint() {
    }

    public Myint(int value) {
        this.value = value;
    }
    //重写一下toString()
    public String toString() {
        return String.valueOf(value);
    }
}

实际中不需要自己写

装箱和拆箱

package Test;

public class IntegerTest02 {
    public static void main(String[] args) {
        //基本数据类型->引用数据类型：装箱
        Integer i=new Integer(123);
        //引用数据类型->基本数据类型：拆箱
        //类似的方法都是负责拆箱
        float f=i.floatValue();
        System.out.println(f);
    }
}

字符串不能装中文，这样拆箱会出错
报NumberFormatException

自动装箱和拆箱

package Test;

public class JavaTest05 {
    public static void main(String[] args) {
        //自动装箱
        //int->Integer
        Integer x = 100;
        //自动拆箱
        float i=x;
        System.out.println(i);
        Integer Z=100;
        System.out.println(z+1);
        //会自动拆箱，保证能正常相加
    }
}

加减乘除这种运算是可以拆箱的，双等号是不会触发自动拆箱机制的

        Integer a=1000;
        Integer b=1000;
        System.out.println(a==b);

返回false

但是，如果是这样

        Integer a=127;
        Integer b=127;
        System.out.println(a==b);

返回true，这个用法有点类似于Python中的一个机制
类加载，放到了整数型常量池里面了
参考：https://blog.csdn.net/qq_43568982/article/details/105207222
池：cache，缓存的意思
缓存优点是效率高，缺点是耗内存
项目的优化手段一个重要点就是缓存优化

Integer的构造方法

package Test;

public class IntegerTest03 {
    public static void main(String[] args) {
        Integer x = new Integer(100);
        //也可以用字符串传进去装箱
        //int和String都可以
        Integer y = new Integer("123");
        System.out.println(x);
        System.out.println(y);
    }
}

通过常量返回最大值和最小值

package Test;

public class IntegerTest04 {
    public static void main(String[] args) {
        //通过访问包装类的常量，来获得最大值和最小值
        //即这种数据类型的最大和最小，有了这个就不需要自己背范围了
        System.out.println("int的最大值"+Integer.MAX_VALUE);
        System.out.println("int的最大值"+Integer.MIN_VALUE);
        System.out.println("Byte的最大值"+Byte.MAX_VALUE);
    }
}

int的最大值2147483647
int的最大值-2147483648
Byte的最大值127

//面试题：为什么String是不可变的
//源代码中，String类中有一个byte[]数组，这个数组都用final修饰
//因为数组一旦创建，长度是不能变的，并且被final修饰的引用一旦指向某个对象后
//不可再指向其他对象，所以String是不可变的

/*
StringBuffer StringBuilder内部实际是一个byte[]数组，这个数组没有被final修饰
当StringBuffer或者StringBuilder的初始化，容量是16，底层调用了数组拷贝的方法
System.arrayCopy()，所以Stringbuffer或StringBuilder适合用于
字符串的频繁拼接
字符串不可变不是指引用变量名不可变，而是说字符串本身不可由"abc"变为"abcd"
*/

parseInt方法

静态方法
同样parseFloat parseDouble都有

package BUPT20201108;

public class IntegerTest {
    public static void main(String[] args) {
        //字符串转数字，同样中文不能转数字
        int retValue = Integer.parseInt("123");
        System.out.println(retValue + 100);
    }
}

toHexString

转为十六进制或者其他进制

        String hexString=Integer.toHexString(18);
        System.out.println(hexString);

总结

int，integer，string的互相转换

代码实现

package BUPT20201108;

public class IntegerTest02 {
    public static void main(String[] args) {
        //String->int
        int i1 = Integer.parseInt("1000");
        //String->Integer
        String s2 = i1 + "";
        //int->String
        Integer k = Integer.valueOf("123");
        //int->Integer
        Integer x = 100;
        //Integer->int
        int y = x;
        //Integer->String
        String e = String.valueOf(x);
    }
}

结束时间：2020-11-09