Java基础 String StringBuffer StringBuilder

String

实现String.trim()和 翻转字符串顺序。

class StringTest
{
    public static void main(String[] args)//throws Exception
    {
        MyString str=new MyString("1234567890");
        //System.out.println(str.trim());
        System.out.println(str.reverse(1,5));
    }
}
class MyString
{
    private String str="";
    MyString(String str)
    {
        this.str=str;
    }

    public String trim()//去除字符串开头和末尾的空白
    {
        int start=0,end=str.length()-1;
        while(start<end)
        {
            if(str.charAt(start)==' ')
                start++;
            if(str.charAt(end)==' ')
                end--;
            if(str.charAt(start)!=' '&&str.charAt(end)!=' ')
                break;
        }
        return str.substring(start,end+1);
    }

    public String reverse()//throws Exception//倒序排列字符串
    {

        return reverse(0,str.length()-1);

    }
    public String reverse(int start,int end) //throws Exception//倒序排列字符串
    {
        char[] carr=str.toCharArray();
        reverseArr(carr,start,end);
        return String.valueOf(carr);
    }
    private void reverseArr(char[] carr,int s,int e)/* throws Exception *///倒序排列字符数组
    {
/*      if(s<0||s>=carr.length-1)
            throw new Exception("start超出字符串边界!");
        if(e<=0||e>(carr.length-1))
            throw new Exception("end超出字符串边界!"); */
        for(int start=s,end=e;start<end;start++,end--)
        {
            swap(carr,start,end);
        }
    }
    private void swap(char[] carr,int start,int end)//交换数组元素
    {
        char tmp=carr[start];
        carr[start]=carr[end];
        carr[end]=tmp;
    }
}

---

获取字符串1和字符串2中相同的最大字符串。在教程的基础上进行了优化。

• 原视频,x,y,z分别改为 wide,start,end.更加好理解.
• 原视频教程当发现第一个相同的最大字符串时使用return结束搜索.
• 优化后，把return改为wide=0.可以继续在当前搜索宽度继续搜索.
  而不继续向更窄范围搜索.

class StringTest2
{
    private static String str1="okhelloko";
    private static String str2="ok,ko";

    public static void getMaxSubString(String s1,String s2)//获取字符串1和字符串2中相同的最大字符串,如果有相同字数的相同字符串,也找出.
    {
        String max="",min="";
        max=(s1.length()>s2.length())?s1:s2;
        min=(max==s1)?s2:s1;
        for(int wide=min.length();wide>0;wide--)//字符串宽度,逐渐缩小,wide代表搜索的字符串宽度//每循环一次搜索区变小一个字符.代表搜索的字符串宽度变小
        {
            for(int start=0,end=wide;end!=min.length()+1;start++,end++)//start代表搜索区起点,end代表搜索区终点.终点不超过字符串长度
            {                                                       //将起点,终点向字符串末尾移动.代表搜索区从左向右进行移动.
                String temp=min.substring(start,end);//temp是当前搜索区内的字符串
                if(max.contains(temp))//如果max长字符串包含 当前在min短字符串内 搜索区的temp字符串，就找到了最长的相同字符串.
                {
                    System.out.println(temp);
                    wide=0;//这里使用wide=0结束外循环,而不用return结束循环,因为要把当前宽度的搜索区继续搜索到最后.否则,发现第一个时会忽略掉之后的.
                    //当内循环结束,到外循环时,由于wide==0，就不继续进行更小范围的搜索了。
                }

            }
        }
    }
    public static void main(String[] args)
    {
        getMaxSubString(str2,str1);
    }
}
/*输出结果:
ok
ko
*/

---

StringBuffer

构造方法摘要
StringBuffer()
构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。

StringBuffer(CharSequence seq)
public java.lang.StringBuilder(CharSequence seq) 构造一个字符串缓冲区，它包含与指定的 CharSequence 相同的字符。

StringBuffer(int capacity)
构造一个不带字符，但具有指定初始容量的字符串缓冲区。

StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

常用方法:
追加文本
StringBuffer append(data)
删除指定范围的文本
StringBuffer delete(int start,int end)
删除指定标号的字符
StringBuffer deleteCharAt(int index)
根据标号获取字符
char charAt(int index)
根据指定范围 获取字符列表,存到dst字符列表的dstBegin位置
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
获取字符串的位子
int indexOf(String str)
插入字符串
StringBuffer insert(int offset, data)
获取字符串长度
int length()
替换字符串
StringBuffer replace(int start, int end, String str)
翻转字符串
StringBuffer reverse()
替换指定位置的字符
void setCharAt(int index, char ch)
获取子文本
String substring(int start)
String substring(int start, int end)
返回文本类型
String toString()

---

StringBuilder

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

将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。

构造方法摘要
StringBuilder()
构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。
StringBuilder(CharSequence seq)
构造一个字符串生成器，包含与指定的 CharSequence 相同的字符。
StringBuilder(int capacity)
构造一个其中不带字符的字符串生成器，初始容量由 capacity 参数指定。
StringBuilder(String str)
构造一个字符串生成器，并初始化为指定的字符串内容。

Integer

static int parseInt(String s, int radix)
使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
Integer.parseInt(“1010”,2)
将字符串”1010”中的数字按照2进制转换为10进制数.
第一个参数指定被转换的数，第二个参数指定进制.
Integer.parseInt(“f”,16)

Integer.parseInt(“11”,17)按照17进制转换”11”
得到17+1=18

Integer m=128;
Integer n=128;
boolean b=(m==n);

b==false

Integer a=127;
Integer b=127;
boolean b=(a==b);

b==true

因为Integer定义变量时先判断值的大小，值在byte范围内就使用内存中的byte数据,所以a和b指向同一个数据
而m,n的值大于byte的范围，所以在内存中开辟了新的空间给两个变量。所以不相等。