黑马程序员——Java基础---String

——- android培训、java培训、期待与您交流！ ———-

String类

package String;

public class Demo {

    public static void main(String[] args) {

        String s1="abc"; //s1是一个类类型变量，"abc"是一个对象
                        //字符串最大特点：一旦被初始化就不可以被改变

        String s2=new String("abc");
        /*
         *s1和s2的区别：
         *s1在内存中有一个对象，s2在内存中有两个对象。
         */

        System.out.println(s1.equals(s2));//String类复写了Object类中equals方法。该方法用于判断字符串是否相同
    }

}

String类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作

常见的操作：
1.获取
1.1 字符串中包含的字符串，也就是字符串的长度
int length():获取长度

1.2 根据位置获取位置上的某个字符。
char charAt(int index)

1.3根据字符获取该字符在字符串中位置
int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexOf(String str):返回的是Str在字符串中第一次出现的位置。
int indexOf(String str，int fromIndex):从fromIndex指定位置开始，获取Str在字符串中出现的位置。
int lastIndexOf(int ch): 反向索引

2.判断。
2.1 字符串中是否包含某一个子串 boolean contains(str)
特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1,表示该str不在字符串中，该方法既可以判断，也可以获取出现的位置。

2.2 字符串中是否有内容。 boolean isEmpty()
2.3 字符串是否是以指定内容开头 boolean startsWith(str)
2.4 字符串是否是以指定内容结尾。 boolean endsWith(str)
2.5 判断内容是否相同，复写了object类中equals方法。 boolean equals(str);
2.6 判断内容是否相同，并忽略了大小写。 boolean equalsIgnoreCase();

3.转换.
3.1 将字符数组转成字符串
构造函数 ： String(char[])
String(char[] ,offer,count):将字符数组中一部分转换成字符串。
静态方法：
static String copyValueOf(char[])
static String copyValueOf(char[] data,int offset,int count)

static String valueOf(char[])

3.2 将字符串转换成字符数组
char[] toCharArray()

3.3将字节数组转换成字符串。
String(byte[])

3.4 将字符串转换成字节数组。**
byte[] getBytes()

3.5 将基本数据类型转换成字符串
static String valueof(int)
static String valueof(double)

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4.替换
String replace(oldchar,newchar);

5.切割
String[] split(regex)

6.字串，获取字符串中的一部分
String substring(begin)
String substring(begin,end)
7.转换，去除空格，比较
7.1 将字符串转换成大写或者小写
String toUpperCase()
String toLowerCase()
7.2 将字符串两端的多个空格去除
String trim()
7.3 对两个字符串进行自然顺序的比较
int compareTo(String)

package String;

public class Demo {

    public static void main(String[] args) {

        //method_get();
        //method_is();
        //method_trans();
        //method_replace();
        //method_split();
         //method_sub();
         method_7();
    }
    public static void method_get()
    {
        String str="avasdfsdggh";

        //长度
        sop(str.length());

        //根据索引获取字符
        sop(str.charAt(4));

        //根据字符获取索引
        sop(str.indexOf('a'));
        sop(str.indexOf('a', 3));

        //反向索引
        sop(str.lastIndexOf('a'));


    }
    public static void method_is()
    {
        String str="avasdggh";
        //判断是否包含子串
        sop(str.contains("dgg"));

        //判断字符串中是否有内容
        sop(str.isEmpty());

        //判断是否以指定内同开头
        sop(str.startsWith("avas"));

        //判断是否以指定内同结尾
        sop(str.endsWith("ggh"));

        //判断两个字符串是否相同
        sop(str.equals("asdf"));

        //判断内同是否为空，并忽略了大小学
        sop(str.equalsIgnoreCase("avasDggh"));

    }
    public static void method_trans()
    {
        //字符数组变成字符串
        char[] arr={'a','g','s','r'};
        String s=new String(arr);
        sop(s);

        //将字符串变成字符数组
        String s1="sdfgg";
        char[] chs=s1.toCharArray();

        for(int x=0; x<chs.length; x++)
        {
            sop(chs[x]);
        }


    }
    public static void method_replace()
    {
        String s="hello java";
        String s1=s.replace("java","world");
        String s2=s.replace("hello java", "hello boy");
        sop(s1);
        sop(s2);


    }

    public static void method_split()
    {
        String s="zhangsan,lisi,wangwu";
        String[] arr=s.split(",");
        for(int x=0; x<arr.length; x++)
        {
            sop(arr[x]);
        }


    }
    public static void method_sub()
    {
        String s="abcdefs";
        sop(s.substring(3));//从指定位置到结尾
        sop(s.substring(0, 4));//包含头不包含尾
    }
    public static void method_7()
    {
        String s="   hello java";
        sop(s.toLowerCase());
        sop(s.toUpperCase());
        sop(s.trim());

        sop(s.compareTo("dads"));

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

}

练习一：

package String;
/*
 * 模拟一个trim方法，取出字符串两端的空格
 * 思路： 
 * 1.判断字符串第一个位置是否是空格，如果是继承向下判断，直到不是空格为止
 * 结尾处判断空格也是如此
 * 
 * 2.当开始和结尾都判断到不是空格时，就是要获取的字符串。
 */
public class MyTrim {

    public static void main(String[] args) {

        String s=" fkkk   ";

        int start =0,end=s.length()-1; //定义开始角标和最后角标
        //在开始角标小于等于末位角标并且开始角标等于空格的情况下，开始角标自增
        while(start<=end && s.charAt(start)==' ')
        {
            start++;
        }
        while(start<=end && s.charAt(end)==' ')
        {
            end--;
        }
        String y=s.substring(start,end+1);//取字串
        System.out.println(y);
    }

}

结果：

练习二：

package String;
/*
 * 将字符串反转
 * 
 * 思路：将字符串变成数组
 * 对数组反转
 * 将数组变成字符串
 */
public class reverseTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s="dssgga";
        //字符串变数组
        char[] chr=s.toCharArray();

        //反转数组
        reverse(chr);

        //将数组变成字符串
        String ss=new String(chr);
        System.out.println(ss);

    }
    //反转数组
    private static void reverse(char[] chr) {

        for(int start=0,end=chr.length-1; start<end; start++,end--)
        {
            change(chr,start,end);
        }
    }
    //将数组变成字符串
    public static void change(char[] chr,int x,int y)
    {
        char temp=chr[x];
        chr[x]=chr[y];
        chr[y]=temp;
    }

}

结果：

练习三：

package String;
/*
 * 获取一个字符串在另一个字符串中出现的次数
 *  "fasgdakkffaaf";
 * 思路：
 * 1.定义一个计数器
 * 2.获取kk第一次出现的位置
 * 3.从第一次出现的位置后剩余的字符串中继续获取kk出现的位置
 * 4.每次获取一次就计数一次
 * 5.当获取不到时计数完成
 */
public class StrCountTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="fasgdakkffaaf";
        String key="kk";

        int count=0;
        int index=0;
        while((index=str.indexOf(key))!=-1)
        {
            str=str.substring(index+key.length());
            count++;        
        }
        System.out.println(count);
    }

}

结果：

练习四：

package String;
/*
 * 获取两个字符串中最大的相同字串，第一个工作：将短的那个字串进行长度依次递减的字串打印
 * "abkidahellojaxv"
 * "cskhellobm"
 * 
 * 思路：1，将短的那个字串按照长度递减的方式获取到
 * 2.将每获取到的字串去长串张判断是否包含，如果包含，已经找到
 */
public class StringTest1 {

    public static void main(String[] args) {
        String s1="abkidahellojaxv";
        String s2="cskhellobm";
        System.out.println(getMaxSubString(s2, s1));
    }
    public static String getMaxSubString (String s1,String s2)
    {
        //定义大小值，提高效率，减少内存运行
        String max="",min="";
        max=(s1.length()>s2.length())?s1:s2;
        min=(max==s1)?s2:s1;
        //用嵌套循环判断字符是否相等
        for(int x=0; x<min.length(); x++)
        {
            for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)
            {
                String temp=min.substring(y,z);
                //System.out.println(temp);
                if(max.contains(temp))
                {
                    return temp;
                }

            }
        }
        return "";
    }


}

StringBuffer
StringBuffer是字符串缓冲区，是一个容器
特点：1.长度是可变化的
2.可以操作多个数据类型
3.最终会通过toString方法变成字符串。
1，存储：
StringBuffer append() :将指定数据作为参数添加到已有的数据结尾处
StringBuffer insert(index,数据）：可以将数据插入到指定index位置

2.删除：
StringBuffer delete(start,end)删除缓冲区中的数据，包含头不包含尾。
StringBuffer deleteCharAt(index):删除指定位置的字符。

3.获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String subString(int start,int end)

4.修改
StringBuffer replace (start,end,string)
void setCharAt(int index,char ch)

5.反转
StringBuffer reverse();

6.将缓冲区中指定数据存储到指定字符数组中
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

jdk1.5版本后出现了StringBuilder

StringBuffer是线程同步的
StringBuilder是线程不同步的

开发建议用StringBuilder

升级的三个因素：
1.提高效率
2.简化书写
3.提高安全性

基本数据类型对象包装类
byte Byte
short Short
int Integer
long Long
boolean Boolen
float Float
double Double
char Character

基本数据类型转换成字符串
基本数据类型+””
基本数据类型.toString(基本数据类型值)
如： Integer.toString(34) 34整数变成”34”
Integer i=new Integer(“123”)
int num=i.intValue()

字符串转成基本数据类型
xxx a=Xxx.parseXxx(String)

十进制转成其他进制
toBinaryString();
toHexString();
toOctalString()

其他进制转成十进制
ParseInt(Stirng,radix)

jdk1.5后出现的新特性
Integer x=4;//自动装箱
x=x+2;//进行自动拆箱，变成了Int类型，和2进行加法运算，再将和进行装箱赋给x.

Integer a=127;
Integer b=127;
System.out.println(a==b);//结果为true，因为a和b指向了同一个integer对象
//因为当数值在Byte范围内容，对于新特性，如果该数值已经存在，
//不会开辟新空间