Java学习07-String类，StringBuilder，其它包装类

1.String类的初始化

String s1 = "abc";//s1是一个类类型变量， "abc"是一个对象。

      //字符串最大特点：一旦被初始化就不可以被改变。

  String s2 = new String("abc");

 

s1和s2的区别：
s1在字符串常量池中创建了一个abc字符串
s2在堆中创建了两个对象一个是默认对象一个是字符串对象。

==和equals的区别

比较的是内容。
==比较的是地址，equals比较的是内容

   System.out.println(s1==s2);            false

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

String类复写了Object类中equals方法，

  该方法用于判断字符串是否相同。

2.String 类基本操作。

String类适用于描述字符串事物。

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

常见的操作有哪些？

"abcd"

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在字符串中出现的位置。

  int lastIndexOf(int ch) ： 找最后一个出现的位置。

 

2），判断。

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

  boolean contains(str):

  特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。

    所以，也可以用于对指定判断是否包含。

    if(str.indexOf("aa")!=-1)

  而且该方法即可以判断，有可以获取出现的位置。 

 2.2 字符中是否有内容。 

  boolean isEmpty(): 原理就是判断长度是否为0.

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

  boolean startsWith(str);

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

  boolean endsWith(str);

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

  boolean equals(str);

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

  boolean equalsIgnoreCase();

 

3），转换。

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

  构造函数：String(char[])

      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 将字节数组转成字符串。

   String(byte[])

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

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

   byte[]  getBytes():

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

  static String valueOf(int)

  static String valueOf(double)

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

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

4），替换

 String replace(oldchar,newchar);

如果要替换的字符不存在，则返回原字符串。

替换过程原字符串不会变化，而是新建了一个字符。

5）切割

 String[] split(regex);

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

 String substring(begin);

 String substring(begin,end); 包含头，不包含尾

70，转换，去除空格，比较。

 7.1 将字符串转成大写或则小写。

   String toUpperCase();

   String toLowerCase();

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

  String trim();

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

  int compareTo(string);

/*
练习
1，模拟一个trim方法，去除字符串两端的空格。
 思路：
 1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
  结尾处判断空格也是如此。
 2，当开始和结尾都判断到不是空格时，就是要获取的字符串。


2，将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
 思路：
 1，曾经学习过对数组的元素进行反转。
 2，将字符串变成数组，对数组反转。
 3，将反转后的数组变成字符串。
 4，只要将或反转的部分的开始和结束位置作为参数传递即可。

3，获取一个字符串在另一个字符串中出现的次数。
 "abkkcdkkefkkskk"
 思路：
 1，定义个计数器。
 2，获取kk第一次出现的位置。
 3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
  每获取一次就计数一次。
 4，当获取不到时，计数完成。

4，获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
 "abcwerthelloyuiodef"
 "cvhellobnm"
 思路：
  1，将短的那个子串按照长度递减的方式获取到。
  2，将每获取到的子串去长串中判断是否包含，
   如果包含，已经找到！。

*/

class Test{
	public static String trim(String s){
		// 去除空格方法
		int pos =0;
		int index = s.length()-1;
		while(pos<index&&s.charAt(pos)==' '){
			pos++;
		}
		while(s.charAt(index)==' '){
			index--;
		}
		return s.substring(pos,index+1);
		// +1因为结尾不包含
	}
	public static int keyCount(String s,String key){
		int index=0;
		while(s.indexOf(key)!=-1){
			int pos= s.indexOf(key);
			s=s.substring(pos+key.length());
			index++;
		}
		return index;
	}	


	public static String reverse(String s){
		char[] c = s.toCharArray();//先变成字节数组
		reverseChar(c);//数组反转
		return String.valueOf(c);//数组转成字符

	}
	public static void  reverseChar(char[] c){
		// 定义数组反转方法
		int start =0;
		int end = c.length-1;
		while(start<end){
			swap(c,start++,end--);
		}
	}
	public static String maxSubString(String s1,String s2){
		// 定义求最大子串
		String max, min;
		max = (s1.length()>s2.length()?s1:s2);
		min = (s1==max?s2:s1);
		for (int i = 0;i<min.length() ;i++ ) {
			for (int j=0,k=s1.length()-i;k!=min.length()+1 ;j++,k++ ) {
				String temp = min.substring(j,k);
				if (max.contains(temp)) {
					return temp;
				}
			}
		}
		return "";
	}
	public static void swap(char[] a,int i, int j){
		// 数组内元素互换
		char temp;
		temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}		
}
public class TrimDemo{
	public static void main(String[] args) {
		String s1 = "   hello  java    ";
		String s2 = "nuddles is learning java";
		// sop(Test.trim(s));
		// sop(Test.reverse(s));
		// String key = "a";
		// sop(Test.keyCount(s,key));
		sop(Test.maxSubString(s1,s2));
		
	}
	public static void sop(Object obj){
		// 这种方法打印更方便
		System.out.println(obj);
	}
}

3.StringBuffer类

StringBuffer是字符串缓冲区。

是一个容器。

特点：

1，长度是可变化的。

2，可以字节操作多个数据类型。

3，最终会通过toString方法变成字符串。

C create U update R read D delete

1，存储。

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

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

2，删除。

 StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。

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

 

3，获取。

 char charAt(int index)

 int indexOf(String str)

 int lastIndexOf(String str)

 int length()

 String substring(int start, int end)

 

4，修改。

 StringBuffer replace(start,end,string);

 void setCharAt(int index, char ch) ;

5，反转。

 StringBuffer reverse();

 

6，

 将缓冲区中指定数据存储到指定字符数组中。

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

 

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

StringBuffer是线程同步。

StringBuilder是线程不同步。

以后开发，建议使用StringBuilder

升级三个因素：

1，提高效率。

2，简化书写。

3，提高安全性。

/*
判断一段字符串是否是回文

*/


public class Huiwen  {
	public static void main(String[] args) {
		Long  l = 12345654321L;
		String s = l.toString();
		StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		String s1 = sb.toString();
		System.out.println(s.equals(s1));
		if (s.equals(s1)) {
			System.out.println(Long.parseLong(s1));
		}
	}
}

4.其它包装类

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

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

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

 Integer i = new Integer("123");

 int num = i.intValue();

 

十进制转成其他进制。

 toBinaryString();

 toHexString();

 toOctalString();

其他进制转成十进制。

 parseInt(string,radix);

关于自动装箱和自动拆箱

Integer x = new Integer(4);

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

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

     //再将和进行装箱赋给x。

class IntegerDemo {
	public static void main(String[] args) {
		// sop(Short.MAX_VALUE.toString);
		sop(Integer.toString(34));
		String s = "123";
		sop(Integer.parseInt(s)+5);
		sop(Integer.toBinaryString(-6));
		sop(Integer.toHexString(60));
		sop(Integer.parseInt("1110",2));
		Integer m =128;
		Integer n =127;
		sop(m.compareTo(n));
		sop(m==n);
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
} 

-----------OUTPUT-----------  
34
128
11111111111111111111111111111010
3c
14
1
false