Java String用法,Java String类怎么用?

String常见用法

1、获取

      1.1、字符串中包含的字符数,也就是字符串的长度:int  length()。注意:数组中的是length属性,String类中是length();


public class StringMethodDemo {
	public static void main(String[] args) {
		StringMethodDemo();
	}
	
	public static void StringMethodDemo(){
		String s = new String("abcde");
		System.out.println("len="+s.length());//通过String类的length()方法来获取字符串的长度,这里我们需要和数组中的length属性区分开
	}

}


      1.2、根据位置获取对应位置上的字符。char  charAt(int index).当访问到字符串中不存在的角标时会发生StringIndexOfBoundsException


public class StringMethodDemo {
	public static void main(String[] args) {
		StringMethodDemo();
	}
	
	public static void StringMethodDemo(){
		String s = new String("abcde");
		System.out.println("char="+s.charAt(2));//通过charAt()方法打印指定位置的字符,如果指定位置不存在,则会报字符串角标越界异常
	}

}

       1.3、根据字符获取该字符在字符串中的位置。int  indexOf(int  ch),返回的是ch在字符串中第一次出现的位置,;为什么接收的是int呢?因为接收的是ASCII码。

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

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

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

                int   lastIndexOf(String str):反向索引一个字符出现的位置。

public class StringMethodDemo {
	public static void main(String[] args) {
		StringMethodDemo();
	}
	
	public static void StringMethodDemo(){
		String s = new String("abcdae");
		System.out.println("index="+s.indexOf('a'));//指定字符第一次出现的位置
		System.out.println("index="+s.indexOf('k'));//如果指定字符在字符串中不存在则返回-1
		System.out.println("lastIndex="+s.lastIndexOf('a'));//指定字符最后一次出现的位置
	}

}


截取字符串中的一部分:

String substring(int  beginIndex,int  endIndex);从指定位置开始,到指定位置结束

String substring(int beginIndex)从指定位置开始到末尾

2、判断

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

boolean  contains(CharSequence  s);

特殊之处:IndexOf(str):可以索引str第一次出现位置,如果返回-1,表示该str不在字符串中存在。所以也可以用于对指定判断的包含。而且该方法既可以判断,又可以获取出现的位置。

      2.2、字符串中是否有内容。

boolean  isEmpty(str);  JDK1.6才出现,原理就是判断长度是否为0

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

 boolean  startsWith(str);

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

boolean  endsWith(str);

      2.5、判断字符串内容是否相同。

boolean   equals(str)。复写了Object的equals方法。

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

boolean  equalsIgnoreCase(str)。

3、转换

      3.1、将字符数组转成字符串。

构造函数:String(char [ ] )

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

静态方法:

   static  String  copyValueOf(char [ ]);

   static  String  copyValueOf(char [ ],offeset,count);

   static  String  valueOf(char [ ]);

      3.2、将字符串转成字符数组。

      char [ ] toCharArray();  

      3.3、将字节数组转成字符串。

String(byte [ ] )

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

      3.4、将字符串转成字节数组。

byte[ ] getBytes();

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

               static  String valueOf(int);

      static   String  vlaueOf(double);

3+"";//String.valueOf(3);

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

4、替换

      String replace(oldchar,newchar);如果要替换的字符串不存在,返回的还是原字符串。

     String replaceAll(String regex,String replacement):按照指定的规则进行替换。

5、切割

     String [] split(regex);

public class StringMethodDemo {
	public static void main(String[] args) {
		StringMethodDemo();
	}
	
	public static void StringMethodDemo(){
		String s = "张三,李四,王武";
		String[] arr = s.split(",");//调用split()方法按照指定的规则进行切割
		
		for(int x = 0;x<arr.length;x++){
			System.out.println(arr[x]);
		}
	}

}


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

     String subString(begin);   从指定位置开始到末尾位置,如果角标不存在,会出现角标越界异常。

     String subString(begin,end);从指定位置开始,到指定位置结束。注意:包含头,不包含尾。

7、转换、取出空格、比较。

      7.1、将字符串转成大写或者小写

            String toUpperCase();

       String toLowerCase();

      7.2、将字符串两端的多个空格去除。

    String trim();

      7.3、对两个字符串进行自然顺序的比较。

    int compareTo(str);如果参数字符串等于此字符串,则返回值0;如果此字符串按字典顺序小于字符串参数,则返回一个小于0的值;如果此字符串按字典顺序大于字符串参数,则返回一个大于0的值。

关于String的练习:

public class StringTest {
	public static void main(String[] args) {
		// String str = "      abc sd     ";
		String str = "abckkadskksdaskksd";
		// sop(myTrim(str));
		// sop(reverseString(str, 6, 14));
		// sop(getSubCount_2(str, "kk")+"");
		String str1 = "asaasfadffgdfhd";
		String str2 = "sfgdasdaa";
		sop(getMaxSubString(str1, str2));
	}

	public static void sop(Object obj) {
		System.out.println(obj);
	}

	// 练习四:两个字符串中最大相同的子串  

/* 
 思路:
①既然取的是最大子串,先看短的那个字符串是否在长的那个字符串中。如果存在,短的那个字符串
就是最大子串。
②如果不是,那么就将短的那个子串进行长度递减的方式去子串,去子串中判断是否存在。如果存在
就已找到,就不用再找了。*/
	public static String getMaxSubString(String str1, String str2) {
		String max = "", min = "";
		max = (str1.length() > str2.length()) ? str1 : str2;//三元运算,当str1长度大于str2时,将str1赋给max
		min = (max == str1) ? str2 : str1;

		for (int x = 0; x < min.length(); x++) {
			for (int y = 0, z = min.length() - x; z != min.length() + 1; y++, z++) {
				String temp = min.substring(y, z);
				// sop(temp);
				if (max.contains(temp))
					return temp;
			}
		}
		return null;
	}

	// 练习三:方式二:一个子串在整串中出现的次数

/*
思路:
①要找的子串是否存在,如果存在获取其出现的位置,这个可以使用indexOf完成。
②如果找到了,那么就记录出现的位置并在剩余的字符串中继续查找该子串,而剩余字符串的起始位
是出现位置+子串的长度。
③以此类推,通过循环完成查找,如果找不到就是-1,并且每次找到用计数器记录。*/
	public static int getSubCount_2(String str, String key) {
		int count = 0;
		int index = 0;
		while ((index = str.indexOf(key, index)) != -1) {
			index = index + key.length();
			count++;
		}
		return count;
	}

	// 练习三:

	public static int getSubCount(String str, String key) {
		int count = 0;
		int index = 0;
		while ((index = str.indexOf(key)) != -1) {
			str = str.substring(index + key.length());
			count++;
		}
		return count;
	}

	// 练习一:模拟一个trim功能方法,去除字符串两端的空白。

/*
思路:
①定义两个变量。
一个变量作为从头开始判断字符串空格的角标,不断++。
一个变量作为从尾开始判断字符串空格的角标,不断--。
②判断到不是空格为止,取头部之间的字符串即可<*/

	public static String myTrim(String str) {
		int start = 0;
		int end = str.length() - 1;
		while (start <= end && str.charAt(start) == ' ') {
			start++;
		}
		while (start <= end && str.charAt(end) == ' ') {
			end--;
		}

		return str.substring(start, end + 1);
	}

	// 练习二:将字符串进行反转
	public static String reverseString(String str, int start, int end) {
		// 字符串变成数组
		char[] arr = str.toCharArray();
		// 反转数组
		reverse(arr, start, end);
		// 数组变成字符串
		return new String(arr);

	}

	public static String reverseString(String str) {

		return reverseString(str, 0, str.length());

	}

	private static void reverse(char[] arr, int x, int y) {
		// TODO Auto-generated method stub
		for (int start = x, end = y - 1; start <= end; start++, end--) {
			swap(arr, start, end);
		}
	}

	private static void swap(char[] arr, int start, int end) {
		// TODO Auto-generated method stub
		char temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;

	}
}



StringBuffer:是一个字符串缓冲区,他是一个容器。而且长度是可变化的,数组也是容器,但是长度是固定的。StringBuffer可以操作多种数据类型,但数组只能操作一种数据类型,最终可以通过toString方法变成字符串。

1、存储

      StringBuffer  append():将指定数据作为参数添加到已有数据结尾处。

      StringBuffer  insert(int  offset,数据):可以将数据插入到指定offset位置

2、删除

      StringBuffer  delete(start,end):删除缓冲区中的数据,包含start,不包含end。清空缓冲区:sb.delete(0,str.length());

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

3、获取

      char  charAt(index)

      int  indexOf(String  str)

      int  lastIndexOf(String  str)

      int  length()

     String   substring(int  start,int  end)

4、修改

     StringBuffer  replace(int  start,int  end,String  str)

     void  setCharAt(int  index,char  ch)

5、反转

    reverse();

6、void  getChars(int  srcBegin,int  srcEnd,char[] dst,int dstBegin):将缓冲区中指定数据存储到指定字符 数组中。

在JDK1.5出现了StringBuilder,StringBuilder是StringBuffer一个简易的替换 ,但StringBuilder是线程不同步的,是线程不安全的。StringBuffer是线程安全的。如果在单线程的情况下,我们建议使用StringBuilder,效率会比StringBuffer高,多线程使用StringBuffer,但我们也可以在多线程的时候使用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.pareseXxx(String);

       int  a = Integer.pareseInt("123");//必须传入数字格式的字符串

      Integer i = new Integer("123");

      int num = i.intValue();

十进制转成其他进制

       toBinaryString()

       toHexString()

       toOctalString()

其他进制转成十进制

     pareseInt(String,radix);


Integer  x = new Integer("123");

Integer  y = new Integer(123);

x==y   x.equals(y)我们通过验证发现==时为false,因为两者是分别new的一个对象,equals时为true,因为Integer里面重写了equals方法,两个值相同。

JDK1.5版本以后出现的新特性:

Integer  x = new  Integer(4);

Integer x = 4;//自动装箱。//new Integer(4);

x = x/*自动拆箱:x.intValue()*/+2;//x+2:x进行了自动拆箱。变成了int类型,和2进行加法运算,再将和进行装箱赋给x

Integer  默认值是null。

Integer m = 128;

Integer  n= 128;

m==n?结果为false

Integer x= 127;

Integer y = 127;

x==y? 结果为true,因为x和y指向了同一个对象。因为当数值在byte范围内时,对于新特性,不会再开辟新的空间,如果该数值已经存在,则不会开辟新的空间。


版权声明:本文为JAVASCHOOL原创文章,未经本站允许不得转载。