API总结1

字符串（String）是一个特殊的对象

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

String s2=new String(“abc”);s1在内存中有一个对象，s2在内存中有两个对象。

String类覆写了Object类中的equals方法，该方法用于判断字符串是否相同。

1，获取。

    1.1 字符串中的包含的字符数，也就是字符串的长度。

        int length():获取长度。

    1.2 根据位置获取位置上某个字符。

        char charAt(int index):

    1.3 根据字符获取该字符在字符串中位置。

int indexOf(int ch):根据ASCII表返回的是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不在字符串中存在。

        所以，也可以用于对指定判断是否包含。

        if(str.indexOf("aa")!=-1)

而且该方法即可以判断，有可以获取出现的位置。

2.2 字符中是否有内容。

        boolean isEmpty(): 原理就是判断长度是否为0.

    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[],offset,count):将字符数组中的一部分转成字符串。Offset是起始位，count是个数。

静态方法：

                static String copyValueOf(char[]);返回指定数组中表示该字符序列的String。

                static String copyValueOf(char[] data, int offset, int count)

static String valueOf(char[]):返回一个char数组参数的字符串表现形式。

3.2 将字符串转成字符数组。**

        char[] toCharArray():

3.3 将字节数组转成字符串。

            String(byte[])

            String(byte[],offset,count):将字节数组中的一部分转成字符串。

    3.4 将字符串转成字节数组。

            byte[]  getBytes():

    3.5 将基本数据类型转成字符串。

        static String valueOf(int)

        static String valueOf(double)

 

        //3+"";//String.valueOf(3);

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

4，替换

    String replace(oldchar,newchar);如果要替换的字符不存在，返回的是原串。

5，切割

    String[] split(regex);

6，子串，获取字符串中的一部分。

    String substring(beginIndex);

    String substring(beginIndex,endIndex);//包含头，不包含尾。

7，转换，去除空格，比较。

    7.1 将字符串转成大写或则小写。

         String toUpperCase();

         String toLowerCase();

7.2 将字符串两端的多个空格去除。

        String trim();

7.3 对两个字符串进行自然顺序的比较。

        int compareTo(string);

自己实现trim功能：

 

class MyTrimTest

{

    public static void main(String[] args)

    {

        String s=" ";

        sop("s="+s);

        s=myTrim(s);

        sop("s="+s);

    }

    public static String myTrim(String str)

    {

        int start=0;

        int end=str.length()-1;

        while(start<=end&&str.charAt(start)==' ')

            start++;

        while(start<=end&&str.charAt(end)==' ')

            end--;

        return str.substring(start,end+1);

    }

            public static void sop(Object obj)

            {

                System.out.println(obj);

            }

}

判断一个字符串中出现子串的次数：

class StringTest5

{

    public static void main(String[] args)

    {

        String s="ahhsfjsfsffjjjhhadahhasdwhh";

        int count=getSubcount(s,"hh");

        System.out.println("count="+count);

    }

    public static int getSubcount(String str,String key)

    {

        int count=0;

        int index=0;

        while((index=str.indexOf(key))!=-1)

        {

            str=str.substring(index+key.length());

            count++;

        }

        return count;

    }

}

从两个字符串中获取最大子串：

class StringTest3

{

    public static void main(String[] args)

    {

        String s1="dsfhsgdahfbkfhak";

        String s2="sgdah";

        String s3=getMaxSubstring(s1,s2);

        System.out.println(s3);

    }

    public static String getMaxSubstring(String s1,String s2)

    {

        String max="";

        String 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);

                if(max.contains(temp))

                return temp;

            }

        }

        return "";

    }

}

StringBuffer是字符串缓冲区，是一个容器。

特点：

1，长度是可变化的。

2，可以字节操作多个数据类型。

3，最终会通过toString方法变成字符串。

C create U update R read D delete

1、存储。

    StringBuffer append():将指定数据作为参数添加到已有数据结尾处。

    StringBuffer insert(index,数据):可以将数据插入到指定index位置。

2、删除。

    StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。

    StringBuffer deleteCharAt(index):删除指定位置的字符。

清空缓冲区：sb.delete(0,sb.length());

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)

Eg：       

StringBuilder sb = new StringBuilder("abcdef");

        char[] chs = new char[6];

sb.getChars(1,4,chs,1);//将

for(int x=0; x<chs.length; x++)

        {

sop("chs["+x+"]="+chs[x]+";");

        }

JDK1.5 版本之后出现了StringBuilder.

StringBuffer是线程同步。

StringBuilder是线程不同步。

以后开发，建议使用StringBuilder

升级三个因素：

1，提高效率。

2，简化书写。

3，提高安全性。

基本数据类型对象包装类：

基本数据类型对象包装类。

 

byte    Byte

short   short

int     Integer

long    Long

boolean Boolean

float   Float

double  Double

char    Character

 

基本数据类型对象包装类的最常见作用，

就是用于基本数据类型和字符串类型之间做转换

 

基本数据类型转成字符串。

基本数据类型+""

基本数据类型.toString(基本数据类型值);

如： Integer.toString(34);//将34整数变成"34";

字符串转成基本数据类型。

xxx a = Xxx.parseXxx(String);

 

    int a = Integer.parseInt("123");

 

    double b = Double.parseDouble("12.23");

 

    boolean b = Boolean.parseBoolean("true");

 

    Integer i = new Integer("123");

 

    int num = i.intValue();

 

十进制转成其他进制。

    toBinaryString();

    toHexString();

    toOctalString();

 

其他进制转成十进制。

    parseInt(string,radix);如parseInt（“110”，2）；