String,StringBuffer,StringBuilder,基本数据类型包装类，一小部分eclipse快捷键

-

常用对象

String    

常用方法

1.Sting s =”abe”  String s1 =”abe”   s==s1 因为abe创建时，放在常量池中，当再次创建时，先看看常量池中有该变量，有的话，直接将该变量的地址付给s1

2.String s= String(byte[]a)：将字节，字符数组变为字符串。

3.字符串常用的方法：

         1.intlength():获取字符串长度

         2.charcharAt(int index)根据位置获取字符，从0开始

         3.intindexOf(int ch);根据字符获取第一次出现的位置从0开始

    4 public int indexOf(int ch,

                  int fromIndex)

        从fromIndex处开始找，ch出现的位置

    4 public int indexOf(String s)

        从头开始找，s出现的位置

 

    5 public int indexOf(string str,

                  int fromIndex)

        从fromIndex处开始找，str出现的位置

 

    6 public int lastIndexOf(int ch)

                       从后面开始找，ch出现的位置，如果不存在则返回-1；

    6 public int lastIndexOf(int ch，int fromIndex)

                       从fromIndex往后开始找，ch出现的位置

    6 public int lastIndexOf(String s)

                       从后面开始找，s出现的位置

    6 public int lastIndexOf(String s，int fromIndex)

                       从fromIndex往后开始找，s出现的位置

 

数个数从一开始，角标从零开始

 

7.获取字符串的子串：String substring(intbeginbindex,int lastIndex);包括前面的下标，不包括后面的下标。Index   lastindex-1

String substring(int beginbindex);从指定位置开始直到最后

转换

将字符串变成字符串数组（字符串的切割）

String[] split(String str); 

        String s ="张三,李四,王五"

        String[]  arr = s.split(",");

        String[]  arr = s.split("\\.");//需要转义字符,第一个\转义.第二个转义\

将字符串转为字符数组

        char[] a ="abdc".toCharArray();

将字符串转为字节数组

        byte[] b ="abce".getBytes();

大小写的转换："Abc".toUpperCase() ；变大写

        "AVC".toLowerCase();//变小写

将指定的字符替换

        String  replace(char oldchar, char newchar);

        String s1 ="abc"  String s2 =sq.replace('q','a'); s1=s2

去掉前后空格

               trim();

字符串的连接：

               concat();"abc".concat("dd");

 

 

字符串的判断：

        判断两个字符串内容是否相同

               booleanequals(Object obj);equalsIgnoreCase();

        字符串是否判断包含指定字符串

               "bbb".contains("bb");

        字符串是否以指定字符串开头。是否以指定字符串结尾

               Stringstr = "ArrayDemo.java";  

               System.out.prinln(str.startswith("Array"));

               System.out.prinln(str.endswith("Array"));

               System.out.prinln(str.contains("Array"));

        按字典顺序比较两个字符串谁大谁小

               intcompareTo(String anotherString);>0 =0  <0  两个字符串相减

1、trim()功能的实现

        publicstatic String MyTrim(String s){

               intstart = 0;

               intend = s.length()-1;

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

               {

                       start++;

               }

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

               {

                       end--;

               }

               returns.subString(start,end+1);

        }

2.得到最大子串

        publicstatic void String getMaxSubString(String s1,String s2)

        {

               for(inti = 0;i< s2.length ;i++)

                       for(inta = 0,b=s2.length-i;b!=s2.length()+1;a++,b++){

                               Stringsub = s2.subString(a,b);

                               if(s1.contains(sub))

                                      return;

                       }

        }

StringBuffer

StringBuffer ：就是字符串缓冲区

         用于存储数据的容器

         特点

                   1.长度是可变的

                   2.可以存储不同类型的数据

                   3.最终要转换成字符串进行使用

                   4.可以对字符串进行修改。

         容器的功能：

                   1.添加

                            append(data);返回值是StringBuffer

                            insert(index,data);返回值仍然是StringBuffer

                   2.删除

                            delete(intstart,int end);包括头不包含尾

                            deleteCharAt(intindex);删除指定位置的字符

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

                   3.查找

                            charAt(index)   indexOf(String)   lastIndexOf(String)

                   4.修改

                            replace(intstart, int end ,String str);将下标start<=  <=end-1处的字符

                            替换成str,返回时stringBuffer

                            voidsetCharAt(index,'d');将指定位置替换成指定字符

         其他方法

                  setLength()；用来设置字符串缓冲区的长度

                   reverse();用来反转字符串缓冲区的内容

                   StringBuffer(intcapacity)//可以提高效率

StringBuilder

         StringBuffer是线程同步的，通常用于多线程

         StringBuilder是线程不同步的，提高了缓冲区的效率，通常用于单线程

         简单应用：

                   publicstatic void arrayToString(int[] arr){

                            StringBuilder sb = newStringBuilder();

                            sb.append("[");

                            for(inti = 0;i< arr.length;i++){

                                     if(i!=arr.length-1){

                                               sb.append(arr[i]+",");

                                     }

                                     else{

                                               sb.append(arr[i]+"]");

                                     }

                            }

                   }

        

                  

    基本数据类型对象包装类

         为了方便操作基本数据类型，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作

         用于描述该对象的类称为基本数据类型对象的包装类

         byte  Byte

         shortShort

         intInteger

         longLong

         floatFloat

         doubleDouble

         charCharacter

         booleanBoolean

         Integer:

                   publicstatic int parseInt(String str);将字符串转为整数；还有一个：Integer.valueOf()

         基本类型--------》字符串

                   1.基本类型数值+""

                   2.用String类中的静态方法valueOf(基本类型)

                  

         字符串-------->基本类型

                   1.用包装类中的静态方法Xx.parseXxx("xxx类型的字符串")

                   2/3.用Integer的静态方法valueof();

         如果字符串被Integer进行对象的封装。

                   可以使用另一个非静态的方法，intValue()；讲一个Integer对象转换成基本数据类型

                   Integeri = new Integer("123"); int j = i.intValue();

                   整数具备不同的进制体现

                            十进制----->其他进制Integer.toBinaryString() 

                            Integer.toString(40,5);可以将40转为5进制

         将其他进制转为十进制

                   Integer.parseInt("34",16):将34看成16进制，进行转换成十进制

                   比较两个对象：Integera = new Integer("23"); Integer b= new Integer(2);

                            a.compareTo(b);10 -1

         类型的装箱：

                   Integeri = 4 ;1.5版本出现后，自动装箱 i = i + 6;自动拆箱

                   Integera = new Integer(128);

                   Integerb = new Integer(128);

                   System.out.println(a==b);//false两个对象地址不同

                   System.out.println(a.equals(b))//true，比较的是内容

                  

                   Integerx = 127;

                   Integery = 127;

                   Integerx1 = 128;

                   Integery1 = 128;

                  

                   System.out.println(x==y);//true;自动装箱，如果装箱的是一个字节，那么该         数据会被共享，不会开辟空间

                   System.out.println(x.equals(y))//true

                   System.out.println(x1==y1);//false，如果不是一个字节，则需要开辟新的空间

                   System.out.println(x1.equals(y1))//true，

      快捷键小计：

                   crtl+shift+x变大写转变   crtl+shift+y变小写

                   crtl+alt+方向键，向那个方向复制

                   crtl+shift+f自动排版

                   crtl+d删除一行

                   crtl+z恢复

                   crtl+c  crtl+d crtl+s保存

                   crtl+f  查找