第六章 字符串

一：字符串

    字符窜是一个由零个或多个字符串组成的字符组成的字符序列。字符串不是一个简单的基本数据类型，也不是一个字符串数组。

    字符串变量使用String关键字来声明，表示该变量为字符串类型的变量。

    Java将字符串作为内置对象处理，提供了丰富的特性来处理字符串。

    字符串的创建：

     String str; //声明一个字符串变量的类型

     str ="abc"; //把一个字符串常量赋值给一个字符串变量str

    当把一个空字符串“”赋给字符串变量时，表示该字符串在内存中已经分配了空间。

   //文件名：StringDemo.java  

class StringDemo
{
	public static void main(String[] args)
	{
		String s; //定义一个字符串变量s
		s = "字符串示例."; //对于String类型的变量需要先初始化才能使用该变量,
		System.out.println(s);		
	}
}

 

二：字符串函数

    1.字符串的截取：

      即从某个字符串中，截取该字符串其中的一部分作为新的字符串操作。

      String类中substring函数可以实现字符串的截取，如

      方式一：String substring(int beginIndex);  //指定开始，一直到结尾

      方式二：String substring(int beginIndex int endIndex);  //指定开始位置和结束位置

      String为该函数的返回类型
      substring是函数名
      int beginIndex是开始的索引位置,包含该位置
      int endIndex 结束位置,不包含该位置

   //文件名：SubstringDemo.java    

class SubstringDemo
{
	public static void main(String[] args)
	{
		String s = "where are you come from?";

		//对字符串进行截取
		String subs1 = s.substring(0); //"where are you come from?";
		String subs2 = s.substring(1); //"here are you come from?";
		String subs3 = s.substring(0,5); // "where"
		String subs4 = s.substring(6,9);//"are"

		System.out.println(subs1);
		System.out.println(subs2);
		System.out.println(subs3);
		System.out.println(subs4);
	}
}

 

    2.字符串的查找

      就是在一个字符串中查找另一个字符串，String类提供字符串查找函数indexOf，这个函数的作用是返回指定子字符串在此字符串中第一次出现处的索引。

      str.indexOf(String substr)

      str.indexOf(String substr, int fromIndex)
      str表示任何一个字符串常量或者字符串变量。
      substr 表示要查找的内容。
      fromIndex 表示开始位置的索引, 如果省略掉此参数,表示从字符串的第一个字符开始搜索指定的字符串结果,如果没有找到指定的字符串, 则返回”-1”。

   //文件名：IndexOfString.java   

class IndexOfString 
{
	public static void main(String[] args) 
	{
		String s = "where are you come form?"; //目标字符串
		String s1 = "where"; //要查找的内容
		String s2 = "re";//要查找的内容

		//从开始位置查找where字个字符串
		int serFlg1 = s.indexOf(s1);
		System.out.println(serFlg1); //0
		
		//从索引为2的位置开始查找where这个字符串
		int serFlg2 = s.indexOf(s1, 2);
		System.out.println(serFlg2); //-1
		
		//查找"re"这个字符串
		int serFlg3 = s.indexOf(s2, 2);
		System.out.println(serFlg3); //3,注意有两个re,返回第一次出现的位置
	}
}

 

   //文件名：LastIndexOfString.java   

public class LastIndexOfString {
	public static void main (String[] args) 
	{
		String s = "LastIndexOfStringStringOf";
		String s1 = "Index";
		String s2 = "Of";
		
		//从右向左查找"Index"这个字符串
		int serFlg1 = s.lastIndexOf(s1);
		System.out.println(serFlg1); //4
		
		int serFlg2 = s.lastIndexOf(s2);
		System.out.println(serFlg2); //23
		
		int serFlg3 = s.lastIndexOf(s2,12); //从索引为12的位置开始查找,即"LastIndexOfSt"反向查找
		System.out.println(serFlg3); //9
	}    
}

 

    3.字符串替换

      对于一个字符串，可以用一个字符去替换该字符串中所有指定的字符，String类提供replace函数可以实现这种操作。
       str.replace(char oldChar, char newChar)
       返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
   //文件名：RepalceString.java     

public class RepalceString {
	public static void main (String[] args) 
	{
		String s = "Replace String is ok,   start";
		char newChar = 'k';
		char oldChar = 's';
		String str = s.replace(oldChar, newChar);
		System.out.println(str); //"Replace String ik ok, ktart" 注意区分大小写
		
		System.out.println(str.replaceAll(" ", " ")); //替换所有匹配项
	}
}

 

    4. 返回一个数据类型值的字符串形式

       对于Java中的基本数据类型, 都可以通过String类提供的valueOf函数将其转换为字符串的形式。
       String valueOf(参数)  
       基本类型通过String.valueOf(a);得到字符串
       字符串通过Integer.parseInt(str)；得到基本类型

   //文件名：ValueOfString.java   

public class ValueOfString
{
	public static void main (String[] args) 
	{
		byte a = 3;
		short b = 70;
		int c = 100;
		long d = 500L;
		char e = 'A';
		boolean f = true;
		float g = 1.25F;
		double  h = 1.0567D;
		char[] cArray = {'A','B','C','D'};
		
		System.out.println(String.valueOf(a)); //"3"
		System.out.println(String.valueOf(b));
		System.out.println(String.valueOf(c));
		System.out.println(String.valueOf(d));
		System.out.println(String.valueOf(e));
		System.out.println(String.valueOf(f));
		System.out.println(String.valueOf(g));
		System.out.println(String.valueOf(h));
		System.out.println(String.valueOf(cArray)); //"ABCD"
	}		    
}

 

    5.大小写转换

      String类提供两个无参函数来实现这种转换操作
      str.toUpperCase 全部转成大写
      str.toLowerCase 全部转成小写

   //文件名：StringCase.java   

public class StringCase {
	public static void main (String[] args) 
	{
		String s1 = "I'm a String";
		String s2 = "String is very good";
		s1.toUpperCase();
		System.out.println(s1.toUpperCase());
		System.out.println(s2.toLowerCase());
	}
}

 

    6.字符串的连接

      字符串的连接, 就是将两个字符串连接在一起,成为一个字符串
      方式一: 使用”+”号, “+”不但可以连接两个字符串,还可以将字符串与其他数据类型相连接, 这种情况下,系统自动将其他类型转换为字符串再与该字符串连接.
      方式二:String类提供的concat函数将指定的字符串与另一个字符串相连接

   //文件名：ConcatString.java   

public class ConcatString {
	public static void main (String[] args) 
	{
		String s1 = "String";
		String s2 = "ABCD";
		String s3 = "EFGH";
		
		//连接
		String result1 = s1.concat(s2);
		String result2 = result1.concat(s3);
		System.out.println(result2);
		//可以连写成下面的方式
		String result = s1.concat(s2).concat(s3);
		System.out.println(result);	
	}    
}

 

    8.字符串的比较

       所谓字符串，就是按字典顺序比较两个字符串。String类提供的compareTo函数来对两个字符串的比较。

       该比较基于字符串中各个字符的Unicode值。

       str.compareTo(String anotherString) 结果正数大 负数小 0 相等

       str.equals(str2) 结果 一样true 不一样false

   //文件名：CompareString.java   

public class CompareString {
	public static void main (String[] args) 
	{
		String str1 = "A"; //Unicode码 65
		String str2 = "B"; //Unicode码 66
		
		//不忽略大小写的情况下比较两个字符串
		System.out.println(str1.compareTo(str2));
		System.out.println(str2.compareTo(str1));
		
		str1 = "AA"; //Unicode码 65 65
		str2 = "AB"; //Unicode码 65 66
		
		//不忽略大小写的情况下比较两个字符串,如果首位相等,接着比第二位
		System.out.println(str1.compareTo(str2));
		System.out.println(str2.compareTo(str1));
		
		str1 = "AA"; //Unicode码 65 65
		str2 = "AA"; //Unicode码 65 65
		
		System.out.println(str1.compareTo(str2));
		System.out.println(str2.compareTo(str1));
		
		str1 = "AA"; //Unicode码 65 65
		str2 = "aa"; //Unicode码 65 65
		
		System.out.println(str1.compareToIgnoreCase(str2));
		System.out.println(str2.compareTo(str1));		
	}
}

 

   //文件名：EquString.java   

public class EquString {
	public static void main (String[] args) 
	{
		String str = "good";
		String cmpStr = "good";
		String upcaseStr = "GOOd";
		String anotherStr = "hi";	
		
		System.out.println(str.equals(cmpStr));//不忽略大小写
		System.out.println(str.equals(upcaseStr));//不忽略大小写		
		System.out.println(str.equalsIgnoreCase(upcaseStr)); //忽略大小写
		System.out.println(str.equalsIgnoreCase(anotherStr)); //忽略大小写			
	}
}

   equals函数是在不忽略大小写的情况下，用来比较一个字符串和另一个字符串是否相等。

   equalsIgnoreCase函数是在忽略大小写的情况下，来比较两个字符串是否相等。

 

    9.字符串的长度

      指一个字符串里所包含字符系列的个数。String类提供了一个无参数的函数length来返回字符串的长度，该函数的返回值类型为int型。

   //文件名：StringLength.java   

public class StringLength {
	public static void main (String[] args) 
   	{
   		String s = "I'm a String!"; //13
   		int len = s.length();
   		System.out.println("I'm a String!的长度是:" + len);   		
	}
}

    注意：数组是length属性，没有括号。字符串是length方法，有括号length()。

 

    10.去除字符串的前后的空格

       String类提供了无参数函数trim可以将一个字符串开始和结尾的所有空格都去掉。

   //文件名：StringTrim.java   

public class StringTrim 
{
	public static void main (String[] args) 
	{
		String s = "     Hello      ";
		System.out.println("去除空格前:" + s);
		String str = s.trim();
		System.out.println("去除空格后:" + str);
	}
}

 

    11.获取字符串中的指定字符串

       String类中的charAt函数和getChars函数可以获得一个字符串中的字符,其中charAt(可以获取一个指定索引处的字符),而getChars可以获取一个字符数组

       str.charAt(int index)
       str.getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
       srcBegin - 字符串中要复制的第一个字符的索引, 包含此处的字符。
       srcEnd - 字符串中要复制的结束索引, 不包含此处的字符。
       dst - 目标数组。
       dstBegin - 目标数组中的起始下标。

   //文件名：GetChars.java  

public class GetChars 
{
	public static void main (String[] args) 
	{
		String s = "Nice to meet you!";
		char c = s.charAt(5); //t
		System.out.println(c);
		
		int startIndex = 3;
		int endIndex = 8;
		char[] cArray = new char[endIndex-startIndex];
		
		System.out.println("cArray数组中的内容为:");
		s.getChars(3,8,cArray,0); //e to
		for(int i=0; i<cArray.length; i++)
		{
			System.out.println(cArray[i]);
		}		
	}    
}

 

     12. 测试字符串的前后缀

      在字符串的使用中,会有判断一个字符串是否以指定的字符串开始或结尾的操作,可以利用String类提供的startsWith和endsWith函数来实现这种操作.返回值都是布尔型。

      开始:true

      不开始:false

  //文件名：StartEndString.java  

public class StartEndString {
	public static void main (String[] args) 
	{
		String s = "This is a book";		
		System.out.println(s.startsWith("This")); //true
		System.out.println(s.startsWith("Th"));	//true	
		System.out.println(s.startsWith("is"));//false
		System.out.println(s.endsWith("book"));	//true	
		System.out.println(s.endsWith("boo"));//false			
	}   
}

 

    13.使用split函数进行字符串分割

      字符串分割,就是按一定的规则把指定字符串拆分成多个字符串的操作,返回的是一个String[ ]

  //文件名：SplitString.java   

public class SplitString {
	public static void main (String[] args) 
	{
		String str = "Process completed Configuration: <Default>";
		
		String[] strArray1 = str.split(" ");
		System.out.println("按\" \"分后的数组是:");
		for(int i=0; i<strArray1.length; i++)
		{
			System.out.println(strArray1[i]);
		}
		System.out.println();
		
		String[] strArray2 = str.split(":");
		System.out.println("按:分割后的数组是:");
		for(int i=0; i<strArray2.length; i++)
		{
			System.out.println(strArray2[i]);
		}
		System.out.println();
	}
}

 

    14.关于args

      static void main(String[] args)

      main函数是程序的主函数，该函数是静态函数并且没有返回值。Java应用程序在执行的时候，会首先执行该函数。

      函数的参数是一个字符串类型的数组String[] args。该数组用来接收从命令行传过来的参数，多个参数之间使用空格隔开。这些命令行传入的参数通过args数组传递给main函数进行处理。

 

   15.输入和输出

      从键盘读入数据

      Java语言提供的类InputStream可以从外部数据源获得输入。

      OutputStream可以对数据进行输出。

      read()和write()这两个无参函数分别实现了对数据进行读取和输出功能。

      System.in是一个定义好的输入流变量，可以读取键盘输入的内容。

  //文件名：BRReaderLines.java  

import java.io.*;

public class BRReaderLines {
	public static void main (String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int lines = 100;
		String[] str = new String[lines];
		int i = 0;

		do
		{
			str[i] = br.readLine();
			
			if(i >= 99)
			{
				break;
			}
		}while(!str[i++].equals("stop"));

		for(int j = 0; j<str.length; j++)
		{
			if(str[j] == null)
			{
				break;
			}
			System.out.println(str[j]);
		}
	}
}