String类，StringBuffer和基本数据类型对象包装类(java基础)

一、字符串

1. 字符串特点

/*
 * @字符串最大特点，一旦初始化就不可以改变。  
 */
public class StringDemo {

	public static void main(String[] args) {
		//两种初始化方式s1 and s2
		String s1 = new String("test");//test是一个对象，然后new一个对象。所以是两个对象。
		String s2 = "test";
		/*
		 s1和s2所达到的效果是一样的，但是他们是有区别的。
		 区别：s1代表了两个对象
		    s2代表了一个对象
		 */
		System.out.println(s1==s2);
		System.out.println(s1.equals(s2));//String类复写了Objext类中的equals方法，该方法用于判断两个字符串是否相等。
	}

}

2.字符串常见操作

/*
 * @常见的字符串操作。"abcd"。
 * 
 * @1.获取：
 * @int length():获取字符串长度。
 * @char charAt(int index);获取字符串中某个固定位置的字符。
 * @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(char ch)//从右往左查找ch第一次出现的位置
 * 
 * @2.判断：
 * @boolean contains(String str)；//字符串中是否包含str字符串。此处用indexOf也可以达到效果
 * @boolean isEmpty();//判断字符串是够为空，即长度是否为。
 * @boolean startsWith(String str)//判断字符串是够以str开头
 * @boolean endsWith(String str)//判断字符串是够以str结尾
 * 
 * 
 * @3.转换:
 * @//构造函数
 * @String(char[]);//将字符出租转换为字符串。
 * @String(char[],int offset,int count);//将字符数组中的一部分转换成字符串。从字符数组中取出从第offset个字符开始的是count个字符，组成一个字符串
 * 
 * @//静态方法
 * @static String copyValueOf(char[],int offset,int count)//效果同上。
 * 
 * @//将字节数组转换成字符串，将char[]变为byte[]。
 *  
 * @//将字符串变为字符数组。****
 * @char[] toCharArray();
 * 
 * 
 * @4.替换:
 * @Stringreplace(oldchar,newchar)；//返回的是一个新字符串。如果要替换的字符不存在，返回的还是原字符串。
 * 
 * 
 * @5.切割：
 * @String[] split(regex)；//涉及到正则表达式的点，不能作为切割字符串的regex。
 * 
 * @6.字串
 * @String substring(begin)；//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
 * @Stringsubstring(begin,end)；//包含头，不包含尾。
 * 
 * @7.其他：
 * @字符串大小写转换：
 * @StringtoUpperCase();
 * @String toLowerCase();
 * @去除字符串两端的空格:
 * @String trim(); 
 * @字符串比较://自然顺序切割<span id="transmark"></span>
 * intcompareTo(String);
 */

public class StringDemo2 {

    public static void StringDemo2_get()//获取演示
    {
        String str = "abcdefghbj";
        sop(str.length());//获取str的长度
        sop(str.charAt(3));//获取字符串中第三个字符，注意计算机是从0开始计数。但是不能超过总长度，否则会出现越界。
        //没有查找到的时候，返回一个-1.
        sop(str.indexOf('b'));//获取b字符出现的位置。
        sop(str.indexOf(2,'a'));//从第二个字符开始查找a出现的位置。
        sop(str.lastIndexOf('b'));//从右往左查找b第一次出现的位置
    }
    
    public static void StringDemo2_is()//判断演示
    {
        String str = "ArrayDemo.java";
        //判断文件名称是否是Array开头。
        sop(str.startsWith("Array"));
        //判断文件名称是否是java结尾。
        sop(str.endsWith("java"));
        //判断文件中是否包含Demo
        sop(str.contains("Demo"));
    }
    
    public static void StringDemo2_trans()//转换演示
    {
        char[] Arr = {'A','r','r','a','y','D','e','m','o','.','j','a','v','a'};//定义一个字符数组
        String s1 = new String(Arr,1,3);//从Arr中取出从第一个字符开始的是三个字符，组成一个字符串
        System.out.println(s1);
        
        String s2 = "toArray";
        char[] Arr1 = s2.toCharArray();
         for(int i = 0; i < Arr1.length; i++)
         {
             sop("ch="+Arr1[i]);
         }
    }
    
    public static void sop(Object obj)//1.5版本后新特性，可以传入基本类型数据。即既可以传入int类型，也可以传入string类型。
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
//        StringDemo2_get();
        StringDemo2_trans();

    }

}

二、StringBuffer

            string对象只要一旦初始化就不可更改，但是StringBuffer可以。注意：StringBuffer是一个容器，他很多方法都跟String相同，它可以增删改查。

/*
 **@StringBuffer基本操作
 * @特点：
 * 1.是一个容器 且长度可变，String长度不可变。 
 * 2.可以字节操作多个数据类型 
 * 3.最终可以通过Tostring变为字符串。
 * 
 * @存储：
 * 1.append();将制定数据作为参数添加到已有数据结尾。
 * 2.insert(index,数据);可以将数据插入到指定的index位置。index表示索引位置。
 * 
 * @删除：
 * 1.StringBufferedelete(start,end)：删除缓冲区中的数据，包含start，不包含end。
 * 2.StringBuffer deleteCharAt(index)：删除指定位置的字符。
 * 3.清空缓冲区：对象.delete(0,对象.length());
 * 
 * @获取：
 * 1.char charAt(int index);
 * 2.int indexOf(String str);
 * 3.int lastIndexOf(String str);
 * 4.int length();
 * 5.String substring(int start,int end);
 * 
 * @修改：
 * 1.StringBuffer replace(int start,int end,String str);
 * 2.void setCharAt(int index,char ch);
 * 
 * @反转：
 * StringBuffer reverse();
 * 
 * @将缓冲区中指定数据存储到指定字符数组中
 * voidgetChars(int srcBegin, int srcEnd,char[] dst,int dstBegin);
 * 
 * @StringBuffer和StringBuilder区别
 *  StringBUffer有锁，且是线程同步的，效率低下。
 *  StringBuilder无锁，不同步，效率高。
 *  开发，建议使用StringBuilder。如遇多线程，使用StringBuffer或自己加锁。
 * 
 */

public class StringBufferDemo {	
	public static void main(String[] args) {
		
		StringBuffer str = new StringBuffer();//初始化
		str.append("String--").append('c').append(1).append(true);//存储，里面的参数可以是字符串，字符，数字，bool值。
		sop(str.toString());
		
		StringBuffer str1 = new StringBuffer();
		str1.append("abc");
		str1.insert(1, "insert");//在1的位置插入一个字符串
		sop(str1.toString());
		
	}
	
	public static void sop(String obj)//输出
	{
		System.out.println(obj);
	}

}

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

概述：

/* @基本数据类型对象包装类:
 * byte    Byte
 * short   Short
 * int     Integer
 * long    Long
 * boolean Boolean
 * float   Float
 * double  Double
 * char    Character
 * 
 * @作用：
 * 基本数据类型和字符串类型之间的互相转换
 * 1.基本数据类型黄转字符串类型
 *   基本数据类型.toString(基本数据类型值);如： Integer.toString(32);
 * 2.字符串数据类型转基本数据类型
 *   xxx a = xxx.parsexxx(String);
 *   如：int a = Integer.parseInt("123");
 */

进制转换：

* 1.十进制转其他进制：
 * toBinaryString();//十进制转二进制
 * toHexString(); //十进制转十六进制
 * toOctalString();//十进制转八进制
 * 2.其他进制转换
 * parseInt(String str,int x);//把x进制类型的str转换为10进制。
 * 如：parseInt("3c",16);结果为60
 */

jdk1.5后新特性：

Integer x = new Integer("127")；

Integer y = new Integer("127")；

Integer m = new Integer("128")；

Integern= new Integer("128")；

x==y？：返回true，因为x，y指向了同一对象。数值在byte范围内容，对于新特性，如果该数值存在，不会开辟新空间，创建新对象。

m==n？：返回false，byte的范围是：-128~127

自动装箱：

 Integer x=new Integer(4);//等效于：Integer x=4;
可以直接进行运算：x=x+2;//x进行自动拆箱。变成了int类型。和2进行加法运算。再将和进行装箱赋给x。这里需注意的是如果 Integer x=null时候，不能这样运算，会报异常。

x的拆箱动作等效：x.intValue()。

四、练习

<span id="transmark"></span>package String_exam;


/*
 * @题目：对一个字符串中的n个数字进行排序，并按从小到大输出。
 * "1,20,5,-3,0,-20,1.5,25,-1.1,0,-3,5"
 * 思考：
 * 1.用字符串切割对字符串进行切割。
 * 2.将其转换成整数型数组。
 * 3.对数组进行快速排序。
 * 4.将数组转换成字符串并打印。
 */




public class String_test {
	
	public static void main(String[] args)
	{
		String S1 = "1,20,5,-3,0,-20,1.5,25,-1.1,0,-3,5";
		System.out.println("排序前---"+S1);
		sor(S1);
	}
	
	public static void sor(String s)//转换排序过程
	{
		//切割字符串并转换成字符数组
		String[] str = s.split(",");
		//将字符数组转换成实数数组
		double[] Array1 = stringToDouble(str);
		double[] Array2 = stringToDouble(str);
		//对此实数型数组进行快速排序或冒泡排序
		sort1(Array1, 0, Array1.length-1);//快速排序
		sort2(Array2);//冒泡排序
		//将数组转化为字符串类型
		String st1 = DoubleToString(Array1);
		String st2 = DoubleToString(Array2);
		//输出结果
		System.out.println("快速排序：");
		sop(st1);
		System.out.println("冒泡排序：");
		sop(st2);
	}
	
	
	private static double[] stringToDouble(String[] str)//将字符数组转换为数字型数组
	{
		double[] arr = new double[str.length];
		for(int i = 0; i <str.length; i++)
		{
			arr[i] =Double.parseDouble(str[i]);//字符->实数
		}
		return arr;
	}
	
	private static void sort1(double[] s,int low,int high)//快速排序
	{
		if(low >= high) return;//当不能再拆分时候返回。
		int l = low;//顺位标记
		int h = high;//逆位标记
		double key = s[low];//关键数
		while(l<h)//当数组的顺位上标小于数组逆位上标时候，循环
		{
			while(l<h&&s[h]>key)//从后向前找小于等于key的值
				h--;
			if(l<h)
			{
				s[l] = s[h];//找到值将其赋给s[l]
				l++;
			}
			while(l<h&&s[l]<key)//从前向后找大于等于key的值
			l++;
			if(l<h)
			{
				s[h]=s[l];//找到值后将其赋给刚才空缺的s[h];
			}
			
		}
		if(l==h) s[l]=key;//第一遍结束，填坑
		sort1(s, low, h-1);//对s[l]的前半段进行排序
		sort1(s, l+1, high);//对s[l]的后半段进行排序
		
	}

	private static void sort2(double[] s)//冒泡选择排序
	{
		double temp = 0;
		int kk;//记录最终选择的数组的下标
		for(int i=0;i<s.length-1;i++)
		{
			kk = 0;
			temp = s[i];
			for(int j=i+1;j<s.length;j++)
			{
				if(s[j]<temp) 
				{
					temp = s[j];
					kk = j;
				}
			}
			if(kk!=0)
			{
			s[kk] = s[i];//选择好了之后再将s[i]与s[kk]交换。
			s[i] = temp;
			}
		}	
	}
	
	
	private static String DoubleToString(double[] s)//将数组转化为字符串
	{
		StringBuilder str = new StringBuilder();
		for(int i =0; i <s.length;i++)
		{
			str.append(s[i]+" ");
		}
		
		return str.toString();
		
	}
	
	private static void sop(String str)
	{
		System.out.println(str);
	}

}