黑马程序员_基本数据类型包装类

------- android培训、java培训、期待与您交流！ ----------

基本数据类型对象包装类                                        

想要对基本类型数据进行更多的操作，最方便的方式就是将其封装成对象。             

为啥呢？因为在对象描述中就可以定义更多的属性和行为对该基本类型数据进行操作。   

• byte Byte     
• short Short    
• int Integer  
• long Long     
• float Float    
• double Double   
• char Character
• boolean Boolean  

基本类型变成对象的好处：可以将基本数据和字符串之间进行互相转换。        
你知道int类型的取值范围是多少吗？
这就应该去查Integer对象。       

基本类型数据--->字符串。                                                  

• 基本数据类型对象包装类中的方法 static String  toString(基本类型);  
• String类中的方法 static String valueOf(基本类型);                  
• 基本类型数据+""                                                    

                                                                          
重点要掌握的就是：                                                        

• 字符串--->基本类型数据。                                                  
• 基本类型     参数，字符串。                                          
• 基本类型  parse基本类型类名(是基本类型格式的字符串)    

	Xxx  parseXxx(XxxString);//NumberFormatException                     
	long parseLong(longString);                                          
	boolean parseBoolean(booleanstring);

                                                                       

在八个基本类型对象包装类中只有一个对象没有parse方法。就是Character   

十进制-->其他进制。        

二进制：static String toBinaryString(int);
十六进制 static String  toHexString(int); 
八进制 static String toOctalString(int);  

                              
其他进制-->十进制。                            

	int parseInt(intString,radix);       

例如：

System.out.println(Integer.toBinaryString(-6));  
System.out.println(Integer.toString(6,2));       
System.out.println(Integer.parseInt("110",2));   

基本数据类型值和基本类型数据对象之间的转换。                                                       

• 基本数据类型值---->基本类型数据对象。                                   
• 使用构造函数。即可以接收基本数值，也可以接收基本数值的字符串形式。 
• 可以使用基本类型对象中的方法。 static Integer  valueOf(int);       

                                                                        
基本类型的对象--->基本数据类型数值。                                    
int intValue();   

例如：

Integer i = new Integer("34"); 
int num = i.intValue();        
System.out.println(num+1);

• 基本数据类型对象包装类jdk1.5后的新特性。  
• 新特性的出现无非就是简化书写。                                
• 让这些对象可以象操作基本数值一样进行运算。     
• 基本数据类型对象包装类，对象创建的简化写法。

自动装箱。自动完成了对象创建的动作。Integer.valueOf(5);

Integer i = new Integer(5); 
Integer i = 5;//i = new Integer(5)

右边的i会先转成基本数据值(自动拆箱)，然后再和5进行加法运算。
=右边运算完的结果，再次被自动装箱变成Integer对象赋给i。

i  = i/*.intValue()*/ + 5;

一旦简化就有弊端：多具备一个值null。记住要使用自动装箱拆箱时，建议进行null的健壮性判断。

Boolean b = true;和boolean b = true;有什么不同？
前面的b是对象的引用，后面一个b是基本类型的变量

测试一下代码，加深理解记忆：
对象引用；基本类型数据变量

Integer a = new Integer(127);                                
Integer b = new Integer(127);                                
System.out.println(a==b);//false                             
System.out.println(a.equals(b));//true                       
System.out.println("---------------------------------");     
Integer m = 127;                                             
Integer n = Integer.valueOf(127); 

在jdk1.5后的新特性自动装箱中，                                                        
如果数值在byte类型范围内。如果该对象数值重复出现，多个引用其实指向的同一个Integer对象。
但是如果超出byte范围，都会生成新的Integer对象                

System.out.println(m==n);//true         
System.out.println(m.equals(n));//true

jdk1.5后的新特性就是简化书写，完成自动装箱和拆箱的动作。  

装箱：

Integer.valueOf(int); Xxx.valueOf(xxx);

拆箱：

intValue() xxxValue():  booleanValue();

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);

7，转换，去除空格，比较。
7.1 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();

7.2 将字符串两端的多个空格去除。
String trim();

7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);

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

class  StringTest3
{
	/*
	练习四。
	*/
	public static String getMaxSubString(String s1,String s2)
	{

		String max = "",min = "";

		max = (s1.length()>s2.length())?s1: s2;

		min = (max==s1)?s2: s1;
		
//		sop("max="+max+"...min="+min);
		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))//if(s1.indexOf(temp)!=-1)
					return temp;
			}
		}
		return "";
	}


	public static void main(String[] args) 
	{
		String s1 = "ab";
		String s2 = "cvhellobnm";
		sop(getMaxSubString(s2,s1));
	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}

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，提高安全性。

综合练习：                                                         
"34 9 -7 12 67 25"要求对这个字符串中的数值进行从小到大的排序，     
然后生成一个数值有序的字符串。                                     
                                                                   
思路：                                                             

• 看到排序，就想要到了数组                                        
• 那数组中的元素怎么获取呢？数值都在字符串中。                    
• 先从字符串中获取到这些具体的数值。怎么获取呢？                  
• 发现这个字符串居然有规律。数值之间都是由空格隔开的。可以对字符串进行切割。                                        
• 将获取的数据存储到数组中并排序，在将数组转成字符就可以了。                                                                                                                     

步骤：                                                             

• 将字符串切割成字符串数组。split。                               
• 定义一个int数组将字符串数组中的元素转成整数存储到int数组中。    
• 对int数组排序。                                                 
• 将int数组排序后转成一个字符串。            

package com.itheima.api;
import java.util.Arrays;
public class Demo4
{
	public static void main(String[] args)
	{
		sop("hello,word!");
		// 对一字符串数字排序,"-5 2 54 8 56 7 98"
		/*
		 * 1. 排序，所以用数组，将字符串转换为数组
		 * 2. 怎么转换呢？用split进行切割
		 * 3. 获取的数据存到Int数组中并排序，最后转换为字符串
		 */
		
		String str = "-5 2 54 8 56 7 98";
		str = sortStringNum(str);
		sop(str);
	}
	public static String sortStringNum(String str)
	{
		// 1. 切割字符串
		String[] strNum = str.split(" ");
		
		// 2. 转换为int数组
		int[] nums = toIntArr(strNum);
		
		// 3. 对int数组排序
		sortIntArr(nums);
		
		// 4. 转换为字符数组
		return arrToStr(nums);
	}


	private static String arrToStr(int[] nums)
	{
		StringBuilder sb = new StringBuilder();
		// 遍历int数组将值转换为String并存入
		for (int x=0; x<nums.length; x++)
		{
			if (x != nums.length-1)
				sb.append(nums[x]+" ");
			else
				sb.append(nums[x]);
		}
		return sb.toString();
	}

	private static void sortIntArr(int[] nums)
	{
		Arrays.sort(nums);
	}

	private static int[] toIntArr(String[] strNum)
	{
		// 创建int数组
		int[] arr = new int[strNum.length];
		
		//便利数组并将转换的整型值存入数组
		for (int i=0; i<strNum.length; i++)
		{
			arr[i] = Integer.parseInt(strNum[i]);
		}
		return arr;
	}

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

}
	public static String sortStringNumber(String str) 
	{
		
		//1，将字符串中的数值通过指定的规则进行切割获取字符串数组。
		String[] str_nums = toStringArray(str);
		
		//2，将字符串数组转成int数组。 
		int[] nums = toIntArray(str_nums);
		
		//3，对int数组排序;
		sortIntArray(nums);
		
		//4，将int数组变成字符串。 
		return arrayToString(nums);
	}
	/*
	 * 将int数组变成字符串。 
	 */
	private static String arrayToString(int[] nums) {
		//1，创建字符串缓冲区。
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < nums.length; i++) {
			if(i!=nums.length-1)
				sb.append(nums[i]+SPACE);
			else
				sb.append(nums[i]);
		}
		
		return sb.toString();
	}

	/*
	 * 对int数组排序。 
	 */
	private static void sortIntArray(int[] nums) 
	{
		Arrays.sort(nums);
	}

	/*
	 * 将字符串数组转成int数组。 
	 */
	private static int[] toIntArray(String[] str_nums) 
	{
		//1,先定义一个int数组。 
		int[] arr = new int[str_nums.length];
		
		//2,对字符串数组进行遍历。
		for (int i = 0; i < str_nums.length; i++) {
			//将数组格式的字符串转成整数。存储到arr数组中。 
			arr[i] = Integer.parseInt(str_nums[i]);
		}
		
		
		return arr;
	}
	/*
	 * 将字符串转成字符串数组。 
	 */
	private static String[] toStringArray(String str)
	{
		
		return str.split(SPACE);
	}