[原创]课堂笔记学习java(初级) - JAVA论坛

第 103 楼

得分:0

第九节课

字符串

1.什么是字符串

java使用java.lang包中的String类来创建一个字符串变量,因此字符串变量是一个对象.

a) 字符串常量

如, "你好","bc-cn","12345789"
字符串常量在内存中一但定义,地址空间是不可改变的,直到程序结束.就是说字符串常量在内存中有固定的地址.

b) 声明字符串

String str;

c) 创建字符串

使用String类的构造方法,例如:

str=new String("I like bc-cn.net"); //当然如果没有声明直接创建也是可以的,回忆一下匿名类的概念

声明和创建可以一步完成:

String str=new String("I like bc-cn.net");

也可以用一个已创建的字符串创建另一个字符串,如

String s=String(str);

String类还有两个比较常用的构造方法.

(1)String (char a[]) //用一个字符数组a创建一个字符串对象,如

char a[]={'b','o','y'};
String s=new=new String(a);

上述过程相当于:

String s=new String("boy");

(2)String(char a[],int startIndex,int count)

提取字符数组a中的一部分字符创建一个字符串对象,参数startIndex和count分别指定在a中提取字符的起始位置(例如第一位置从0开始依次类推)和从该位置开始截取的字符个数,例如

char a[]={'s','t','b','u','s','n'};
String s=new String(a,2,3); //从2开始,即第三个位置(b),截取3个字符

上述过程相当于:

String s=new String("bus");

d)引用字符串常量对象

字符串常量是对象,因此可以把字符串常量的引用赋值给一个字符串变量,例如:

String s1,s2;
s1="how are you";
s2="how are you";

分析:"how are you"是个字符串常量,所以在内存中的地址是固定的,赋值给了s1和s2,就说明s1和s2用的是同一个空间

2.字符串的常用方法

1)public int length()
使用String类中的length()方法可以获取一个字符串的长度,如

String s="we are student",tom="我们是学生";
int n1,n2,n3;
n1=s.length(); //n1的值是15
n2=tom.length(); //n2的值是5.
n3="we are student=我们是学生".length();// n3的值是21

2)public boolean equals(String s)
字符串对象调用String类中的equals方法,比较当前字符串对象的实体是否与参数指定的字符串s的实体相同,如:

String tom=new String("we are student");
String boy=new String("We are students");
String jerry=new String(tom);

则:tom.equals(boy)或tom.equals(jerry) 的值都是true 因为比较是是实体,即字符串本身(各个位置的字符与长度是否相同)

注意:如果是tom==jerry或tome==boy 的值就是false,因为new了之后,字符串就是对象,tom,boy,jerry是引用值(地址),因为每个对象在创建后都有自己的内存空间,所以用"=="比较当然会不同喽

字符串对象调用public boolean equalsIgnoreCase(String s) 比较当前字符串对象与参数指定的字符串s是否相同,比较时候忽略大小写.
仔细体会下面的例子:


class E
{  public static void main(String args[])
    {  String s1,s2;
       s1=new String(\"we are students\");
       s2=new String(\"we are students\");
       System.out.println(s1.equals(s2));//字符串实体相同,输出结果是true    
       System.out.println(s1==s2); //对象各自分配的空间不同,输出结果为false          
       String s3,s4; 
       s3=\"how are you\";
       s4=\"how are you\"; 
       System.out.println(s3.equals(s4));  //同一个空间,结果为true  
       System.out.println(s3==s4);    //同一个空间,结果为true
    }
}

3)public boolean startsWith(String s) 和public boolean endWith(String s)
字符串对象调用startsWith(String s)方法,判断当前字符串对象的前缀是否是参数指定的字符串s,如

String tom="bbs.bc-cn.net",jerry="www.bc-cn.net";
tom.startsWith("bbs")的值是true
jerry.startsWith("bbs")的值是false

同样,endWith(String s)判断的就是后缀

字符串对象调用public boolean startsWith(String prefix,int toffset)方法,判断当前字符串从toffset索引处开始的前缀是否是参数指定的字符串prefix,如:

String str="123456";
boolean boo=str.startsWith("456",3)// 很容易看出来,boo的值应该是true

4)public boolean regionMatches(int firstStart,String other,int otherStart,int length)
字符串调用此方法,从当前字符串参数firstStart指定的位置开始处,取长度为length的一个子串,并将这个子串和参数other指定的一个子串进行比较.其中,other指定的字符串是从参数otherStart指定的位置开始,从other中取长度为length的一个子串.如果两个子串相同则该方法返回true

使用该方法的重载方法:
public boolean regionMatches(boolean b,int firstStart,String other,int otherStart,int length)
可以通过参数b决定是否忽略大小写,当b为ture时,忽略大小写

这个方法描述起来虽然罗嗦,但看完下面的例子就很容易掌握了,如


class E
{   public static void main(String args[])
    {  int number=0; 
       String s=\"student;entropy;engage,english,client\";
       for(int k=0;k<s.length();k++)
        {  if(s.regionMatches(k,\"en\",0,2))//k是第一个串的其实位置,0是\"en\"的其实位置,2是每次取的子串的长度
             {  number++;
             }
         } 
       System.out.println(\"number=\"+number);
    }//这个例子很容易看出是在统计s中出现en的次数
}

5)public int compareTo(String s)
字符串对象可以使用String类中的compareTo(String s)的方法,按字典序与参数s指定的字符串比较大小.如果当前字符串与s相同,该方法返回值0;如果当前字符串对象大于s,该方法返回正值;如果小于s,该方法返回负值.例如:

String str="abcde";
str.compareTo("boy")小于0
str.compareTo("aba")大于0
str.compareTo("abcde")等于0

按字典序比较两个字符串还可以使用public int compareToIgnoreCase(String s) 该方法忽略大小写

看看下面的例子是将一个字符串数组按字典序重新排序


class E
{  public static void main(String args[]) 
{  String a[]={\"door\",\"apple\",\"Applet\",\"girl\",\"boy\"};
       for(int i=0;i<a.length-1;i++) 
          { for(int j=i+1;j<a.length;j++) 
            {  if(a[j].compareTo(a[i])<0)//如果当前字符串比下一个字符串字典序号大,交换 
               {   String temp=a[i];
                   a[i]=a[j];
                   a[j]=temp;
                }
            } 
         }
      for(int i=0;i<a.length;i++) 
         {  System.out.print(\"  \"+a[i]);
         }
    }
}

6)public int indexOf(String s)
字符串对象调用indexOf(String s)方法从当前字符串的头开始检索字符串s,并返回首次出现s的位置.如果没有检索到字符串s,该方法返回-1.

字符串调用public int indexOf(String s,int startpoint)方法从当前字符串的startpoint位置处开始检索字符串s,并返回首次出现s的位置.如果没有检索到返回-1.

字符串调用public int lastIndexOf(String s)方法从当前字符串的头开始检索字符串s,并返回最后出现s的位置.如果没有检索到返回-1.

如:
String s="bbs.bc-cn.net";
s.indexOf("b"); //值为0
s.indexOf("b",3); //值为4
s.lastIndexOf(".");//值为9 即net前面那个"."

7)public String substring(int startpoint)
字符串对象调用该方法获得一个当前的字符串的子串,该子串是从当前字符串的startpoint处截取到字符串的末尾处所得到的字符串.

字符串对象调用substring(int start,int end)方法获得一个当前字符串的子串,该子串是从当前串的start处截取到end处所得到的字符串,但不包括end处所对应的字符.
例如:
String tom="I love tom";
string s=tom.substring(2,5);// 得到的s应是"lov"

8)public String replaceAll(String oldString,String newString)
字符串对象调用该方法可以获得一个串对象,这个串对象是通过参数newString指定的字符串替换s中由oldString指定的所有字符串而得到的字符串.

字符串对象调用public String replaceFirst(String oldString,String newString)方法可以获得一个串对象,这个串对象是通过用参数newString指定的字符串替换s中出现的第一个oldString指定字符串而得到得字符串.
例如:
String tom="hello,tom";
String jerry=new String(tom.replaceAll("tom","jerry")); //jerry的应该是"hello,jerry"

9)public String trim()
字符串常量调用此方法得到一个字符串对象,该字符对象是s去掉前后空格后的字符串.
如:


class E
{  public static void main(String args[])
   {   String path=\"c:\\myfile\\2000\\result.txt\";
       int index=path.lastIndexOf(\"\\\"); //得到最后出现'\'的位置,注意'\'是转移字符,要想单独表示'\'时应该写成\"\\\"
       String fileName=path.substring(index+1);//得到'\'后面的子串即result.txt
       String newName=fileName.replaceAll(\".txt\",\".java\"); //把result.txt中的txt替换成java
       System.out.println(path);
       System.out.println(fileName); //输出应为result.txt
       System.out.println(newName); //输出应为result.java 
   }
}

3.字符串与基本数据的相互转换
a)
java.lang包中的Integer类调用其类方法:
public static int parseInt(String s)
其可以将"数字"格式的字符串,如"123456",转化为int型数据,例如

int x;
String s="123456";
x=Integer.parseInt(s);//整形x值为123456

类似的还有Byte,Short,Long,Float,Double类调相应的类方法:
byte Byte.parseByte(String s); //将字符串转换为byte格式

short Short.parseShort(String s);

long Long.parseLong(String s);

float Float.parseFloat(String s);

double Double.parseDouble(String s);

注意使用这些时候要放在try-catch中捕获异常 NumberFormatException ,后面会有例子格式说明

b)可以用下列的方法把数字型变量转换为字符串:

public static String valueOf(byte n)

public static String valueOf(int n)

public static String valueOf(long n)

public static String valueOf(float n)

public static String valueOf(double n)

如: String str=String.valueOf(12345678.9);

c)可以用下列方法(Long 类)得到整数的各种进制的字符串:

public static String toBinaryString(long i)

public static String toOctalString(long i)

public static String toHexString(long i)

public static String toString(long i,int p)

其中的toString(long i,int p)返回整数i的p进制表示

下面一个转换的综合例子,仔细体会一下:

public class E
{  public static void main(String args[]) 
   {  double n,sum=0,item=0;
      boolean computable=true; 
      for(int i=0;i<args.length;i++) 
        { try{  item=Double.parseDouble(args[i]);
                sum=sum+item;
             }
          catch(NumberFormatException e)
             {  System.out.println(\"您键入了非数字字符:\"+e);
                computable=false;
             }
        }
     if(computable)
        { n=sum/args.length;
          System.out.println(\"平均数:\"+n);
        } 
     int number=123456;
     String binaryString=Long.toBinaryString(number);
     System.out.println(number+\"的二进制表示:\"+binaryString);
     System.out.println(number+\"的十六进制表示:\"+Long.toString(number,16));
     String str=\"1110110\";
     int p=0,m=0;
     for(int i=str.length()-1;i>=0;i--) 
     {   char c=str.charAt(i);
         int a=Integer.parseInt(\"\"+c);
         p=p+(int)(a*Math.pow(2,m));
         m++;
     }
     System.out.println(str+\"的十进制表示:\"+p);
  }
}

分析:应用程序中的main方法中的参数args能接受从键盘输入的字符串.首先编译源文件:
编译通过后,输入java E 12 15 16 36 回车
这时,程序中的args[0],args[1],args[2],args[3]分别得到字符串12,15,16和36.在程序中再将这些字符串转换为数值进行计算,得到所需的结果.

上述例子输出结果为:
平均数:19.75
123456的二进制表示:11110001001000000
123456的十六进制表示:1e240
1110110的十进制表示:118

4.对象的字符串表示

所有的类都默认时java.lang包中Object类的子类或者间接子类.Object类有一个public方法toString,一个对象通过调用该方法可以获得该对象的字符串表示.如:


import java.util.Date;
import java.awt.*;
public class E
{  public static void main(String args[])
   {  Date date=new Date();//Date包中的类 获取系统当前时间
      Button button=new Button(\"确定\");//awt包中的类
      System.out.println(date.toString());//date的属性用字符串表示,即当前系统时间
      System.out.println(button.toString());//把button的属性用字符串表示出来,(即位置,大小,可用,名称等等)  
   }
}

显示结果为:
Sun Nov 26 20:38:30 CST 2006
java.awt.Button[button0,0,0,0x0,invalid,lable=确定]

5.StringTokenizer类

StringTokenizer(String s) 为字符串s构造一个分析器.使用默认的分隔符集合,即空格符(若干个空格被看成一个空格),换行符,回车符,Tab符,进纸符.

StringTokenizer(String s,String dilim) 为字符串s构造一个分析器,参数dilim中的字符被作为分隔符.

如:StringTokenizer fenxi=new StringTokenizer("we are student");//用空格区分单词
StringTokenizer fenxi=new StringTokenizer("we,are ;student",", ; ");//用"," 和";"还有空格来区分单词

StringTokenizer可以用nextToken()方法逐个获取字符串中的语言符号(单词),每当调用nextToken()时,都将在字符串中获得下一语言符号,每当获取到下一个语言符号,字符串分析器中负责计数的变量的值就自动减一,该计数变量的初始值等于字符串中单词的个数.通常用while循环来逐个获取语言符号,为了控制循环,可以使用StringTokenizer类中的hasMoreTokens()方法,只有字符串中还有语言符号,即计数变量的值大于0,该方法就返回true,否则返回false.另外还可以随时让分析器调用countTokens()方法得到分析器中计数变量的值.

通过下面的例子理解StringTokenizer类的使用,如


import java.util.*;
public class E
{  public static void main(String args[])
   {  String s=\"I am Geng.X.y and she is my girlfriend\";
      StringTokenizer fenxi=new StringTokenizer(s,\" ,\"); 
      int number=fenxi.countTokens();
      while(fenxi.hasMoreTokens()) 
       {  String str=fenxi.nextToken();
          System.out.println(str);
          System.out.println(\"还剩\"+fenxi.countTokens()+\"个单词\");
       }
     System.out.println(\"s共有单词：\"+number+\"个\");
   } 
}

unicorn-h.spaces. ◇◆ sava-scratch.spaces. noh enol ! pue pu!w hw u! shemle aq ll!m noh

第 104 楼

得分:0

6.字符串与字符,字节数组
1)字符串和字符数组
a)用字符数组创建字符串对象

String (char[]) //该构造方法用指定的字符数组构造一个字符串对象
String (char[],int offset,int length) //用指定的字符数组的一部分,即从起始位置offset开始取length个字符构造字符串对象

如前面的例子:

char a[]={'b','o','y'};
String s=new=new String(a);

b)将字符串中的字符复制到字符数组
public void getChars(int start,int end,char c[],int offset) //字符串调用此方法将当前的字符串中的一部分字符复制到数组c中,将字符串中从start到end-1位置上的字符复制到数组c中,并从数组c中的offset处开始存放这些字符,需要注意的是,必须保证数促c能容纳下要复制的字符.

public char[] toCharArray() 字符串对象调用该方法可以初始化一个字符数组,该数组的长度与字符串的长度相等,并将字符串对象的全部字符复制到该数组中.

体会下面俩个例子:


class E
{  public static void main(String args[])
   {  char c[],d[],e[];
      String s=\"巴西足球队击败德国足球队\";
      c=new char[2];
      s.getChars(5,7,c,0);
      System.out.println(c); //输出击败
      d=new char[s.length()];
      s.getChars(7,12,d,0);
      s.getChars(5,7,d,5);
      s.getChars(0,5,d,7);
      System.out.println(d);//d[]中保存的是德国足球队击败巴西足球队
      e=new char[s.length()];
      e=s.toCharArray()
      System.out.println(e);//e[]中保存的s的内容即\"巴西足球队击败德国足球队\"
      
   }
}


class E
{  public static void main(String args[]) 
   {  String s=\"编程论坛\";
      char a[]=s.toCharArray();//把字符串转成字符数组
      for(int i=0;i<a.length;i++)
        {  a[i]=(char)(a[i]^'t');//把每个字符都处理下
        }
String secret=new String(a);
System.out.println(\"密文:\"+secret);
      for(int i=0;i<a.length;i++)
       {  a[i]=(char)(a[i]^'t');
       }
String code=new String(a);  
  System.out.println(\"原文:\"+code);
   }
}

2)字符串和字节数组
和字符数组的形容类似
a)用字节创建字符串对象
String (byte [])

String (byte[],int offset,int length)

b)将字符串转换为字节数组
public byte[] getBytes()

例如:


public class E
{  public static void main(String args[])
   {  byte d[]=\"你我他\".getBytes();           
      System.out.println(\"数组d的长度是(一个汉字占两个字节):\"+d.length);//输出\"数组d的长度是(一个汉字占两个字节):6\"
      String s=new String(d,0,2);
      System.out.println(s);//输出\"你\"
   }
}

7.StringBuffer类

前面学习了String字符串对象,String类创建的字符串对象是不可修改的,也就是说String字符串不能修改,删除,替换字符串中的某个字符,即String对象一但创建,那么实体是不可以再发生变化的.

下面介绍StringBuffer类,该类能创建可修改的字符串序列,也就是说,该类对象的实体的内存空间可以自动改变大小,便于存放一个可变的字符序列.比如,一个StringBuffer对象调用用append()方法可以追加字符序列,例如:
StringBuffer s=new StringBuffer("I love this game");
s.append(" !!");
//s的值就变为I love this game !!

1)StringBuffer的构造方法

a)StringBuffer()//无参数,可容纳16个字符,可以通过调用capacity()方法获取当前实体的实际容量

b)StringBuffer(int size)//指定size大小的容量,当存放大于size时,实体容量自动增加,以便存放所增加的字符

c)StringBuffer(String s)//指定实体的初始容量为参数s的长度额外再加16个字符,当超过size大小时,实体容量自动增加,以便存放所增加的字符

注意:可以用String(StringBuffer bufferstring)创建一个字符串的对象

2)StringBuffer类常用的方法

a)append方法//追加字符串,刚刚讲过

b)char charAt(int n)//得到第n(n>=0&&n<=s.capacity())个位置的字符

c)void setCharAt(int n,char ch)//替换第n个位置的字符

d)StringBuffer insert(int index,String str)//再第index的位置插入字符串str,并返回当前对象的引用

e)StringBuffer reverse()//逆置当前对象的实体,并返回当前对象的引用

f)StringBuffer delete(int startIndex,int endIndex)//删除从startIndex~endIndex-1之间的字符串,并返回当前对象的引用

g)StringBuffer replace(int startIndex,int endIndex,String str)//用字符串str替换startIndex~endIndex-1之间的字符串,并返回当前对象的引用

例如:


class E
{ public static void main(String args[ ])
  { StringBuffer str=new StringBuffer(\"62791720\");
    str.insert(0,\"010-\");//在第0个位置插入010-,当前实体变为\"010-62791720\"
    str.setCharAt(7 ,'8'); //把第8个位置的字符设置为8,当前实体变为\"010-62781720\"
    str.setCharAt(str.length()-1,'7');//把最后一个位置的字符设置为7,当前实体变为\"010-62781727\"
    System.out.println(str); //输出当前实体\"010-62781727\"
    str.append(\"-446\");//追加字符串-446,当前实体变为\"010-62781727-446\"
    System.out.println(str);
    str.reverse();//逆置当前实体,实体变为644-72718726-010
    System.out.println(str);
  }
}

总结:字符串是很重要的概念,此节深入理解字符串及其相关方法的应用

unicorn-h.spaces. ◇◆ sava-scratch.spaces. noh enol ! pue pu!w hw u! shemle aq ll!m noh