stringbuffer常用方法_[基础篇]-常用类-02-与字符串相关的常用类

与字符串相关的常用类

1.Object类和Java7新增的Objects工具类

Object是所有类、数组的父类，也就说允许在任何类对象中调用Obejct的方法。Object常用的方法：

equals(Object obj)：判断字符串是否相同、可以通过重载判断是否引用同一个对象

finalize()：初始化

hashCode()：获取对象的内存地址（哈希码）

getClass()：获取当前对象所属类的类名

toString()：输出对象的内存地址，可通过重载实现输出对象的相关信息

1.1浅克隆

Java中的Object类还提供了一个clone的方法，该方法用于帮助其他类实现自我克隆，也就说自我复制。

public class Address {
	private String city;
	private String street;
	public Address() 
{
	}
	public Address(String city, String street) {
		this.city = city;
		this.street = street;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	public String toString() {
		return  city +street ;
	}
}
/**
 *	如果一个类中要实现克隆，需要实现Cloneable接口
 *	Cloneable接口是个空接口，是标志性接口
 *	如果实现该接口，需要重写clone方法（不需要作任何改动）
 *	此处定义User类实现Cloneable接口 
 */
public class User implements Cloneable {
	private String name;
	private int age;
	private Address address;
	public User()
{
	}
	public User(String name, int age, Address address) {
		this.name = name;
		this.age = age;
		this.address = address;
	}
	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 Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	/**
	 * 重写clone方法，不需要对原来的内容作任何改动
	 * 可以返回指定的类型，此处返回User类型
	 */
	protected User clone() throws CloneNotSupportedException {
		return (User)super.clone();
	}
}
public class CloneTest {
	public static void main(String[] args) throws Exception {
		Address address = new Address("深圳","布吉街道");
		User u1 = new User("haha",18,address);
		User u2 = (User) u1.clone();
	System.out.println("u1:"+u1.getName()+"--"+u1.getAge()+"--"+u1.getAddress());
	System.out.println("u2:"+u2.getName()+"--"+u2.getAge()+"--"+u2.getAddress());
		System.out.println(u1==u2);//false
		System.out.println(u1.getAddress()==u1.getAddress());//true
		/**
* 浅克隆的相关概念：
		 * 分析：u2是由u1对象克隆而来，因此u1、u2并不是指向同一个对象
		 * 但两者的信息完全相同（此处为姓名、年龄、地址）
		 * 克隆的含义是指将数据复制一份，由u2指向这份数据，但这份数据中的
		 * address指向还是原来的address，因此有
		 * u1.getAddress()==u1.getAddress()返回的结果为true
		 * 而u1==u2返回的结果为false
		 */
	}
}

1.2 Objects工具类

Java7新增了一个工具类Objects， 它提供了一些工具方法，这些工具方法大多数是针对安全性操作的。

public class ObjectsTest {
	static ObjectsTest obj;
	public static void main(String[] args) {
		/**
		 * 在无法得知传递的对象是否为null时，如果直接使用对象的hasCode方法
		 * 或者是其它相应的方法，系统会报空指针异常
		 * 因此java7新增了Objects类可以进行安全操作，而不报错
		 */
		/**
		 * System.out.println(obj.hashCode());
		 * System.out.println(obj.toString());
		 * 系统报java.lang.NullPointerException
		 */
		//1.借助Objects类进行安全操作(hashCode方法、toString方法 )
		System.out.println(Objects.hashCode(obj));//0
		System.out.println(Objects.toString(obj));//null
		/**
		 * 2.借助Objects类提供的requireNonNull方法验证obj是否为null
		 * 如果obj为null，则人为抛出相应的异常
		 */
		System.out.println(Objects.requireNonNull(obj,"obj的参数不能为null"));
	}
}

2.String类

字符串就是一连串的字符序列，Java提供了String和StringBuffer两个封装字符串，并且提供了一系列的方法进行操作字符串。

String类是不可变类，就是一个String对象被创建出来以后，包含在这个字符串对象的字符序列的不可改变的，即直到这个对象被销毁，被垃圾回收都不会改变。

/**
 *	通过查阅API中java.lang包下的与String类、StringBuffer类、
 *	StringBuilder类相关的方法进行测试分析
 */
public class StringTest {
	public static void main(String[] args) {
		/**
		 * 1.String类常见的构造方法
		 * a.String():指向空字符序列
		 * b.String(char[] value):用指定字符数组创建字符串数据
		 * c.String(char[] value, int offset, int count) 
		 *   用指定字符数组的一个字数组创建字符串数据
		 * d.String(String original):用指定字符串创建字符串数据
		 * e.String(StringBuffer buffer):用StringBuffer类型的字符串创建新的字符串数据 
		 * f.String(StringBuilder builder):用StringBuilder类型的字符串创建新的字符串数据
		 * g.还可将字符串常量直接复制给String类型的变量
		 */
		String str = "hahabibu";
		/**
		 * 2.String常用的方法
		 * a.得到字符串中指定位置的字符(char)、得到指定字符的位置(int)
		 *   charAt(int index):返回指定索引处的 char值
		 *   indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
		 *   indexOf(int ch, int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索 
		 *   indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引
		 *   indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
		 *   lastIndexOf(int ch):返回指定字符在此字符串中最后一次出现处的索引 
		 *   lastIndexOf(int ch, int fromIndex):返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 
		 *   lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
		 *   lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 
		 * b.两个字符串之间比较大小
		 *   compareTo(String anotherString):按字典顺序比较两个字符串,返回值为int类型
		 *   compareToIgnoreCase(String str):按字典顺序比较两个字符串，不考虑大小写，返回值为int类型
		 * c.链接字符串(可通过‘+’实现)
		 *   concat(String str):将指定字符串连接到此字符串的结尾，返回值为String类型
		 * d.看指定字符串是否包满足要求(是否为空、是否包含某些内容、是否包含指定的前后缀、是否匹配)
		 *   isEmpty():当 length()为 0 时返回 true。 
		 *   contains(CharSequence s):若字符串包含指定的 char值序列则返回 true
		 *   startsWith(String prefix):若字符串以指定的前缀开始则返回true 
		 *   startsWith(String prefix, int toffset):若从指定索引开始的子字符串以指定前缀开始则返回true 
		 *   endsWith(String suffix):如果此字符串以指定的后缀结束则返回true
		 *   matches(String regex):如果此字符串匹配给定的正则表达式则返回true
		 * g.将字符串与指定的字符串数据进行比较
		 *   equals(Object anObject):如果两个字符串的字符序列相同则返回true
		 *   equalsIgnoreCase(String anotherString):不考虑大小写进行比较
		 * h.得到指定字符串的某些属性(信息)
		 *   hashCode():返回指定字符串的哈希码 
		 *   length():返回此字符串的长度(int类型)
		 *   toString():返回此对象本身
		 *   trim():返回字符串的副本，忽略前导空白和尾部空白
		 * g.用指定的内容替换原字符串数据
		 *   replace(char oldChar, char newChar)用 newChar替换此字符串中出现的所有 oldChar得到新字符串数据 
		 *   replaceAll(String regex, String replacement):用replacement替换此字符串所有匹配给定的正则表达式的子字符串
		 *   replaceFirst(String regex, String replacement):使用给定的 replacement替换此字符串匹配给定的正则表达式的第一个子字符串。 
  		 * h.根据指定要求拆分字符串、 截取字符串数据
  		 *   split(String regex):根据给定正则表达式的匹配拆分此字符串(返回字符串数组String[])
  		 *   substring(int beginIndex):返回一个新的字符串，它是此字符串的一个子字符串。 
		 *   substring(int beginIndex, int endIndex) 
		 * i.将指定字符串进行转化(转化为字符数组、全大写、全小写)
		 *   toCharArray():将此字符串转换为一个新的字符数组(char[]) 
		 *   toLowerCase():将指定字符串的所有字符都转换为小写(String) 
		 *   toUpperCase():将指定字符串的所有字符都转换为大写(String)
		 * j.将基本的数据类型转化为String类型
		 *   valueOf(...):可以直接进行转化的类型有除了byte、short类型的其他六种基本类型
		 *                以及字符数组、Object对象
		 */
		//1.charAt:返回指定索引处的char值
		System.out.println(str.charAt(0));//h
		//2.compareTo:按字典顺序比较两个字符串(得到第一个不相同的字符的ASCII码差值)
		System.out.println(str.compareTo("hahaBiBi"));//32
		System.out.println(str.compareToIgnoreCase("HahaBIBU"));//0
		//3.concat:拼接字符串
		System.out.println(str.concat("hello"));//hahabibuhello
		//4.contains:判断是否包含某个子字符串
		System.out.println(str.contains("bi"));//true
		System.out.println(str.contains("gg"));//false
		//5.startWith、endWith:是否包含指定前后缀
		System.out.println(str.startsWith("haha"));//true
		System.out.println(str.endsWith("bb"));//false
		//6.查找字符在指定字符串中出现的位置
		String str1 = "haha bibu gogo study";
		System.out.println(str1.indexOf("b"));//5
		//indexOf("s",5)：跳过5个字符不读，即从索引位置为5处开始查找
		System.out.println(str1.indexOf("s",5));//15
		//lastIndexOf("u")：得到当前字符串中“u”最后一次出现的的位置
		System.out.println(str1.lastIndexOf("u"));//17
		//7.isEmpty:判断是否为空
		System.out.println(str.isEmpty());//false
		//8.切割字符串:sqlit
		String str2 = "aa,bbb,cc,ddd";
		String[] strs = str2.split(",");
		for(String s:strs)
			System.out.print(s+"-");//aa-bbb-cc-ddd-gogo
		System.out.println();
		/**
		 * 9.substring:截取字符串
		 * 一个参数：截断n之前的内容，取后边的部分
		 * 两个参数：截断指定区域的字符串，包含左侧区域不包含右侧区域
		 */
		String str3 = "hahagogo";
		System.out.println(str3.substring(4));//截断前4个：gogo
		System.out.println(str3.substring(4,7));//gog
		//10.转换大小写
		String str4 = "hAhAbiBU";
		System.out.println("大写："+str4.toUpperCase());//HAHABIBU
		System.out.println("小写："+str4.toLowerCase());//hahabibu
		//11.去掉首尾空格：trim
		String str5 = "  haha bibu   ";
		System.out.println(str5.trim());//haha bibu
		//12.类型转换valueOf:将一些基本的数据类型转化为相应的字符串形式输出
		System.out.println(String.valueOf(123));//123
	}
}

练习分析

public class EmailCheckTest {
	public static void main(String[] args) {
		/**
		 *	练习1
		 *  判断邮箱是否合法     guigu@163.com
		 *  1.必须有且只有一个@
		 *  2.@不能出现在头部或者尾部
		 *  3.@和.不能同时出现
		 *  4.@之后的内容不能超过15位
		 *  5.@之后必须有点
		 *  6.@之后是以 com  或者cn  或者net 或者org结尾
		 */
		String qq = "892944741@qq.com";
		check(qq);
	}
	public static void check(String str)
	{
		//1.必须只有1个@：以@切割字符串，如果得到的字符串数组长度为2则满足条件
		String[] ss = str.split("@");
		if(ss.length!=2)
			System.out.println("邮箱必须有且只有一个@...");
		//2.@不能出现在头部或者是尾部
		else if(str.startsWith("@"))
			System.out.println("邮箱中的@不能出现在头部...");
		else if(str.endsWith("@"))
			System.out.println("邮箱中的@不能出现在尾部...");
		//3.@和.不能够同时出现
		else if(str.contains("@."))
			System.out.println("邮箱中@和.不能够同时出现...");
		//4.@之后的内容不能超过15位：直接判断ss[1]的长度是否大于15
		else if(ss[1].length()>15)
			System.out.println("@之后的内容不能够超过15位...");
		//5.@之后要以com、cn、net、org四者之一结尾
		else if(!(ss[1].endsWith("com")||ss[1].endsWith("cn")||ss[1].endsWith("net")||ss[1].endsWith("org")))
			System.out.println("@之后的内容要以com、cn、net、org四者之一结尾...");
		else
			System.out.println("邮箱验证通过：合法！！！");
		/**
		 * 如果一次性要展示所有的问题，则可全部设置成if语句，如此一来每个情况都可以分析判断得到
		 * 然后可通过flag进行标记(初始值位false)，如果所有条件均满足，则可将flag置为true
		 * 并输出验证合法通过....
		 */
	}
}
public class StringReverse {
	/**
	 * 练习2:
	 * 将一个字符串 abcd  反转   dcba 
	 * 1.可以通过将字符串转化为字符数组的形式进行反转(反向遍历)
	 * 2.可以将字符串转化为相应的StrngBuffer、StringBuilder
	 *   然后通过其提供的reverse方法直接实现反转
	 */
	public static String f1(String str)
	{
		//1.将字符串数据转化为相应的字符数组进行操作
		char[] ch = str.toCharArray();
		//2.可以通过反向遍历数组实现反转
		char[] newCh = new char[ch.length];
		int j = 0;
		for(int i = ch.length-1;i>=0;i--)
		{
			newCh[j] = ch[i];
			j++;
		}
		String s = new String(newCh);
		return s;
		/**3.可以借助StringBuilder类直接用append方法追加数据
		 * StringBuilder sb = null;
		 * sb.append(ch[i]);
		 */
	}
	public static String f2(String str)
	{
		StringBuffer sb = new StringBuffer(str);
//		StringBuilder sb = new StringBuilder(str);
		return sb.reverse().toString();
	}
	public static void main(String[] args) {
		System.out.println("方法1实现反转："+f1("abcd"));
		System.out.println("方法2实现反转："+f2("abcd"));
	}
}
public class StringSort {
	/**
	 *	练习3:
	 *	对字符串中的字母 进行排序  :ysdfg   -->dfgsy
	 *	1.将字符串转化为字符数组利用相应的排序算法进行排序
	 *	2.将字符串转化为字符数组，借助Arrays工具类进行排序
	 */
	public static void f(String str)
	{
		/**
		 * 1.将字符串转化为相应的字符数据，通过两种方法进行排序
		 *   冒泡排序：bubber
		 *   选择排序：choose
		 */
		char[] ch = str.toCharArray();
		//调用冒泡排序方法
		System.out.println("冒泡排序："+bubber(ch));
		//调用选择排序方法
		System.out.println("选择排序："+choose(ch));
		/**
		 * 2.借助Arrays工具类的sort方法直接进行排序
		 */
		System.out.println("借助工具类Arrays："+f2(ch));
	}
	public static String bubber(char[] ch)
	{
		for(int i=0;i<ch.length-1;i++)
			for(int j=0;j<ch.length-1-i;j++)
				if(ch[j]>ch[j+1])
				{
					char temp = ch[j];
					ch[j] = ch[j+1];
					ch[j+1] = temp;
				}
		String s = new String(ch);
		return s;
	}
	public static String choose(char[] ch)
	{
		for(int i=0;i<ch.length-1;i++)
			for(int j=i+1;j<ch.length;j++)
				if(ch[i]>ch[j])
				{
					char temp = ch[i];
					ch[i] = ch[j];
					ch[j] = temp;
				}
		String s = new String(ch);
		return s;
	}
	public static String f2(char[] ch)
	{
		Arrays.sort(ch);
		String s = new String(ch);
		return s;
	}
	public static void main(String[] args) {
		f("dcba");
	}
}
public class StringAppearCounter {
	/**
	 * 练习4: 
	 * 获取一个字符串在另外一个字符串中出现的次数
	 * “rtyui”  ---> “asdasrtyuiaegasrtyuiad rtyuizaf rtyui”  --->4
	 */
	public static int count(String str,String subStr)
	{
		int count = 0;
		/**
		 * 思路：
		 * 先查找到第1个subStr子串所在位置，然后将源字符串以第1个subStr子串位置+长度进行截断
		 * （即截断第1个子串及其之前的所有内容），并执行计数器加1操作。继续依次遍历，依次类推
		 * 如果查找到的最终字符串不包括subStr子串或者是最终子串与subStr相同，则退出遍历
		 */
		boolean flag = true;//定义flag用以控制遍历操作是否退出
		while(flag)
		{
			//1.查找第1个subStr子串出现的位置
			int location = str.indexOf(subStr);
			//2.截断subStr子串及之前的内容
			if(location!=-1)
			{
				count++;//查找成功，计数器加1,继续查找
				str = str.substring(location+subStr.length());
			}
			if(str.length()<subStr.length()||(!str.contains(subStr)))
				flag=false;
		}
		return count;
	}
	public static void main(String[] args) {
		System.out.println(count("abcdgogoabcdgoabcdgogoabcdgo","abcd"));
	}
}
public class MaxSubString {
	/**
	 * 练习5: 
	 * 获取两个字符串最大相同的子串  
	 * “dsfhkoasdfhasdlfhasdf” ----->”ieqohrfoasdfhasdakwepghspghs”
	 * 输出 最大的相同的字符串 “oasdfhasd”
	 */
	public static String getMaxString(String s1, String s2) {  
		/**
		 * 思路：
		 * 先对比两个字符串的长度，如果max包括min则表示min为当前两个字符串的最大相同子串
		 * 以min的长度为准遍历查找
		 */
	    String max=(s1.length()>s2.length())?s1:s2;  
	    String min=(max.equals(s1))?s2:s1;  //取s1、s2中长度较长的为max，取较短的为min
	    if(max.contains(min)){   //如果max对应字符串包含min则表示两者的最大公共字串为min
	        return min;  
	    }  
	    for(int i=0;i<min.length();i++){   //进行min对应的字符串长度次循环匹配查找，  
	        for(int a=0,b=min.length()-i;b!=min.length()+1;a++,b++){
	        	/**
	        	 * 每次查找，都是从小字符串的起始位置查找，  记录查找的位置
	        	 * a，b代表的是每次查找时的从小字符串中截取的子串的起始位置和末尾位置+1
	        	 * 每次查找将小字符串min进行取子串，然后再将该子串与max匹配，
	        	 * 看看是max否包含该子串，直接返回当前子串
	        	 */
	            String sub=min.substring(a, b);  
	            if(max.contains(sub)){  
	                return sub;  
	            }  
	        }  
	    }  
	    return null;  
	}
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入第一个任意字符串");
		String str1 = sc.nextLine();	
		System.out.println("请输入第二个任意字符串");
		String str2 = sc.nextLine();
		System.out.println("输入两个字符串的最大公共字串为："+getMaxString(str1,str2));
	}
}

3.StringBuffer 和StringBuilder

StringBuffer对象代表的是一个可变字符序列，当一个StringBuffer创建出来以后，通过StringBuffer提供的append/insert/reverse/setCharAt等方法改变这个字符串对象的字符序列。一旦通过StringBuffer获得最终字符串，可以通过调用toString方法将字符StringBuffer对象转换为String对象。

在jdk1.5以后，新增了一个StringBuilder类，它代表字符串对象，StringBulider和StringBuffer这两个类功能基本相似，用法基本相似，不同的是StringBuffer是线程安全的，StringBulider不是线程安全的。

public class StringBufferTest {
	public static void main(String[] args) {
		/**
		 * StringBuffer与StringBuilder用法基本类似，
		 * 可以用StringBuilder直接替换StringBuffer，
		 * 但StringBuffer是线程安全的，而StringBuilder
		 * 是线程不安全的
		 */
		/**
		 * 1.StringBuffer/StringBuilder常见的方法
		 *   append:添加(字符串末尾追加),可追加字符、字符数组、字符串、boolean类型的数据
		 *   delete:删除(删除制指定区域的内容)
		 *   deleteCharAt(int index):删除指定索引位置的字符
		 *   insert：插入数据
		 *   toString:得到String类型的数据
		 *   replace:替换制定区域的数据
		 *   reverse:翻转字符串数据
		 */
		StringBuffer sb = new StringBuffer("hahabibu");
		//1.append：在末尾追加内容
		sb.append("hello").append(18).append(true);
		System.out.println(sb);//hahabibuhello18true
		//2.得到StringBuffer的大小(容量)
		System.out.println(sb.capacity());//24
		//3.插入字符串数据(其他类型参考相应的API文档)
		StringBuffer sb1 = new StringBuffer("haha");
		//insert(2, "xixi")：在第2个索引位置插入字符串xixi
		sb1.insert(2, "xixi");//haxixiha
		//4.delete:删除数据(包括左侧的而不包括右侧的部分)
		sb1.delete(2, 5);//haiha
		//5.反转字符串
		StringBuffer sb2 = new StringBuffer("olleh");
		System.out.println(sb2.reverse());//hello
		//6.打印字符串长度、转化为相应的String类型
		System.out.println(sb2.length());//5
		System.out.println(sb2.toString());//hello
		/**
		 * 2.StringBuffer、StringBuilder与String类型之间的转化
		 * a.StringBuffer、StringBuilder-->String
		 *   利用toString方法
		 *   借助+（连接）符号,加上一个空的字符串
		 * b.String-->StringBuffer、StringBuilder
		 *   利用StringBuffer、StringBuilder各自的构造方法
		 */
		/**
		 * 分析StringBuffer的capacity
		 * 与StringBuffer底层的构造相关
		 * 其构造函数的初始化容量大小为16，一旦超出这个大小，会利用append
		 * 进行扩容,最终的容量为16+length(length为字符串数据的长度)
		 * 参考源代码实现简单理解
		 */
		StringBuffer sbt = new StringBuffer();
		System.out.println(sbt.capacity());//16
		StringBuffer sbt1 = new StringBuffer("a");
		System.out.println(sbt1.capacity());//17
	}
}

• 分析StringBulider的容量

• Value是一个数组

• 通过构造函数进行初始化

• StringBulider类中 构造函数 初始大小容量是16

• append进行扩容

• String、StringBuffer、StringBuilder的区别

String类与StringBuffer类、StringBuider类都是用于存储字符串类型的数据，但String类（不可变类）存储的是不可变的字符串序列（即一个String对象被创建之后，包含在这个字符串对象的字符序列不能够被改变，直到该对象被销毁、被垃圾回收都不会改变），而StringBuffer类、StringBuilder类存储的是可变的字符串序列，可通过该类对应提供的append/insert/reverse/setCharAt等方法改变对应字符串对象的字符序列。但StringBuffer是线程安全的，StringBuilder是线程不安全的

4.StringTokenizer

public class StringTokenizerTest {
	/**
	 * 对于特殊字符，无法直接通过String类型的split方法对指定字符串进行分隔，
	 * 由此可以通过StringTokenizer能够实现以指定特殊字符分割字符串，之后
	 * 还会介绍正则表达式相关的内容，借助正则表达式，实现指定格式的字符串分割
	 */
	public static void main(String[] args) {
		String str = "haha /*+%^&*@bibu/*+%^&*@gogo/*+%^&*@study/*+%^&*@lalala";
		String[] strs = str.split("/*+%^&*@");
		for(String s:strs)
			System.out.print(s+"-");
			/**
		 * 上述操作得到的结果是：
		 * haha /*+%^&*@bibu/*+%^&*@gogo/*+%^&*@study/*+%^&*@lalala-
		 * 显然通过String类型split方法无法直接以特殊的字符分割指定字符串
		 */
		//借助StringTokenizer实现
		//第1个参数是要进行分割的字符串，第2个参数是以什么指定字符进行分割
		StringTokenizer st = new StringTokenizer(str,"/*+%^&*@");
		//打印相关的数据信息
		while(st.hasMoreTokens())
			System.out.print(st.nextToken()+"-");
	}
}

练习：五子棋的应用

public class Chess {
	/**
	 * 设计一个基于控制台的五子棋
	 */
	//1.定义棋盘格局10*10
	public static char[][] board = new char[10][10];
	//2.定义下棋标志(一人走一步)
	public static boolean flag = true;
	//3.初始化棋盘(用特殊符号)
	public static void init()
	{
		for(int i=0;i<board.length;i++)
			for(int j=0;j<board.length;j++)
			{
				board[i][j]='+';
			}
	}
	//4.获取用户输入,控制棋盘
	public static void play(int x,int y)
	{
		if(board[x][y]=='+')
		{
			if(flag)
			{
				board[x-1][y-1] = '★';
				System.out.println("白棋已走，转换选手...");
				flag = false;
			}
			else
			{
				board[x-1][y-1] = '●';
				System.out.println("黑棋已走，转换选手");
				flag = true;
			}
		}
		else
			System.out.println("不能重复覆盖棋子，请重新进行操作...");
	}
	//5.每次一步结束后，刷新棋盘
	public static void print()
	{
		for(int i=0;i<board.length;i++)
		{
			for(int j=0;j<board.length;j++)
				System.out.print(board[i][j]);
			System.out.println();
		}
	}
	public static void main(String[] args) {
		//测试基于控制台的五子棋
		init();
		print();
		System.out.println("请输入操作要放置的位置：（输入格式：x-y）");
		Scanner sc = new Scanner(System.in);
		while(sc.hasNext())
		{
			System.out.println("请输入操作要放置的位置：（输入格式：x-y）");
			String[] s = sc.next().split("-");
			int x = Integer.valueOf(s[0]);
			int y = Integer.valueOf(s[1]);
			play(x,y);
			print();
		}
	}
}