黑马程序员——基础知识总结_String类

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

                第一话：String类中张常见方法

概述：

字符的操作对于任何一门语言来说都是最基础的，能够自由操作字符与字符串是我的追求。在将万物都视为对象的java中，字符串也被封装在String类中。相对于其他对象，String对象要是被创建就无法被改变，我们对String中字符的任意操作都会新构建一个String对象。

常见获取方法：

//获取字符串长度
int length()
//获取字符串在下标为index时的字符
char charAt(int index)
//返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索 
  int indexOf(int ch, int fromIndex)
  //返回指定子字符串在此字符串中第一次出现处的索引
 int indexof(String str)
 //返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
 int indexof(String str,int fromIndex)
  //返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 
  int indexOf(int ch, int fromIndex) 

常见判断方法：

//将此字符串与指定的对象比较。
boolean equals(String str)

//当且仅当 length() 为 0 时返回 true
boolean isEmpty()

//测试此字符串是否以指定的前缀开始
boolean startWith(String str)

//测试此字符串是否以指定的后缀结束。
boolean endWith(String str)

//当且仅当此字符串包含指定的 char 值序列时，返回 true
boolean contains(CharSequence s) 

常见转换方法：

//分配一个新的String使其表示字符数组参数中当前包含的字符序列String
String (char[] value)

// 分配一个新的String，它包含取自字符数组参数一个子数组的字符
String (char[],offset,count)

//通过使用平台的默认字符集解码指定的byte数组，构造一个新的 String
String (byte[] bytes)

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

//返回指定数组中表示该字符序列的 String
static String copyValueOf(char[] data, int offset, int count)

//返回 char 数组参数的字符串表示形式。
static String valueOf(char[] data) 

//返回 int 参数的字符串表示形式
static String valueOf(int i)

//返回 double 参数的字符串表示形式
static String valueOf(double b)

//将此字符串转换为一个新的字符数组
char[] toCharArray();

//使用平台的默认字符集将此 String 编码为 byte 序列，并将结果          //存储到一个新的 byte 数组中
byte[] getByte()

常见替换方法：

// 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现     //的所有 oldChar 得到的 
 String replace(char oldChar, char newChar) 

常见字符串切割：

//根据给定正则表达式的匹配拆分此字符串
String[] split(String regex) 

//根据匹配给定的正则表达式来拆分此字符串      
String[] split(String regex, int limit) 

//返回一个新的字符串，它是此字符串的一个子字符串
 String substring(int beginIndex) 

//返回一个新字符串，它是此字符串的一个子字符串       
String substring(int beginIndex, int endIndex)

常用方法：

//使用默认语言环境的规则将此String中的所有字符都转换为大写
String toUpperCase()

//使用默认语言环境的规则将此String中的所有字符都转换为小写
String toLowerCase()

//返回字符串的副本，忽略前导空白和尾部空白
String trim()

//按字典顺序比较两个字符串
int compareTo(String str)

                      第二话：String容器

StringBuffer：

StringBuffer是字符缓冲区。他具有以下几个特点：
1.是一个容器且长度可变
2.可以操作多个数据类型
3.最终会通过toString方法变成字符串
相应的操作方法：

添加：
//追加 Object 参数的字符串表示形式
StringBuffer append(Object obj)

//将 char 参数的字符串表示形式插入此序列中
StringBuilder insert(int offset, char c) 

删除：
//移除此序列的子字符串中的字符
StringBuffer delete(int start, int end) 
获取：
//返回此序列中指定索引处的char值
char charAt(int index)

//返回第一次出现的指定子字符串在该字符串中的索引
int indexOf(String str)

//从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引
int lastIndexOf(String str)

//返回长度
int length()

//返回一个新的 String，它包含此序列当前所包含的字符子序列
String substring(int start, int end)

修改：
//将给定索引处的字符设置为 ch
void setCharAt(int index, char ch)

//使用给定 String 中的字符替换此序列的子字符串中的字符
StringBuffer replace(int start, int end, String str) 

反转：
//将此字符序列用其反转形式取代
StringBuffer reverse()

StringBuilder:

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

String类小练习：

public class StringTest
{
    public static void main(String[] args)
    {
        String s1 = "abc";
        //new 表示有创建了一个对象
        String s2 = new String("abc");  
        String s3 = "abc";
        //true s2 是指向在字符串池中的“abc”对象
        System.out.println(s1==s2);    
        System.out.println(s1==s3);   //false 
        //true因为String重写了Object中的equals方法，该功能为判断字符串对象中的字符数组是否一样
        System.out.println(s1.equals(s2));   
        }

    }

结果图：

字符匹配：

/*字符串另一个字符串中最大相同子串*/


class minINmax
{
    public static void main(String[] args)
    {
        String s1 = "jakdjfhellokajc";
        String s2 = "njkhelloa";
        //输出结果
        System.out.println(new minINmax().getString(s1,s2));
    }
    private String getString(String s1, String s2)
    {
        //创建字符对象
        String str = "";
        //外层循环遍历较短字符串   
        for(int i = 0; i < s2.length(); i++)
        {       
            //第二层循环左右移动，寻找存在的最大匹配串
            for(int y = 0,z = s2.length()-i; z != s2.length()+1; y++,z++ )
                {
                    //将在y，z间的字符传给Str
                    str = s2.substring(y,z);
                    //打印str
                    System.out.println(str);
                    //判断str是否被S1包含
                    if(s1.contains(str))
                                    return str;

                }

            }
                return "";
            }
}

结果图：

自定义去除字符串前后的空格：

class MyTrim
{
        public static void main(String[] args)
        {
            String s1 = "   hallo word   ";

            System.out.println("原字符串:"+s1);
            //调用trim()方法
            System.out.println("trim后的字符串:"+s1.trim());
            System.out.println("mytrim后的字符串:"+new MyTrim().mytrim(s1));
            }
            String mytrim(String s)
            {
            //  String s1 = s;
            int begin = 0;
            //s.length() - 1为了防止脚标越界
            int end = s.length() - 1;
        //如果字符为空格则增加脚标，相当于向前移动
        while( (s.charAt(begin)==' ') && begin < end )
            {
                begin++;
            }
            //如果字符为空格则增加脚标，相当于向后移动
            while( (s.charAt(end)==' ') && end > begin)
            {
            end --;
            }
            //返回子串
            return s.substring( begin, end+1);
            }
    }

结果图：

小结：

String类的各种构造方法实际上封装了大部分的字符串操作，使得我们能够更方便的对字符串进行操作。这也是java简单易学的原因。对于String方法的掌握，我觉得通过练习来熟练是最好的方法了。