黑马程序员 Java自学总结十二 String类和基本数据类型包装类

来源：互联网发布：加工中心编程软件排名编辑：程序博客网时间：2024/05/01 07:11

------ ASP.Net+Android+IO开发.Net培训期待与您交流！ ------

总结内容来源于黑马毕老师的java基础教学视频

String类

String类特点：是一个特殊的类，定义时被final修饰，所以它没有子类，字符串一旦初始化，就不可以被改变．

用一段代码来说明String类的其他特点

[java] view plaincopy
class  StringDemo  
{  
     public static void main(String[] args)  
     {  
          String s1 = "abc";//s1是一个类类型变量,"abc"是一个对象.  
                        //字符串最大的特点:一旦被初始化就不可以被改变.  
  
          String s2 = new String("abc");  
  
          //s1和s2有什么区别?  
         //s1在内存中有一个对象.   "abc".  
          //s2在内存中有两个对象.   new String()和"abc".  
  
  
          System.out.println(s1==s2);//结果为false  
          System.out.println(s1.equals(s2));//结果为true  
                          //原因是String类复写了Object类中的equals方法.  
                          //该方法用于判断字符串是否相同.  
     }  
}  

String类是用于描述字符串事物.

那么它就提供了多个方法对字符串进行操作.

常见的操作有哪些?

1.获取

1.1 字符串中的包含的字符数,也就是长度.

int length():获取长度

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

char charAt(int index)

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

int indexOf(int ch):返回的是ch在字符串中第一次出现的位置.

int indexOf(int ch, int fromIndex):从fromIndex指定位置开始,获取ch出现在字符串中位置.

int indexOf(String str):返回的是str在字符串中第一次出现的位置.

int indexOf(String str, int fromIndex):从fromIndex指定位置开始,获取str出现在字符串中位置.

2.判断.

2.1 字符串中是否包含某一个子串.

boolean contains(str)

特殊:indexOf(str);可以索引str第一次出现位置,若返回-1,表示不在字符串中存在.

所以,也可以用于对指定判断是否包含.

if(str.indexOf("aa")!=-1);//判断写法

而且该方法既可以判断,又可以获取出现的位置.

2.2 字符中是否有内容.

boolean isEmpty();//原理就是判断长度是否为0

2.3 字符串是否以指定内容开头.

boolean startsWith(String str);

2.4 字符串是否是以指定内容结尾.

boolean endsWith(String str);

2.5 判断字符串的内容是否相同.复写了Object类中的equals方法

boolean equals(str);

2.6 判断内容是否相同,并忽略大小写.

boolean equalsIgnoreCase();

3.转换.

3.1 将字符数组转成字符串.

构造函数:new String(char[])

new String(char[],offset,count)//将字符数组中的一部分转成字符串

静态方法:

static String copyValueOf(char[])

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

static String valueOf(char[])

3.2 将字符串转成字符数组.

char[] toCharArray()

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

new String(byte[])

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

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

byte[] getBytes()

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

static String valueOf(int)

static String valueOf(double)

例如 3+""和String.valueOf(3)的效果是相同的.

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

4.替换

返回一个新的字符串,它是通过用newChar替换此字符串中出现的所有 oldChar得到的

String replace(oldChar, newChar)

使用指定的字符串new替换指定的字符串old,也返回一个新的字符串.

String replace(oldString, newString)

5.切割

根据给定表达式的匹配拆分此字符串。

String[] split(regex)

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

从指定位置开始到结尾

String substring(begin)

返回一个新字符串,该字符串的长度为 end-begin.

String substring(begin,end);

7.转换,去除空格,比较

7.1 将字符串转成大小写.

String toUpperCase()

String toLowerCase()

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

String trim();

7.3 对两个字符串进行比较,该比较基于字符串中各个字符的Unicode值.

int compareTo(string)

举例代码

[java] view plaincopy
class StringMethodDemo  
{  
    public static void method_7()  
     {  
          String s = "  Hello Java  ";  
          sop(s.toUpperCase());  
          sop(s.toLowerCase());  
          sop(s.trim());  
  
          String s1 = "a1c";  
          String s2 = "aaa";  
          sop(s1.compareTo(s2));  
          sop("---------------------------------------------------");  
     }  
  
     public static void method_sub()  
     {  
          String s = "abcdef";  
          sop(s.substring(3));  
          sop(s.substring(3,5));  
          sop("---------------------------------------------------");  
     }      
  
     public static void method_slipt()  
     {  
          String s = "zhangsan,lisi,wangwu";  
          String[] s1 = s.split(",");  
          for (int x=0; x<s1.length; x++)  
          {  
               sop(s1[x]);  
          }  
          sop("---------------------------------------------------");  
     }  
  
     public static void method_replace()  
     {  
          String s = "hello java";  
          //String s1 = s.replace('q','n');  
                               //如果要替换的字符不存在,返回原串  
          String s1 = s.replace("java","world");  
  
          sop("s="+s);  
          sop("s1="+s1);  
     }  
    public static void method_trans()  
     {  
          char[] arr = {'a','b','c','d','e'};  
          //用构造函数将字符数组转成字符串  
          String s =new String(arr,1,3);  
          sop("s="+s);  
          //用静态方法将字符数组转成字符串  
          sop(String.copyValueOf(arr,3,2));  
         
          String s1 = "gesfedghe";  
          //将字符串转成字符数组  
          char[] arr1 = s1.toCharArray();  
          for (int x= 0; x<arr1.length; x++)  
          {  
               if (x==arr1.length-1)  
               {  
                    System.out.print(arr1[x]+"]");  
               }  
               else if (x==0)  
               {  
                    System.out.print("["+arr1[x]+",");  
               }  
               else  
                    System.out.print(arr1[x]+",");  
          }  
     }  
  
    public static void method_is()  
     {  
          String str = "ArrayDemo.java";  
          //判断文件名是否是是Array单词开头.  
          sop(str.startsWith("Array"));  
          //判断文件名是否是.java的文件.  
          sop(str.endsWith(".java"));  
          //判断文件中是否包含Demo  
          sop(str.contains("Demo"));  
          sop("---------------------------------------------------");  
     }  
  
     public static void method_get()  
     {  
          String str = "abcdefakpf";  
  
          //获取字符串长度  
          sop("length="+str.length());  
  
          //根据索引获取字符  
          sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生:  
                            //StringIndexOutOfBoundsException(字符串角标越界)  
  
          //根据字符获取索引  
          sop(str.indexOf('a',3));//如果没有找到,返回-1.  
  
          //根据字符串获取索引  
          sop(str.indexOf("de"));  
  
  
          //反向索引一个字符出现位置.  
          sop(str.lastIndexOf("a"));  
          sop("---------------------------------------------------");  
     }  
  
     public static void main(String[] args)  
     {  
        method_get();  
          //method_is();  
          //method_trans();  
          //method_replace();  
          //method_slipt();  
          //method_sub();  
          //method_7();  
          /* 
 
          String s1 = "abc"'; 
          String s2 = new String("abc"); 
 
          System.out.println("Hello World!"); 
 
          */  
     }  
  
     public static void sop(Object obj)  
     {  
          System.out.println(obj);  
     }  
}  

String练习

[java] view plaincopy
/* 
一:模拟一个trim方法,去除字符串两端的空格. 
   思路: 
          1.判断字符串第一个位置是否空格,如果是继续向下判断, 
               直到不是空格为止,结尾处判断空格也是如此. 
          2.当开始和结尾都判断到不是空格时,就要获取的字符串. 
 
二:将一个字符串进行反转,将字符串中指定部分进行反转,"abcdefg",abfedcg 
   思路: 
        1.曾经学习过对数组的元素进行反转. 
          2.将字符串变成数组,对数组反转. 
          3.将反转后的数组变成字符串. 
          4.只要将要反转的部分的开始和结束为止作为参数传递即可. 
 
三:获取一个字符串中另一个字符转中出现的次数. 
   "abkkcdkkefkkskk" 
   思路: 
        1.定义个计数器. 
          2.获取kk第一次出现的位置. 
          3.从第一次出现位置后剩余的字符串中继续获取kk出现的位置. 
            每获取一次,就计数一次. 
          4.当获取不到时,计数完成. 
 
四:获取两个字符串中最大相同子串.第一个动作:将短的串进行长度一次递减 
   的子串打印 
    "abcwerthelloyuiodef" 
     "cvhellobnm" 
     思路: 
          1.将短的子串按照长度递减的方式获取到. 
          2.将每次获取到的子串去长串中判断是否包含,如果包含,已经找到! 
    
*/  
  
class Trim  
{  
     //打印的简写调用方法  
     public void sop(Object obj)  
     {  
          System.out.println(obj);  
     }  
     //练习四  
     public void getContainsSub(String str,String key)  
     {  
          String max = "",min = "";  
          max = (str.length()>key.length())?str:key;  
          min = (max==str)?key:str;  
          for (int y=min.length();y>0 ;y-- )  
          {  
               int x = 0;  
               int temp = y;  
                
               while(temp!=min.length()+1)  
               {  
                    String s = min.substring(x,temp);  
                   if(max.contains(s))  
                    {  
                         sop(s);  
                         return;  
                    }  
                    x++;  
                    temp++;  
               }  
          }  
     }  
  
     //练习三:方式二  
     public void samMethod1(String str,String key)  
     {  
          int count = 0;  
          int index = 0;  
          while ((index=str.indexOf(key,index))!=-1)  
          {  
               index = index + key.length();  
               count ++;  
          }  
          sop(count);  
     }  
     //练习三:方式一  
     public void samMethod(String str,String key)  
     {  
          int count = 0;  
          int index = 0;  
          if(str.contains(key))  
          {  
               while ((index=str.indexOf(key))!=-1)  
               {  
                    sop(str);  
                    str = str.substring(index+key.length());  
                    count ++;  
               }  
               sop(count);  
          }  
                
     }  
     //练习二  
     public void turnMethod(String str,int x,int y)  
     {  
          //字符串变char数组  
          char[] c = str.toCharArray();  
          //反转数组  
          while (x<y)  
          {  
               char temp = c[x];  
               c[x] = c[y];  
               c[y] = temp;  
               x++;  
               y--;  
          }  
          //将数组变字符串  
          String s = new String(c);  
          sop(s);  
     }  
  
     //练习一  
     public void trimMethod(String str)  
     {  
          int x = 0;  
          int y = str.length()-1;  
          while (str.charAt(x)==' '&&x<y)  
          {  
               x++;                
          }  
          while (str.charAt(y)==' '&&y>0)  
          {  
               y--;                
          }  
          if(x>y)  
               sop("你输入的字符串无效");  
          else  
               sop(str.substring(x,y+1));  
     }  
}  
  
class StringTest  
{  
     public static void main(String[] args)  
     {  
          String s = "abcdefg";  
          Trim t = new Trim();  
          //t.trimMethod(s);  
          //t.turnMethod(s,4,6);  
          //t.samMethod1("abkkcdkkefkkskk","kk");  
          t.getContainsSub("cvhellobnm","abcwerthelloyuiodef");  
     }  
}  

StringBuffer是字符串缓冲区.

是一个容器.特点:

1.长度是可变化的

2.可以直接操作多个数组类型.

3.最终会通过toString变成字符串.

1.存储

StringBuffer append();将制定数据作为参数添加到已有数据的结尾处.

StringBeffer insert(index,数据):可以将数据插入到制定index位置.

2.删除

StringBuffer delete(start,end):删除缓冲区数据,包含start,不包含end.

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

3.获取.

char charAt(index)

int indexOf(str)

int lastIndexOf(str)

int length()

String substring(start,end)

4.修改

StringBuffer replace(start,end,String)替换start到end的字符串

void setCharAt(index,char)替换某角标位的字符

5.反转

StringBuffer reverse()

将缓冲区指定数组存储到指定char[]中.

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

举例代码

[java] view plaincopy
class StringBufferDemo  
{  
     public static void main(String[] args)  
     {  
//          method_del();  
          method_update();  
     }  
     public static void method_update()  
     {  
          StringBuffer sb = new StringBuffer("avdeyswj");  
          sb.replace(1,7,"java");  
          sb.setCharAt(5,'a');  
          sop(sb.toString());  
     }  
     public static void method_del()  
     {  
          StringBuffer sb = new StringBuffer("avdeyswj");  
//          sb.delete(2,7);  
        //清除缓冲区  
          sb.delete(0,sb.length());  
          sop(sb.toString());  
  
     }  
     public static void method_add()  
     {  
          StringBuffer sb = new StringBuffer();  
          sb.append(34).append(true).append("abc");  
          sb.insert(3,"pp");  
          sop(sb.toString());  
     }  
  
     public static void sop(String str)  
     {  
          System.out.println(str);  
     }  
}  

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

StringBuffer是线程同步.自带锁,同时只能有一个线程操作,建议多线程使用

StringBuilder是线程不同步.无锁,建议单线程使用.

以后开发建议使用StringBuilder.

JDK升级三个因素

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 d = Double.parseDouble("12.23");

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

对象调用方法

Integer i = new Integer("123")

int i = i.intValue();

十进制转成其他进制.

toBinaryString(十进制数字);//转成二进制

toHexString(十进制数字);//转成十六进制

toOctalString(十进制数字);//转成八进制

其他进制转成十进制.

parseInt(string,radix)

parseInt("3c",16)

parseInt("110",2)

parseInt("77",8)

JDK1.5升级的新特性用一段代码来说明

[java] view plaincopy
/* 
JDK1.5版本以后出现的新特性. 
*/  
  
class IntegerDemo1  
{  
     public static void main(String[] args)  
     {  
//          Integer x = new Integer(4);  
          Integer x = 4;//和上面的意义是相同的,进行了自动装箱.  
  
          x = x + 2;//x进行了自动拆箱,变成了int型,和2进行加法运算.  
                    //再将运算结果进行装箱赋给X.  
  
  
          Integer m = 128;  
          Integer n = 128;  
  
          sop("m==n"+(m==n));//结果为假,两个对象  
  
          Integer a = 127;  
          Integer b = 127;  
  
          sop("a==b"+(a==b));//结果为真:  
                        //因为a和b指向了同一个Integer对象.  
                        //因为当数字在byte范围内时,由于新特性,  
                           //如该值已存在,不会开辟新空间.  
  
     }  
}  

------ ASP.Net+Android+IO开发.Net培训期待与您交流！ ------