黑马程序员---------笔记整理（java基础九-----String,StringBuffer,StringBuilder）

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

      We have a dream to be successful。

大纲：

String:

 1.1String方法 
 1.2String特点 
 1.3 StringBuffer 
 1.4 StringBuilder 
 1.5 Jdk升级的目的 
 1.6 基本数据类型对象包装类 
 1.7基本类型======>字符串 
 1.8 字符串=====>基本类型 
 1.9 整数具备不同的进制体现。 
 2.0自动拆装箱 
    面试题 

  挨个走一遍吧，Let's go.   

String:

    String对象的初始化
          由于String对象特别常用，所以在对String对象进行初始化时，Java提供了一种简化的特殊语法，格式如下：
              String s = “abc”;
              s = “Java语言”;
          其实按照面向对象的标准语法，其格式应该为：
                         String s = new String(“abc”);
                          s = new String(“Java语言”);
         只是按照面向对象的标准语法，在内存使用上存在比较大的浪费。例如String s = new String(“abc”);实际上创建了两个String对象，一个是”abc”对象，

         存储在常量空间中，一个是使用new关键字为对象s申请的空间。其它的构造方法的参数， 可以参看String类的API文档。

 1.1String方法 

获取

    获取字符串中字符的个数（长度）

    int length（）；

    根据位置获取字符

    char  charAt(int index);

    根据字符获取在字符串中的第一次出现的位置

    int  indexOf(int ch);【因为char类型可以转换成int（对应的是0---2^16），

    依据ASCII,返回-1时，表示这个字符不存在，此方法也可以判断字符是否存在。】

    从指定位置进行ch的查找第一次出现位置

    int indexOf(int ch,int fromIndex);

    根据字符串获取在字符串中的第一次出现的位置

    int indexOf(String str);

    从指定位置进行ch的查找第一次出现位置

    int indexOf(String str,int fromIndex)

 

    根据字符获取在字符串中的最后一次出现的位置

    int lastIndexOf(int ch)；

    从指定位置进行ch的查找最后一次出现位置

    int lastIndexOf（int ch，int fromIndex）；

    根据字符串获取在字符串中的最后一次出现的位置

    int latindexOf(String str);

    从指定位置进行ch的查找最后一次出现位置

    int lastindexOf(String str,int fromIndex)；

 

    获取字符串中一部分字符串，也叫子串

    String  subString（int beginIndex，int endIndex）；【包含begin，但不包含end】

    String substring（int beginIndex）；从beginIndex到最后

 

转换

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

    String []  split（String regex）：【里面的条件是一个正则表达式】

    将字符串变成字符数组

    char []   toCharArray();

    将字符串变成字节数组

    byte [] getBytes（）；

    将字符串中的字母转成大小写

    String toUpperCase（）；【大写】

    String toLowerCase（）；【小写】

    将字符串中的内容进行替换

    String replace（char oldch,char newch）;

    String replace(String s1,String s2);

    将字符串两端的空格去除

    String trim();

    将字符串进行连接

    String concat（String str）；

 

判断

    两个字符串内容是否相同

    boolean equals(Object obj);【复写Object的方法，所以传递的是Object对象】

    boolean equalsIgnoreCase(String str);忽略大写比较字符串内容。

    字符串中是否包含指定字符串

    boolean contains（String str）；

    字符串是否以指定字符串开头

    boolean startsWith(String str);

    boolean endsWith(String str);

 

比较

    比较字符串的顺序

    int compareTo(String anotherString);【返回有三种结果，大于、小于、等于，所以用int表示，分别为正数，

                                         负数，等于】

    int compareToIgnoreCase(String str);【忽略大小写】

 

其他

    String intern();

    如果池已经包含一个等于此String对象的字符串，则返回池中的字符串。否则，将此

    String对象添加到池中，并返回次String对象的引用。

    例如：

    String s1="abc";

    String s2=s1.intern();

    System.out.println(s1==s2);//true

    System.out.println(s1.equals(s2));//true

 1.2String特点        

     字符串对象一旦被初始化就不会被改变。

     String s="abc";//创建一个字符串对象在常量池中。

     创建字符串时，先到常量池中寻找，没有就建立，如果有，直接使用。

 
 1.3 StringBuffer 
     字符串缓冲区，用于存储数据的容器，

     特点：

          长度的可变的；

          可以存储不同类型的数据；

          最终要转成字符串进行使用；

          可以对字符串进行修改。

      方法:

添加：

StringBuffer append（data）；//data表示任意类型的数据

StringBuffer insert（int index，data）；//在index位置上添加任意类型的数据

删除：

StringBuffer delete（int start，int end）；//包含头，不包含尾

StringBuffer deleteCharAt（int index）；//删除指定位置的元素

查找：

char charAt（int index）；//查找指定位置的字符

int indexOf（String str）；//查找字符串在字符串中首次出现的位置

int lastIndexOf（String str）；//查找字符串在字符串中最后一次出现的位置

修改：

StringBuffer replace（int start，int end，String str）；//将指定位置的字符串

替换。

void setCharAt（int index，char ch）；//将指定位置的字符串进行替换。

 1.4 StringBuilder 

jdk1.5以后出现，功能与StringBuffer一样

不同点：

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

StringBuilder是线程不同步的，通常用于单线程，可以提高效率。

 1.5 Jdk升级的目的 

简化书写

提高效率

增加安全性

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

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

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

byte          Byte

short         Short

int              Integer

long           Long

float          Float

double      Double

char          Character

boolean    Boolean

 1.7基本类型======>字符串 

1，  基本类型数值+” ”

2，  用String类中的静态方法valueOf(基本类型数值);

 1.8 字符串=====>基本类型 

使用包装类中的静态方法 xxx parseXxx(“xxx类型的字符串”);

int parseInt(“intstring”);//里面的参数只能是int数字类型，不能是字符

long parseLong(“longstring”);

boolean parseBoolean(“booleanstring”);

只有Character没有parse方法

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

可以使用另一个非静态的方法，inValue(); ，将以个Integer对象转成基本数据类型值。

如：    Integer i = new Integer("123");

       System.out.println(i.intValue());打印的是123

 1.9 整数具备不同的进制体现。 

十进制----->其他进制

Integer.toBinaryString(60)

Integer.toHexString(60)

Integer.toString(60,16); 60为要转的数字，16为要转换的进制是16进制

Integer.toString(60,4); //将60转换为4进制

 2.0自动拆装箱 

Integer i = 4; // i=new Integer(4);自动装箱,简化书写。

i = i+6 // i = new Integer( i.intValue() + 6) ;  // i.intValue() 自动拆箱。

       Integer a =new Integer("3");

       Integer b =new Integer(3);

       System.out.println(a==b);

       System.out.println(a.equals(b));//带着自动拆箱的功能所以是true

System.out.println(a.compareTo(b));//打印0 代表两个对象内容相同,如果a大于b，打印为1，a小于b打印为-1

 

       Integer in = 4;

       in = in + 6;

       System.out.println(in); in打印为10，自动拆装箱，不是两个对象相加。

        面试题 

public class StringTest {

 public static void main(String[] args) {

  String s1 = "hello";

  String s2 = "java";

  show(s1,s2);

  System.out.println(s1+"...."+s2);

 }

 public static void show(String s1,String s2){

  s2.replace('a','o');

  s1 = s2;

 }

}

输入的结果为 hello java

可以这么理解;因为s1与s2是字符串常量，初始化值就固定，不能改变，所以结果为hellojava

理解二： 调用show方法时，传递的是地址值，在方法中，只是对地址值的赋值，并没有对字符

串的内容进行操作，所以结果是 hello java。

 

9、3，两个字符串中最大相同的子串。

 * "qwerabcdtyuiop"

 * "xcabcdvbn"

 * 

 * 思路：

 * 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。

 * 如果存在，短的那个字符串就是最大子串。

 * 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。

 * 如果存在就已找到，就不用在找了。

 * 

 * 

 */

public class StringTest_3 {

 

public static void main(String[] args) {

 

 String s1 = "qwerabcdtyuiop";

 String s2 = "xcabcdvbn";

 

 String s = getMaxSubstring(s2, s1);

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

}

public static String getMaxSubstring(String s1, String s2) {

 

 String max = null,min = null;

 max = (s1.length()>s2.length())?s1:s2;

 

 min = max.equals(s1)?s2:s1;

 

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

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

 for (int i = 0; i < min.length(); i++) {

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

  String sub = min.substring(a, b);

   if(max.contains(sub))

    return sub;

  }

 }

 

 return null;

}

}

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