Java 常用类 String

String

2.1.1、String 类是不可变，也就是说String对象声明后，将不可修改

public class Stringtest(){
	
	public static void main(String[]args){
	
		String s1 ="a"
		
		String s2 ="b";
		
		s1 = s1 + s2 //ab
		//new String("a");
		System.out.print(s1)
		
	}
}

test01

package commonClass.String;

public class StringTest01 {
    /*
        Java.lang.String； 是字符串类型
            1.字符串一旦创建不可再改变。”abc“字符串对象一旦创建，不可再改变成"abcd"
            2.提升字符串的访问效率；在程序中使用了”缓存“技术。所以在java中所有使用”双引号“括起来的
            字符串都会在”字符串常量池“中创建一份，字符串常量池在方法区中被储存
            3.在程序在此过程中，如果程序用到某个字符串，例如"abc"，那么程序会在字符串常量池中去搜索该字符串，如果没有找到
            则在字串发常量池中新建一个”abc“字符串，如果找到就直接拿过来用（字符串常量池是一个缓冲区，为了提高访问字符串的效率）


     */
    public static void main(String[] args) {

        //创建一个”abc“字符串对象，该对象的内存地址，该s1变量保存。
        String s1 ="abc";

        //可以让s1重新指向吗？s1 是局部变量，s1前边没有final，所有是s1可以重新指向。
        //但是"def"字符串本身不可变的
        s1 = "def";// 可以的

        String s2 ="Hello";//在字符串常量池中新建一个”Hello“字符串对象，该对象不可变
        String s3 ="Hello";//从字符串常量池中直接拿来用

        System.out.println(s2==s3);//  true,上面一样是因为地址一样

        //比较两个字符串是否相等，不能用”==“
        String s4 = new String("abc");
        String s5 = new String("abc");//新建了一个在堆里

        System.out.println(s4 == s5);// false

        //比较两个字符串是否一致，必须使用String类提供的equals方法
        System.out.println(s4.equals(s5));// true

        //以下程序执行结束之后，会在字符串常量池中创建3个字符串对象
        //“aaa” "bbb" "aaabbb"
        String s6 = "aaa";
        String s7 = "bbb";
        String s8 = s6 + s7;
        System.out.println(s8);//生成一个新的




    }


}

test02

package commonClass.String;

/*
    分析以下程序创建字符串的对象的区别
        1. String s1 = "abc"； 只会在字符串常量池中创建一个"abc"字符串对象

        2. s2 = new String("hello"); 会在字符串常量池中创建一个“hello”字符串对象，并且会在堆中再创建一个字符串对象。

        第二种方式比较浪费内存。常量是第一种方式。
 */

public class StringTest02 {
    public static void main(String[] args) {

        String s1 ="abd";
        String s2 = new String("abc");//需要创建2个对象，分别是在heap和方法区




    }
}

test03

package commonClass.String;

/*
    面试题
 */

public class StringTest03 {
    public static void main(String[] args) {

        //判断以下程序创建了几个对象？
        //堆中2个
        //方法区字符串常量池中1个，所以一个3个
        String s1 = new String("Hello");
        String s2 = new String("Hello");
        //通过以上分析，使用String时，不建议使用new 关键字，因为使用new会创建2个对象
        

    }

}

test04

package commonClass.String;

/*
    使用String的时候我们应该注意的问题： 尽量不要做字符串频繁的拼接操作。
    因为字符串一旦创建不可改变，只要频繁拼接，就会再字符串常量池中创建
    大量的字符串对象，给垃圾回收带来问题。
 */

public class StringTest04 {
    public static void main(String[] args) {

        String[] ins = {"sport", "music", "food", "sleep"};

        //要求将上面的兴趣爱好拼接成一个字符串“sport,music,food,sleep"

        String temp = "";
        for (int i = 0; i < ins.length; i++) {
            if (i==ins.length-1){
                temp += ins[i];

            }else{
                temp += ins[i] +",";
            }


        }
        System.out.println(temp);
    }
}

test05

package commonClass.String;

/*
    关于字符串常用方法
 */

public class StringTest05 {
    public static void main(String[] args) {

        //1.
        String s1 = "abc";

        //2.
        String s2 = new String("abc");

        //3.
        byte[] bytes = {97,98,99,100};
        String s3 = new String(bytes);
        System.out.println(s3);//abcd String 已经重写了object 中的toString

        //4
        String s4 = new String(bytes,0,2);
        System.out.println(s4);// ab，从0开始长度是2

        //5.
        char[] c1 = {'我','是','中','国','人'};
        String s5 = new String(c1);
        System.out.println(s5);

        //6.
        String s6 =new String(c1,2,2);//下标从2开始，长度是2
        System.out.println(s6);//中国
    }
}

test06 字符串常用的方法

package commonClass.String;

/*
    字符串常用的方法
 */

import java.sql.SQLOutput;

public class StringTest06 {
    public static void main(String[] args) {

        //1. char charAt(int index);
        String s1 = "阿巴阿巴阿巴";
        char c1 = "abcdef".charAt(2);
        char s2 = s1.charAt(2);
        System.out.println(c1);//c
        System.out.println(s2);//阿

        //2. boolean endsWith(String endStr);
        System.out.println("HelloWorld.java".endsWith("java"));//true
        System.out.println("HelloWorld.java".endsWith("HelloWorld.java"));//true
        System.out.println("HelloWorld.java".endsWith("阿巴阿巴"));//false
        System.out.println("HelloWorld.java".endsWith("java "));//false

        //3. boolean equalsIgnoreCase(String anotherString);将此String与另一个String 比较，不考虑大小写
        System.out.println("abc".equalsIgnoreCase("ABc"));//true

        //4.byte[] getBytes() 使用平台的默认字符集此String编码为byte 序列，并将结果储存到一个新的byte数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);//97.98,99

        }

        //5. int indexOf(String str); 放回指定子字符串在此字符串中第一次出现处的索引
        System.out.println("http；//192.168.1.100.8080/oa/login.action?username=jack&pwd=123".indexOf("/oa"));//判断/oa第一次出现这此字符串的位置

        //6. int indexOf(String str, int fromIndex);
        System.out.println("javaoraclec++javavb".indexOf("java",1));//13,从字符串1开始算，也就是a开始算，果然不加，那就是0，一个开头就有java这个字符串了

        //7. int lastIndexOf(String str)
        System.out.println("javaoraclec++javavb".lastIndexOf("java"));//13,最后一次出现的位置

        //8. int lastIndexOf (String str, int fromIndex)
        System.out.println("javaoraclec++javavb".lastIndexOf("java",1));//0 ,从制定的下标开始反向搜索，也是从1开始往0走，搜索“java“出现的位置

        //9. int length();
        System.out.println("abc".length()); // 数组中length 是属性，String 是length()方法

        // 10. String replaceAll(String s1, String s2);
        System.out.println("javaoraclec++javavb".replaceAll("java","mysql"));// 把java 替换成mysql输出， 这个程序是4个字符串

        //11. String[] split(String s); //分割
        String MyTime = "2008,08,08";
        String [] ymd = MyTime.split(",");//建立一个数组，然后用逗号分割
        for (int i = 0; i < ymd.length; i++) {
            System.out.println(ymd[i]);

        }//输出是2008  下一次循环再输出08 ，然后08
        
        //12. boolean statsWith(String s);
        System.out.println("/system/login.action".startsWith("/"));// true, 判断里面是否有指定的字符串

        //13. String substring(int begin); // 截取字符串的
        System.out.println("/oa/login.action".substring(3));//截取3后面的字符串（从3开始）

        //14. String substring(int beginIndex, int endIndex); 从这里开始到那里结束
        System.out.println("/oa/login.action".substring(4,9));// 截取从4到8的，不包含9

        //15. char[] toCharArray();//char数组，将字符串分解成一个个char，然后用数组储存起来
        char[] c2 = "我是周骏腾".toCharArray();
        for (int i = 0; i <c2.length ; i++) {
            System.out.println(c2[i]);


        }

        //16， 转换成大写
        System.out.println("Peter".toUpperCase());

        //17.转换为小写
        System.out.println("PeTER".toLowerCase());

        //18.String trim(); 去除前后空白,但不能去除中间的
        System.out.println("     A      b      c   ".trim());

        //19. String valueOf(Object obj);
        Object o = new Object();
        System.out.println(s1);//不会，因为并不是直接调用toString方法，String,valueOf(Object)这个方法对空值进行处理了

        System.out.println(String.valueOf(o));
        //System.out.println(o.toString()); 这个会出现空指针异常




    }
}

StringTest07

package commonClass.String;

/*
    正则表达式
        1.正则表达式是一门独立的学科
        2.正则表达式是一种字符模型,专门做字符串格式匹配的。

        例如： 正则表达式"a[2]$", 表示 2个a字符，等同于"aa"

        \d 数字
        \D 非数字
        \w 英文字母
        \W 非英文字母


 */

public class StringTest07 {
    public static void main(String[] args) {

        System.out.println("aa".matches("^a[2]$"));//false,

        String s1 = "asdd33dfsdaf33ddsd55fdd3dssf4343sdf455ddsddh565gggh55ddhg";


        //将dd替换为"中"
        System.out.println(s1.replaceAll("dd","中"));

        //将dd替换为"中"
        System.out.println(s1.replaceAll("d(2)","中"));

        //将数字替换为"中"
        System.out.println(s1.replaceAll("\\d","中"));

        //将非数字替换为"中"
        System.out.println(s1.replaceAll("\\D","中"));
    }

}