java基础语法（十七）String

最新推荐文章于 2024-08-10 02:43:56 发布

顺毛黑起

最新推荐文章于 2024-08-10 02:43:56 发布

阅读量312

点赞数

分类专栏： java 文章标签： java 字符串

本文链接：https://blog.csdn.net/Apikaqiu/article/details/105459625

版权

java 专栏收录该内容

48 篇文章 9 订阅

订阅专栏

常用

关于javaIDK中内置的一个类：java.lang.String
1、String表示字符串类型，属于引用数据类型，不属于基本数据类型。
2、在java中使用双引号括起来的都是String对象。
3、java中规定，双引号括起来的字符串，是不可变的。
4、在JDK当中双引号括起来的字符串都是直接存储在方法区的“字符串常量池”当中的
为什么SUN公司把字符串存储在一个"字符串常量池"当中呢？因为字符串在实际开发中使用太频繁。为了执行效率，
所以把字符串放到了方法区的字符串常量池当中。

public class StringTest01 {
    public static void main(StringTest01[] args) {
        //这两行代码表示底层创建了3个字符串对象，堆在字符串常量池当中。
        String  s1 = "abcdef";
        String  s2 = "abcdef" + "xy";

        //这是使用new的方式创建的字符串对象。这个代码当中的"xy"是从哪里来的？
        //凡是双引号括起来的都在字符串常量池当中有一份
        //new对象的时候一定在堆内存中开辟空间。
        String s3 = new String("xy");

    }
}

在这里插入图片描述
String类型的引用当中同样也是保存了对象的内存地址

 public static void main(String[] args) {
        User user = new User(110,"张三");
    }

在这里插入图片描述

  public static void main(String[] args) {
        String s1 = "hello";
        //"hello"是存储在方法区的字符串常量池当中。
        //所以这个"hello"不会新建。（因为这个对象已经存在了！）
        String s2 = "hello";
        //==双等号比较的是变量中保存的内存地址。
        System.out.println(s1 == s2);//true

        String x = new String("xyz");
        String y = new String("xyz");
        System.out.println(x == y);//false

        //字符串对象之间的比较不能使用"==",应该调用String类的equals方法。
        //String类已经重写了equals方法，以下的equals方法调用的是String重写之后的equals方法。
        System.out.println(x.equals(y));//true

        String k = new String("testString");
        //"testString"这个字符串可以后面加"."
        //因为"testString"是一个String字符串对象。只要是对象都能调用方法。
        System.out.println("testString".equals(k));//建议使用这种方式，因为这个可以避免空指针异常。
        System.out.println(k.equals("testString"));

    }

上述代码的内存结构图

关于String类中的构造方法

第一个：String s = new String(" ");
第二个：String s = " ";最常用
第三个：String s = new String(char数组);
第四个：String s = new String(char数组，起始下标，长度);
第五个：String s = new String(byte数组);
第六个：String s = new String(byte数组，起始下标，长度);

 public static void main(String[] args) {
        //创建字符串对象最常用的一种方式
        String s1="hello world!";

        //这里只掌握常用的构造方法
        byte[] bytes={97,98,99};//97是a，98是b，99是c
        String s2 = new String(bytes);
        //输出一个引用的时候，会自动调用toString()方法,默认是Object的话，会自动输出对象的内存地址。
        //String类已经重写了toString()方法。
        //输出字符串对象的话，输出的不是对象的内存地址，而是字符串本身。
        System.out.println(s2);//abc
        System.out.println(s2.toString());//abc

        //String(字节数组，数组元素下标的起始位置，长度)
        //将byte数组中的一部分转换成字符串
        String s3 = new String(bytes,1,2);
        System.out.println(s3);//bc

        //将char数组全部转换成字符串
        char[] chars={'喜','欢','吃','火','锅'};
        String s4 = new String(chars);
        System.out.println(s4);//喜欢吃火锅
        //将char数组的一部分转换成字符串
        String s5 = new String(chars,2,3);
        System.out.println(s5);//吃火锅

        String s6 = new String("hello world");
        System.out.println(s6);//hello world


    }

String类当中常用方法

public static void main(String[] args) {
        //String类当中常用的方法
        //1.char charAt(int index)
        char c = "云吃火锅".charAt(0);
        System.out.println(c);//云

        //2.int compareTo(String anotherString)
        //字符串之间比较大小不能直接使用> <,需要使用compareTo方法
        int result = "abc".compareTo("abc");
        System.out.println(result);//0(等于0) 前后一致

        int result2 = "abcd".compareTo("abce");
        System.out.println(result2);//-1(小于0) 前小后大

        int result3 = "abce".compareTo("abcd");
        System.out.println(result3);//1(大于0) 前大后小

        System.out.println("xyz".compareTo("yxz"));//-1

        //3.boolean contains(CharSequence s)
        //判断前面的字符串中是否包含后面的子字符串
        System.out.println("HelloWorld.java".contains(".java"));//true

        //4.boolean endsWith(String suffix)
        //判断当前字符串是否以某个字符串结尾
        System.out.println("test.txt".endsWith(".java"));//false
        System.out.println("test.txt".endsWith(".txt"));//true

        //5.boolean equals(Object anObject)
        //比较两个字符串必须使用equals方法，不能使用"=="
        //equals方法只能看出相等不相等
        //compareTo方法可以看出是否相等，并且同时还可以看出谁大谁小
        System.out.println("abc".equals("abc"));//true

        //6.boolean equalsIgnoreCase(String anotherString)
        //判断两个字符串是否相等，并且同时忽略大小写
        System.out.println("ABC".equalsIgnoreCase("abC"));//true

        //7.byte[] getBytes()
        //将字符串对象转换成字节数组
        byte[] bytes="abcdef".getBytes();//97 98 99 100 101 102
        for(int i = 0;i<bytes.length;i++){
            System.out.println(bytes[i]);

        }

        //8.int indexOf(String str)
        //判断某个子字符串在当前字符串中第一次出现处的索引。
        System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".indexOf("java"));//6

        //9.boolean isEmpty()
        //判断某个字符串是否为空字符串
        String s = "";
        System.out.println(s.isEmpty());//true

        //10 imt length()
        //判断数组长度和判断字符串长度不一样
        //判断数组长度是length属性，判断字符串长度是length()方法
        System.out.println("abc".length());//3

        //11.int lastIndexOf(String str)
        //判断某个子字符串在当前字符串中最后一次出现处的索引。
        System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".lastIndexOf("java"));//28

        //12.String replace(char oldChar,char newChar)
        //String的父接口就是：CharSequence
        String newString ="http://www.baidu.com".replace("http://","https://");
        System.out.println(newString);//https://www.baidu.com

        //13.String[] split(String regex)
        //拆分字符串
        String[] ymd="1980-10-11".split("-");//"1980-10-11"以"."分隔符进行拆分。
        for(int i = 0;i<ymd.length;i++){
            System.out.println(ymd[i]);
        }

        //14.boolean startsWith(String prefix)
        //判断某个字符串是否以某个子字符串开始。
        System.out.println("http://www.baidu.com".startsWith("http://"));//true

        //15.String substring(int beginIndex) 参数是起始下标
        //截取字符串
        System.out.println("http://www.baidu.com".substring(7));//www.baidu.com

        //16.String substring(int beginIndex,int endIndex)   左闭右开
        System.out.println("http://www.baidu.com".substring(7,10));//www

        //17.char[] toCharArray()
        //将字符串转换成char数组
        char[] chars = "我爱吃火锅".toCharArray();
        for(int i = 0;i<chars.length;i++)
        {
            System.out.println(chars[i]);
        }

        //18.String toLowerCase()
        //转换为小写
        System.out.println("ABCDefGh".toLowerCase());//abcdefgh

        //19.String toUpperCase()
        //转成大写
        System.out.println("ABCDefGh".toUpperCase());//ABCDEFGH

        //20.String trim()
        //去除字符串前后空白
        System.out.println("   hello   world   ".trim());//hello   world

        //21.String中只有一个方法是静态的，不需要new对象
        //这个方法叫做valueOf
        //作用：将"非字符串"转换成"字符串"
        String s1 =String.valueOf(true);
        System.out.println(s1);
        String s2 =String.valueOf(3.14);
        System.out.println(s2);
        //这个静态的valueOf()方法，参数是一个对象的时候，会自动调用该对象的toString()方法吗？
        String c1 =String.valueOf(new Customer());
        //System.out.println(c1);//没有重写toString()方法之前是对象的内存地址  javase2.changyonglei.Customer@326de728
        System.out.println(c1);//我是一个VIP客户！！！
        //本质上System.out.println()这个方法在输出任何数据的时候都是先转换成字符串再输出
        System.out.println(new Customer());//同样，如果创建的该类的对象，如果该类重写toString()方法，则调用，否则返回对象的内存地址
    }

StringBuffer

在实际的开发中，如果需要进行字符串的频繁拼接，会有什么问题？
因为java中的字符串是不可变的，每一次拼接都会产生新字符串。
这样会占用大量的方法区内存，造成内存空间的浪费。
String s = “abc”;
s += “hello”;
就以上两行代码，就导致在方法区字符串常量池当中创建了3个对象：
“abc” “hello” “abchello”

String s ="";
//这样会给java的方法区字符串常量池带来很大的压力
for(int i = 0;i<100;i++){
     s=s+i;
     System.out.println(s);
        }

如果以后需要进行大量字符串的拼接操作，建议使用JDK中自带的：
java.lang.StringBuffer
java.lang.StringBuilder
如何优化StringBuffer的性能
在创建StringBuffer的时候尽可能给定一个初始化容量。
最好减少底层数组的扩容次数。预估计一下，给一个大一些的初始化容量。

public static void main(String[] args) {
        //创建一个初始化容量为16个byte[]数组。（字符串缓冲区对象）
        StringBuffer stringabuffer = new StringBuffer();

        //拼接字符串，以后拼接字符串统一调用append()方法
        //append是追加的意思
        stringabuffer.append("a");
        stringabuffer.append("b");
        stringabuffer.append("d");
        stringabuffer.append(3.14);
        stringabuffer.append(true);
        stringabuffer.append(100L);
        //append方法底层在进行追加的时候，如果byte数组满了，会自动扩容
        System.out.println(stringabuffer.toString());//abd3.14true100

        //指定初始化容量的StringBuffer对象(字符串缓冲区对象)
        StringBuffer sbu = new StringBuffer(100);
    }

StringBuffer和StringBuilder的区别：
StringBuffer中的方法都有：synchronized关键字修饰。表示StringBuffer在多线程环境下运行是安全的。
StringBuilder中的方法都没有：synchronized关键字修饰。表示StringBuilder在多线程环境下运行是不安全的。