String_java

String构造方法

package com.bjpowernode.javase.string;
/*
   String 表示引用数据类型
   在java 中用双引号括起来的就是一个字符串对象
   并且双引号括起来的字符串是不可以变的 从出生到死亡都不可以变化
   字符串存储在“字符串常量池”里

   为什么SUM 把字符转存储在一个字符串常量池中
     因为String 使用太过于频繁了
 */

public class StringTest01 {
    public static void main(String[] args) {
        // 这两行表示在jvm中  创建了三个对象
        String s1="abc";
        String s2="abc"+"bef";

        String s3=new String("abc");
        // new String 是在堆内存中存储
    }
}

package com.bjpowernode.javase.string;

public class StringTest02{
    public static void main(String[] args) {
        String s1="aa";
        String s2="aa";
        System.out.println(s1==s2);  // true
        // 说明s1和s2在栈中的地址直接指向了方法区中的常量 并且== 比较的是两个字符串中的内存地址

        String a1=new String("123");
        String a2=new String("123");
        System.out.println(a1==a2); // false
        // 说明a1和a2 在栈中的地址先指向堆中（堆中创建了对象）堆中地址再指向方法区中的常量
        // 结论：比较字符串不应该用==来比较  应该使用equals来比较
        System.out.println(a1.equals(a2));


        int i=100;
        // 解释：i存储在堆中 并且堆中保存的不是地址  它保存的就是这个100
        String s="abc";
        // 但String在堆中保存的是一个地址  字符串“abc“是保存在方法区中 通过堆中的地址区访问”abc“
    }
}

package com.bjpowernode.javase.string;

public class StringTest03 {
    public static void main(String[] args) {
        String s1="abc";
        System.out.println(s1);



        byte[] bytes={97,98,99};
        String s2=new String(bytes);
        // 输入引用 会默认引用toSting() 应该输入的是一个内存地址
        System.out.println(s2); // abc
        // 说明在String 类中已经将toSring()方法重写了

        String s3=new String(bytes,1,2);
        System.out.println(s3);

        char[] chars={'我','是','中','国','人'};
        String s4=new String(chars,1,3);
        System.out.println(s4);



    }
}

String类中所包含的方法

package com.bjpowernode.javase.string;

import java.nio.charset.StandardCharsets;

public class StringTest04 {
    public static void main(String[] args) {
        // charAt(int index)
        char c="中国人".charAt(1);
        System.out.println(c);

        // 	compareTo(String anotherString
        int ret1="abc".compareTo("abc"); // 0 相等
        System.out.println(ret1);
        int ret2="abcd".compareTo("abce");// -1 小于
        System.out.println(ret2);
        int ret3="acb".compareTo("abc");// 1  大于
        System.out.println(ret3);

        // compareToIgnoreCase(String str)
        int a1="abcdigf".compareToIgnoreCase("abcfaofi");
        System.out.println(a1);

        // concat(String str)
        // 将指定的字符串连接到该字符串的末尾
        String s1="abc";
        String s2="bds";
        String s3=s1.concat(s2);
        System.out.println(s3);

        // contains(CharSequence s)
        // 判断两个字符串是否为包含关系  包含为ture
        String s4="abcdef";
        String s5="ab";
        System.out.println(s4.contains(s5));

        // endsWith(String suffix)
        // 测试此字符串是否以指定的后缀结尾
        String s6="abcd";
        String s7="jkajfl";
        System.out.println(s6.endsWith("cd"));
        System.out.println(s7.endsWith("fl"));

         // 	getBytes()
        //  将你需要的字符串提取出来
        String a2="abc";
        byte[] arr=a2.getBytes();
        System.out.println(arr[1]);

        // indexOf(String str)
        // 判断第一个字符串出现的下标
        String a3="akdfaojfoajsfd";
        int b=a3.indexOf("f");
        System.out.println(b);

        // isEmpty()
        // 判断字符串是否为0
        String a4="dcsad";
        System.out.println(a4.isEmpty());

        // 	lastIndexOf(String str)
        // 判断最后的字符的下标
        String a5="skaasjfafjdo";
        System.out.println(a5.lastIndexOf("o"));

        // replace(CharSequence target, CharSequence replacement)
        // 字符串的修改
        String a6="akafdjaofj";
        String a7=a6.replace("aka","afkdjf");
        System.out.println(a7);

        // split(String regex)  字符串的拆分
        String a8="1990-12-2=3";
        String[] aa=a8.split("-");
        for(int i=0;i<aa.length;i++)
        {
            System.out.println(aa[i]);
        }
        String[] bb=aa[2].split("=");
        for(int i=0;i<bb.length;i++)
        {
            System.out.println(bb[i]);
        }

        // startsWith(String prefix)
        //测试此字符串是否以指定的前缀开头
        String c2="abfksafj";
        boolean b1=c2.startsWith("b");
        System.out.println(b1);

        // substring(int beginIndex)
        //返回一个字符串，该字符串是此字符串的子字符串。 截取字符串
        String b2="kdsfjaofjao";
        System.out.println(b2.substring(3,5));

        // toCharArray()
        //将此字符串转换为新的字符数组
        String b3="我是中国人";
        char[] cc=b3.toCharArray();
        for(int i=0;i<cc.length;i++)
        {
            System.out.println(cc[i]);
        }

        // toLowerCase()
        //将所有在此字符 String使用默认语言环境的规则，以小写。
        String b4="AFAJOG";
        System.out.println(b4.toLowerCase());
        // toUpperCase()
        //将所有在此字符 String使用默认语言环境的规则大写
        String b5="fjaojgfioas";
        System.out.println(b5.toUpperCase());

        // 	trim()
        //返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。

        String b6="     nihao     nihao ";
        System.out.println(b6.trim());

        // String 中只有一个方法是静态的 不需要new 对象
        // valueOf(boolean b)
        //返回 boolean参数的字符串 boolean形式。
        String b7=String.valueOf(true);
        System.out.println(b7);
    }
}

StringBuffer的用法

package com.bjpowernode.javase.Stringbuffer;
/*
   我们在实际的开发中，如果需要频繁进行字符串拼接，会出现什么问题？？？
   在java 中 每进行一次字符串拼接 都会在方法区中的字符串常量里存一次
   并且在堆内存中也会有一个地址
   这样很浪费空间
 */
public class StringBuffer {
    public static void main(String[] args) {
        String s="";
        for(int i=0;i<100;i++)
        {
            s=s+i;
            System.out.println(s);
        }
    }
}

进行字符串的追加

package com.bjpowernode.javase.Stringbuffer;
/*
   如果以后需要进行大量的字符串拼接 建议使用JDK中自带的
       java.lang.StringBuffer
       java.lang.StringBuilder
 */
public class StringBufferTest02 {
    public static void main(String[] args) {
        StringBuffer stringBuffer=new StringBuffer();
        // append(char c)
        //将 char参数的字符串表示附加到此序列。(进行字符串的追加)
        char[] chars={'a','b','c','d'};
        stringBuffer=stringBuffer.append(chars,1,2);
        char charss=stringBuffer.charAt(1);
        System.out.println(charss);

        // StringBuffer(CharSequence seq)
        //构造一个包含与指定的相同字符的字符串缓冲区 CharSequence 。
        StringBuffer sb=new StringBuffer(100);
        sb.append('a');
        StringBuffer aa=sb.append('b');
        System.out.println(aa);
        


    }
}

StringBuilder的用法

• 这个跟StringBuffer的用法差不多

package com.bjpowernode.javase.Stringbuffer;
/*
java.lang.StringBuilder

   StringBuffer和StringBuilder的区别
   StringBuffer中的方法都有synchrnized 关键字修饰 表示StringBuffer在多线程环境下运行是安全的
   而StringBuilder中没有这个关键字 表示StringBuilder在多线程环境下是不安全的
 */
public class StringBuilderTest01 {
    public static void main(String[] args) {
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append(100);
        stringBuilder.append('n');
        StringBuilder ss=stringBuilder.append("niaho");
        System.out.println(ss);

    }
}

8种数据类型的包装类

package com.bjpowernode.javase.integer;
/*
    Byte  Short Integer Long Float Double Boolean Character
 */
public class IntegerTest02 {
    public static void main(String[] args) {
        Integer integer=new Integer(122);
        System.out.println(integer.toString());
        Integer integer1=new Integer("123");
        System.out.println(integer1);
    }

}

• 自动拆箱 自动装箱

package com.bjpowernode.javase.integer;

public class IntegerTest04 {
    public static void main(String[] args) {
        // 自动装箱
        // int自动转换为Integer类型
        Integer i=100;
        System.out.println(i);
        // 自动拆箱
        // Integer类型自动转换为int类型
        int a=i;
        System.out.println(a);
    }
}