Java基础学习笔记15(常用API)

今日内容介绍

第一章 API概述

第二章 Object 类

第三章 String 类

第四章 字符串缓冲区StringBuffer和StringBuilder类

第五章 StringBuffer类案例拼接数组

1.1API概述

* A: API(Application Programming Interface) 
	* Application(应用) Programming(程序) Interface(接口)
	* 应用程序编程接口
* B: Java API
	* 就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
	* 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
	* 在JDK安装目录下有个src.zip文件，这个文件解压缩后里面的内容是所有Java类的源文件。可以在其中查看相对应的类的源码。

2.1Object类概述

* A: Object类概述:
	* Object类是Java语言中的根类，即所有类的父类;
	* 所有类都直接或者间接的继承自该类;
	* Object中描述的所有方法子类都可以使用;
	* 所有类在创建对象的时候，最终找的父类就是Object。
* B: 构造方法
	* public Object()
	* 回想面向对象中为什么说：
		* 子类的构造方法默认访问的是父类的无参构造方法
* C: 在Object类众多方法中，我们先学习equals方法与toString方法，其他方法后面课程中会陆续学到。

2.2equals方法比较内存地址

* A: Object类中的equals方法:
	* equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较
	* Object类中的equals方法内部使用的就是==比较运算符。
		* Object类中源码:
			public boolean equals(Object obj) {
		        return (this == obj);
		    }
		
	* b: 代码案例:
	
		public class Person extends Object{
			private String name;
			private int age;
			
			public Person(){}
			
			public Person(String name, int age) {
				this.name = name;
				this.age = age;
			}
			/*
			 * 将Object父类的equals方法重写过来
			 * 但是，不改变Object父类方法的源代码, 方法equals比较两个对象的内存地址
			 * 				
			 */
			public boolean equals(Object obj){					
				return (this == obj);
			}		
			
			public String getName() {
				return name;
			}
			public void setName(String name) {
				this.name = name;
			}
			public int getAge() {
				return age;
			}
			public void setAge(int age) {
				this.age = age;
			}				 
		}
		//测试代码
		public class TestEquals {
			public static void main(String[] args) {
				Person p1 = new Person("李四",20);	//创建Person对象p1
				Person p2 = new Person("张三",20);	//创建Person对象p2
				
			  
				//Person对象p1,调用Object父类的方法equals,进行对象的比较
				boolean b = p1.equals(p2);
				System.out.println(b);	//false
				
			}
		}
* C: 图解:
	![在这里插入图片描述](https://img-blog.csdnimg.cn/20190328120742964.JPG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pc19fU3VuZGF5,size_16,color_FFFFFF,t_70)

2.3重写equals方法

* A: 重写equals方法
	* a: 开发中两个对象比较地址，没有什么意义(因为两个对象地址肯定不同)，实际开发中，一般是比较是对象中的属性值。
	* b: 在开发经常需要子类重写equals方法根据对象的属性值进行比较。	
	* c: ==号和equals方法的区别:
		* ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
		* equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法可以比较对象中的属性
* B: 案例:
	* a: 描述人这个类，并定义功能根据年龄判断是否是同龄人
		* 由于要根据指定类的属性进行比较，这时只要覆盖Object中的equals方法
		* 在方法体中根据类的属性值进行比较

	* b: 案例代码:
		public class Person extends Object{
			private String name;
			private int age;
			
			public Person(){}
			
			public Person(String name, int age) {
				this.name = name;
				this.age = age;

			/*
			 * 将Object父类的equals方法重写
			 * 两个对象去比较地址没有什么意义
			 * 下面通过重写比较两个对象的成员变量age的属性值
			 * 两个对象变量age相同,返回true,不同返回false
			 * 
			 * 重写父类的equals,自己定义自己对象的比较方式
			 */
			public boolean equals(Object obj){
				//判断当前调用equals方法的对象和传递进来的对象是否是同一个
				if( this == obj){
					return true;
				}
				
				//对参数obj,非null判断
				if( obj == null){
					return false;
				}
				
				//判断传递进来的对象是否是Person类型
				if( obj instanceof Person){
					//将obj向下转型为Perosn引用，访问其属性
					Person p = (Person)obj;
					//比较年龄
					return this.age ==  p.age;
				}
				return false;
			}				
			
			public String getName() {
				return name;
			}
			public void setName(String name) {
				this.name = name;
			}
			public int getAge() {
				return age;
			}
			public void setAge(int age) {
				this.age = age;
			}				 
		}
		//测试代码
		public class TestEquals {
			public static void main(String[] args) {
				Person p1 = new Person("李四",20);	//创建Person对象p1
				Person p2 = new Person("张三",20);	//创建Person对象p2
				
			  
				//Person对象p1,调用父类的方法equals,进行对象的比较
				boolean b = p1.equals(p2);
				System.out.println(b);	//true
				
			}
		}
	* c: 注意：在重写Object中的equals方法时，一定要注意public boolean equals(Object obj)的参数是Object类型，在调用对象的属性时，一定要进行类型转换，在转换之前必须进行类型判断。		

2.4toString方法

* A: toString方法
	* a: toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
	* b: 为什么要重写toString方法
		* 由于toString方法返回的结果是内存地址，而在实际开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
		* Object类中的toString的核心代码:
			getClass().getName() + "@" + Integer.toHexString(hashCode()) 
		* 由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
	* c: 案例核心代码(重写Person类中的toString方法)
		/*
		 * 重写父类的方法toString()
		 * 没有必要让调用者看到内存地址
		 * 要求: 方法中,返回类中所有成员变量的值
		 */
		class Person extends Object{
			int age ;
			//根据Person类的属性重写toString方法
			public String toString() {
				return "Person [age=" + age + "]";
			}
		}

3.1String类的概述和不变性

* A: String类概述:
	* 查阅Java API中的String类的描述，发现String 类代表字符串;
	* Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现;
		* 代码案例:
			//演示字符串
			String str  = "itcast";
			str = "传智播客"
* B: String类的不变性:
	* 字符串是常量,在创建之后不能更改,这是什么意思呢?;
		* 其实就是说一旦这个字符串确定了，那么就会在内存区域中就生成了这个字符串。字符串本身不能改变，但str变量中记录的地址值是可以改变的。
	* 源码分析,String类底层采用的是字符数组:
		* private final char value[]
		* private 修饰说明value只能在String类内部使用,而且又没有提供get方法,所以外部无法获取value数组,就无法改变数组中元素的值
		* final修饰说明value是常量,一旦创建,就不能被改变,value一旦被初始化成某个数组,将永远指向这个数组,不可能再指向其它的数组了
	* 代码案例:
			//引用变量str执行内存变化
			//定义好的字符串对象,不变
			String str = "itcast";
			System.out.println(str);
			str = "itheima";
			System.out.println(str);
			
	* 图片: ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190328133710806.JPG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pc19fU3VuZGF5,size_16,color_FFFFFF,t_70)

* C: String类创建方式和比较:
	* 通过String类的构造方法可以完成字符串对象的创建;
	* 那么,通过使用双引号的方式创建对象与new的方式创建对象，有什么不同呢？
		* a: 创建对象的数量不同
			* String s3 = "abc";
				* 在内存中只有一个对象。这个对象在字符串常量池中。
			* String s4 = new String("abc");
				* 在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中。
		* b: 案例代码
			public class StringDemo {
				public static void main(String[] args) {
					String str1 = new String("abc");
					String str2 = "abc";
					System.out.println(str1);
					System.out.println(str2);
					
					System.out.println(str1==str2);	//false 引用数据类型,比较对象的地址 
					System.out.println(str1.equals(str2));//true String重写了Object中的equals方法
				}
			}
	* c: 图片: ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190328140609196.JPG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pc19fU3VuZGF5,size_16,color_FFFFFF,t_70)

3.2String类构造方法

* A: String类构造方法:
	* a: 常见构造方法
		* public String():空构造
		* public String(byte[] bytes):把字节数组转成字符串
		* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串			
		* public String(String original):把字符串常量值转成字符串
		* .....
	* b: 案例代码
		String s1 = new String(); //创建String对象，字符串中没有内容

		byte[] bys = new byte[]{97,98,99,100};
		String s2 = new String(bys); // 创建String对象，把数组元素作为字符串的内容
		String s3 = new String(bys, 1, 3); //创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数length为要几个元素
		
		char[] chs = new char[]{’a’,’b’,’c’,’d’,’e’};
		String s4 = new String(chs); //创建String对象，把数组元素作为字符串的内容
		String s5 = new String(chs, 0, 3);//创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数count为要几个元素
	
		String s6 = new String(“abc”); //创建String对象，字符串内容为abc

3.3String类的成员方法

* A：String类的成员方法
	* a: 方法介绍:
		* int length(): 返回字符串的长度
		* String substring(int beginIndex,int endIndex): 获取字符串的一部分
		* String substring(int beginIndex): 获取字符串的一部分
		* boolean startsWith(String prefix): 判断一个字符串是不是另一个字符串的前缀,开头
		* boolean endsWith(String prefix): 判断一个字符串是不是另一个字符串的后缀,结尾
		* boolean contains (String s): 判断一个字符串中,是否包含另一个字符串
		* int indexOf(char ch):  查找一个字符,在字符串中第一次出现的索引,被查找的字符不存在,返回-1
		* byte[] getBytes(): 将字符串转成字节数组,此功能和String构造方法相反,byte数组相关的功能,查询编码表
		* char[] toCharArray(): 将字符串转成字符数组,功能和构造方法相反
		* boolean equals(Object obj): 方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
		* boolean equalsIgnoreCase(String s): 传递字符串,判断字符串中的字符是否相同,忽略大小写			
		* ......
	* b: 案例代码
	
		public class StringDemo {
			public static void main(String[] args) {
				method();
			}
			/*
			 *  boolean equals(Object obj)
			 *  方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
			 *  
			 *  boolean equalsIgnoreCase(String s)
			 *  传递字符串,判断字符串中的字符是否相同,忽略大小写
			 */
			public static void method(){
				String str1 = "Abc";
				String str2 = "abc";
				//分别调用equals和equalsIgnoreCase
				boolean b1 = str1.equals(str2);
				boolean b2 = str1.equalsIgnoreCase(str2);
				System.out.println(b1);
				System.out.println(b2);
			}
			
			/*
			 * char[] toCharArray() 将字符串转成字符数组
			 * 功能和构造方法相反
			 */
			public static void function_8(){
				String str = "itcast";
				//调用String类的方法toCharArray()
				char[] ch = str.toCharArray();
				for(int i = 0 ; i < ch.length ; i++){
					System.out.println(ch[i]);
				}
			}
			
			/*
			 *  byte[] getBytes() 将字符串转成字节数组
			 *  此功能和String构造方法相反
			 *  byte数组相关的功能,查询编码表
			 */
			public static void function_7(){
				String str = "abc";
				//调用String类方法getBytes字符串转成字节数组
				byte[] bytes = str.getBytes();
				for(int i = 0 ; i < bytes.length ; i++){
					System.out.println(bytes[i]);
				}
			}
			
			/*
			 *  int indexOf(char ch)
			 *  查找一个字符,在字符串中第一次出现的索引
			 *  被查找的字符不存在,返回-1
			 */
			public static void function_6(){
				String str = "itcast.cn";
				//调用String类的方法indexOf
				int index = str.indexOf('x');
				System.out.println(index);
			}
			
			/*
			 *  boolean contains (String s)
			 *  判断一个字符串中,是否包含另一个字符串
			 */
			public static void function_5(){
				String str = "itcast.cn";
				//调用String类的方法contains
				boolean b =str.contains("ac");
				System.out.println(b);
			}
			
			/*
			 * boolean endsWith(String prefix)
			 * 判断一个字符串是不是另一个字符串的后缀,结尾
			 * Demo.java
			 *     .java
			 */
			public static void function_4(){
				String str = "Demo.java";
				//调用String类方法endsWith
				boolean b = str.endsWith(".java");
				System.out.println(b);
			}
			
			/*
			 * boolean startsWith(String prefix)  
			 * 判断一个字符串是不是另一个字符串的前缀,开头
			 * howareyou
			 * hOw
			 */
			  public static void function_3(){
				  String str = "howareyou";
				  //调用String类的方法startsWith
				  boolean b = str.startsWith("hOw");
				  System.out.println(b);
			  }
			
			/*
			 *  String substring(int beginIndex,int endIndex) 获取字符串的一部分
			 *  返回新的字符串
			 *  包含头,不包含尾巴
			 *  
			 *  String substring(int beginIndex)获取字符串的一部分
			 *  包含头,后面的字符全要
			 */
			public static void function_2(){
				String str = "howareyou";
				//调用String类方法substring获取字符串一部分
				str= str.substring(1, 5);
				System.out.println(str);
				
				String str2 = "HelloWorld";
				str2 = str2.substring(1);
				System.out.println(str2);
			}
			
			/*
			 *  int length() 返回字符串的长度
			 *  包含多少个字符
			 */
			public static void function(){
				String str = "cfxdf#$REFewfrt54GT";
				//调用String类方法length,获取字符串长度
				int length = str.length();
				System.out.println(length);
			}
		}

3.4String类练习

* 题目一: 获取指定字符串中，大写字母、小写字母、数字的个数。
	* a: 思路:
		* 为了统计大写字母、小写字母、数字的个数。创建3个计数的变量。
		* 为了获取到字符串中的每个字符，进行字符串的遍历，得到每个字符。
		* 对得到的字符进行判断:
			* 如果该字符为大写字母，则大写字母个数+1；
			* 如果该字符为小写字母，则小写字母个数+1；
			* 如果该字符为数字，则数字个数+1。
		* 显示大写字母、小写字母、数字的个数

	* b: 案例代码:
		public static void method(String str){
			int bigCount = 0; //大写字母的个数
			int smallCount = 0; //小写字母的个数
			int numberCount = 0; //数字的个数
			for (int i=0; i < str.length(); i++) {
				char ch = str.charAt(i); //获取指定位置上的字符
				if (ch>=’A’ && ch<=’Z’) {
					bigCount++;
				} else if (ch>=’a’ && ch<=’z’) {
					smallCount++;
				} else if (ch>=’0’ && ch<=’9’) {
				    numberCount++;
				}
			}
			System.out.println("大写字母个数："+bigCount);
			System.out.println("小写字母个数："+smallCount);
			System.out.println("数字个数："+numberCount);
		}

* 题目二: 将字符串中，第一个字母转换成大写，其他字母转换成小写，并打印改变后的字符串。
	* a: 思路:
		* 把字符串分为两个部分:
			* 第一部分为字符串中第一个字母;
			* 第二部分为剩下的字符串。
		* 把第一部分字符串转换成大写字母，把第二部分字符串转换成小写字母
		* 把两部分字符串连接在一起，得到一个完整的字符串
	* b: 代码:
		public static String convert(String str){
			//获取第一部分为字符串
			String start = str.substring(0,1);
			//获取第二部分为字符串
			String end = str.substring(1);
			//把第一部分字符串转换成大写字母，把第二部分字符串转换成小写字母
			String big = start.toUpperCase();
			String small = end.toLowerCase();
			//把两部分字符串连接在一起，得到一个完整的字符串
			return big+small;
		}

* C: 查询大字符串中，出现指定小字符串的次数;
	* 如: “hellojava,nihaojava,javazhenbang”中查询出现“java”的次数。 
	* a: 思路:
		* 在大串中，查找小串出现的位置，出现了就次数+1
		* 在上次小串出现位置的后面继续查找，需要更改大串的内容为上次未查询到的字符串。
		* 回到第一步，继续查找小串出现的位置，直到大串中查询不到小串为止
	* c: 代码:	
		public static int getCount(String big, String small){
			int count = 0; //出现小串的次数
			int index = -1;//出现小串的位置
			/*
			 *	while的循环条件三步骤：
			 *		步骤一. big.indexOf(small) 获取小串在大串中出现的位置
			 *		步骤二. 把小串出现的位置，赋值给变量index
			 *		步骤三. 判断出现的位置是否为-1， 如果位置等于-1，说明大串中已经查询不到小串了；如果位置不等于-1，那么，进行循环，完成次数累加与修改大串的操作
			 */
			while ((index = big.indexOf(small)) != -1 ){
				count++;//出现次数+1
				//更改大串内容
				big = big.substring(index+1);
			}
			return count;
		}

4.1StringBuffer类

* A:StringBuffer类概述
	* 通过查阅JDK提供的API，StringBuffer又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。
	* 原来StringBuffer是个字符串的缓冲区，即就是它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
	* 特点:
		* 可变字符数组
		* 底层采用字符数组实现,初始容量为16。
	* 图片:![在这里插入图片描述](https://img-blog.csdnimg.cn/20190328141217667.JPG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pc19fU3VuZGF5,size_16,color_FFFFFF,t_70) 
	* 线程安全的可变字符序列。
* B:StringBuffer和String的区别:
	* String是一个不可变的字符序列（底层final修饰）
	* StringBuffer是一个可变的字符序列

4.2StringBuffer类的成员方法

* A: StringBuffer类的成员方法
	* a: 方法介绍
		* 1. StringBuffer append():将任意类型的数据,添加到缓冲区中
			*  StringBuffer源码append方法中return this，那么return的是谁?
				*  调用者是谁,返回值就是谁
		* 2. delete(int start,int end): 删除缓冲区中字符
			*  start 开始索引
			*  end 结束索引 
			*  开始索引包含,结尾索引不包含
		* 3. insert(int index, 任意类型): 将任意类型数据,插入到缓冲区的指定索引上
		* 4. replace(int start,int end, String str): 将指定的索引范围内的所有字符,替换成新的字符串
		* 5. reverse(): 将缓冲区中的字符反转
		* 6. String toString(): 继承Object,重写toString()
			*   将缓冲区中的所有字符,变成字符串
	* b: 案例代码:
		public class StringBufferDemo {
			/*
			 *  StringBuffer的append方法
			 */
			public static void function(){
				StringBuffer buffer = new StringBuffer();
				//调用StringBuffer方法append向缓冲区追加内容
				buffer.append(6).append(false).append('a').append(1.5);
				System.out.println(buffer);//6falsea1.5
			}

			/*
			 * StringBuffer的delete方法
			 *  	start 开始索引
			 *  	end 结束索引 
			 *  	开始索引包含,结尾索引不包含
			 */
			public static void function_1(){
				StringBuffer buffer = new StringBuffer();
				buffer.append("abcdef");
				
				buffer.delete(1,5);
				System.out.println(buffer);
			}

			/*
			 *  StringBuffer类方法 insert
			 *    insert(int index, 任意类型)
			 *  将任意类型数据,插入到缓冲区的指定索引上
			 */
			 public static void function_2(){
				 StringBuffer buffer = new StringBuffer();
				 buffer.append("abcdef");	 
				 
				 buffer.insert(3, 9.5);
				 System.out.println(buffer);
			 }
		
			/*
			 *  StringBuffer类方法
			 *    replace(int start,int end, String str)
			 *    将指定的索引范围内的所有字符,替换成新的字符串
			 */
			public static void function_3(){
				StringBuffer buffer = new StringBuffer();
				buffer.append("abcdef");
				
				buffer.replace(1, 4, "Q");
				
				System.out.println(buffer);
			}				

			/*
			 *  StringBuffer类的方法
			 *    reverse() 将缓冲区中的字符反转
			 */
			public static void function_4(){
				StringBuffer buffer = new StringBuffer();
				buffer.append("abcdef");
				buffer.reverse();
				System.out.println(buffer);
			}
			
			/*
			 *  StringBuffer类的方法
			 *   String toString() 继承Object,重写toString()
			 *   将缓冲区中的所有字符,变成字符串
			 */
			public static void function_5(){
				StringBuffer buffer = new StringBuffer();
				buffer.append("abcdef");
				buffer.append(12345);
				
				//将可变的字符串缓冲区对象,变成了不可变String对象
				String s = buffer.toString();
				System.out.println(s);
			}
		}
* C: 对象的方法链式调用：
	* 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。这种时候，我们就可以把代码现在一起，如append方法一样，代码如下：
	* 代码案例:
		创建一个字符串缓冲区对象。用于存储数据。
			StringBuffer sb = new StringBuffer();
		添加数据。不断的添加数据后，要对缓冲区的最后的数据进行操作，必须转成字符串才可以。
			String str = sb.append(true).append("hehe").toString();
			
* D: StringBuffer练习:
	* 题目:int[] arr = {34,12,89,68};将一个int[]中元素转成字符串  格式 [34,12,89,68]
	* 代码案例:
		public static String toString_2(int[] arr) {
			StringBuffer sb = new StringBuffer();		
			sb.append("[");
			for (int i = 0; i < arr.length; i++) {
				if(i!=arr.length-1){
					sb.append(arr[i]+",");
				}else{
					sb.append(arr[i]+"]");
				}
			}		
			return sb.toString();
		}
	* 无论多少数据，数据是什么类型都不重要，只要最终变成字符串就可以使用StringBuffer这个容器

4.3StringBuilder类

* A:StringBuilder的概述
	* 查阅API发现还有一个StringBuilder类，它也是字符串缓冲区。
	* StringBuilder与它和StringBuffer的有什么不同呢？
		* 我们阅读StringBuilder的API说明发现，它也是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
		* 目前，我们还没有涉及到线程与同步，知道结论StringBuilder比StringBuffer快即可。为什么快，我们会在学习线程时讲解。
* B:面试题"String,StringBuffer,StringBuilder的区别:
	* StringBuffer和StringBuilder的区别:
		* StringBuffer是jdk1.0版本的,是线程安全的,效率低;
		* StringBuilder是jdk1.5版本的,是线程不安全的,效率高。

	* String和StringBuffer,StringBuilder的区别:
		* String是一个不可变的字符序列;
		* StringBuffer,StringBuilder是可变的字符序列。

5.1StringBuffer类案例拼接数组

* A: StringBuffer类案例拼接数组
	* a: 题目分析
		* 定义StringBuffer对象
		* 遍历数组,按照格式要求拼接处新的字符串,追加到StringBuffer容器中
		* 将StringBuffer中的内容以String的形式返回
	* C: 案例代码	
		public class StringBufferTest {
			public static void main(String[] args) {
				int[] arr = {4,1,4,56,7,8,76};
				System.out.println(toString(arr));
			}
		   /*
			* int[] arr = {34,12,89,68};将一个int[]中元素转成字符串 
			* 格式 [34,12,89,68]
			* String s = "["
			* 数组遍历
			*   s+= arr[i];
			*  s+"]"
			*  StringBuffer实现,节约内存空间, String + 在缓冲区中,append方法
			*/
			public static String toString(int[] arr){
				//创建字符串缓冲区
				StringBuffer buffer = new StringBuffer();
				buffer.append("[");
				//数组遍历
				for(int i = 0 ; i < arr.length;i++){
					//判断是不是数组的最后一个元素
					if(i == arr.length-1){
						buffer.append(arr[i]).append("]");
					}else{
						buffer.append(arr[i]).append(",");
					}
				}
				return buffer.toString();
			}
		}