Java笔记第十一课（String类&StringBuffer类）

Java常用类

 String类中的其他功能:

   替换功能:

   public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换

  public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
   去除字符串两端空格:

  public String trim()

  两个字符串进行比较:

  public int compareTo(String anotherString)  是Comparable接口中的方法(该接口可以实现一个自然排序）

public class StringDemo {
	
	public static void main(String[] args) {
		
		//定义字符串
		String s1 = "helloworld" ;
		
		//替换功能
		//public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
		//String s2 = s1.replace('l', 'k') ;
		//System.out.println("s:"+s2);
		//public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
		String s3 = s1.replaceAll("owo", "ak47") ;
		System.out.println("s3:"+s3);
		
		System.out.println("------------------");
		
		String s4 = " hello world " ;
		System.out.println("s4:"+"----"+s4+"----");
		//public String trim()
		String s5 = s4.trim() ;
		System.out.println("s5:"+"----"+s5+"----");
		
		//public int compareTo(String anotherString)
		String s6 = "hello" ;
		String s7 = "hello" ;
		String s8 = "abc" ;
		System.out.println("compareTo():"+s6.compareTo(s7));
		System.out.println("compareTo():"+s6.compareTo(s8));
	}
}
//定义字符串
		String s1 = "helloworld" ;
		
		//替换功能
		//public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
		//String s2 = s1.replace('l', 'k') ;
		//System.out.println("s:"+s2);
		//public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
		String s3 = s1.replaceAll("owo", "ak47") ;
		System.out.println("s3:"+s3);
		
		System.out.println("------------------");
		
		String s4 = " hello world " ;
		System.out.println("s4:"+"----"+s4+"----");
		//public String trim()
		String s5 = s4.trim() ;
		System.out.println("s5:"+"----"+s5+"----");
		
		//public int compareTo(String anotherString)
		String s6 = "hello" ;
		String s7 = "hello" ;
		String s8 = "abc" ;
		System.out.println("compareTo():"+s6.compareTo(s7));
		System.out.println("compareTo():"+s6.compareTo(s8));
	}
}

例;String一些方法的使用

public class StringTest {

		public static void main(String[] args) {
			//创建键盘录入对象
			Scanner sc = new Scanner(System.in) ;
			
			//录入并接收数据
			System.out.println("请您输入一个字符串:");
			String line = sc.nextLine() ;
			
			//将接收到的字符串截取
			String s1 = line.substring(0, 1) ;
			
			//将得到s1字符串转换成小写
			String s2 = s1.toLowerCase() ;
			
			//在将line字符串的其余字母字符截取出来
			String s3 = line.substring(1) ;
			//转换成大写
			String s4 = s3.toUpperCase() ;
			
			//s2和s4作品接
			String result = s2.concat(s4) ;
			System.out.println("result:"+result);
			System.out.println("------------------------------");
			
			//链式编程
			String result2 = line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase()) ;
			System.out.println("result2:"+result);
		}
}
//创建键盘录入对象
			Scanner sc = new Scanner(System.in) ;
			
			//录入并接收数据
			System.out.println("请您输入一个字符串:");
			String line = sc.nextLine() ;
			
			//将接收到的字符串截取
			String s1 = line.substring(0, 1) ;
			
			//将得到s1字符串转换成小写
			String s2 = s1.toLowerCase() ;
			
			//在将line字符串的其余字母字符截取出来
			String s3 = line.substring(1) ;
			//转换成大写
			String s4 = s3.toUpperCase() ;
			
			//s2和s4作品接
			String result = s2.concat(s4) ;
			System.out.println("result:"+result);
			System.out.println("------------------------------");
			
			//链式编程
			String result2 = line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase()) ;
			System.out.println("result2:"+result);
		}
}

扫描二维码关注公众号，回复： 2569176 查看本文章

char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)

字符串拼接：

例：

import java.util.Scanner;

/**
 * 需求:键盘录入一个字符串,将字符串进行反转
 * 
 * 举例:
 * 		"abc"--->"cba"
 * 
 * 分析:
 * 		1)创建键盘录入对象,录入并接收一个字符串
 * 		2)定义空字符串
 * 		3)可以将字符串转换成字符数组:toCharArray();
 * 		4)遍历字符数组,倒着遍历
 * 		5)遍历之后获取到字符串中的每一个字符,然后使用空串进行拼接
 * 		6)输出即可!
 * @author Apple
 */
public class StringTest3 {
	
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入数据并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
	/*	//定义一个空字符串
		String result = "" ;
		
		//将字符串转换成字符数组
		char[] chs = line.toCharArray() ;
		
		//遍历字符数组,倒着遍历
		for(int x = chs.length-1; x >=0 ; x --){
			//获取到每一个字符
			result+= chs[x] ;
		}*/
		
		String result = myReverse(line) ;
		
		//输出
		System.out.println("result:"+result);
	}
	
	//写一个功能实现
	public static String myReverse(String s){
		//定义空字符串
		String result = "" ;
		
		//将字符串字符数组
		char[] chs = s.toCharArray() ;
		
		//遍历字符数组
		for(int x = chs.length -1 ; x >=0; x --){
			//拼接每一个字符
			result+= chs[x];
		}
		
		return result ;
	}
}
/**
 * 需求:键盘录入一个字符串,将字符串进行反转
 * 
 * 举例:
 * 		"abc"--->"cba"
 * 
 * 分析:
 * 		1)创建键盘录入对象,录入并接收一个字符串
 * 		2)定义空字符串
 * 		3)可以将字符串转换成字符数组:toCharArray();
 * 		4)遍历字符数组,倒着遍历
 * 		5)遍历之后获取到字符串中的每一个字符,然后使用空串进行拼接
 * 		6)输出即可!
 * @author Apple
 */
public class StringTest3 {
	
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入数据并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
	/*	//定义一个空字符串
		String result = "" ;
		
		//将字符串转换成字符数组
		char[] chs = line.toCharArray() ;
		
		//遍历字符数组,倒着遍历
		for(int x = chs.length-1; x >=0 ; x --){
			//获取到每一个字符
			result+= chs[x] ;
		}*/
		
		String result = myReverse(line) ;
		
		//输出
		System.out.println("result:"+result);
	}
	
	//写一个功能实现
	public static String myReverse(String s){
		//定义空字符串
		String result = "" ;
		
		//将字符串字符数组
		char[] chs = s.toCharArray() ;
		
		//遍历字符数组
		for(int x = chs.length -1 ; x >=0; x --){
			//拼接每一个字符
			result+= chs[x];
		}
		
		return result ;
	}
}

StringBuffer：

 1.StringBuffer的构造方法:
   public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
   public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
   public StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始                                                      容量为 16 加上字符串参数的长度。
  
 2.常用的功能:
   public int length():获取字符串长度数
   public int capacity():获取当前字符串缓冲区的容量

public class StringBufferDemo {
	
	public static void main(String[] args) {
		//StringBuffer sb = "hello" ;
		//String s = "hello" ;
		//StringBuffer sb = s ;
		
		//public StringBuffer	()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符(构造方法)
		//创建一个字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		System.out.println("sb.length:"+sb.length());
		System.out.println("sb.capacity:"+sb.capacity());//16
		
		System.out.println("----------------------------");
		
		//	public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
		StringBuffer sb2 = new StringBuffer(50) ;
		System.out.println("sb2.length:"+sb2.length());
		System.out.println("sb2.capacity:"+sb2.capacity());//50
		
		System.out.println("----------------------------");
		
		StringBuffer sb3 = new StringBuffer("hello") ;
		System.out.println("sb3.length:"+sb3.length());
		System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度
		
	}
}
		//StringBuffer sb = "hello" ;
		//String s = "hello" ;
		//StringBuffer sb = s ;
		
		//public StringBuffer	()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符(构造方法)
		//创建一个字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		System.out.println("sb.length:"+sb.length());
		System.out.println("sb.capacity:"+sb.capacity());//16
		
		System.out.println("----------------------------");
		
		//	public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
		StringBuffer sb2 = new StringBuffer(50) ;
		System.out.println("sb2.length:"+sb2.length());
		System.out.println("sb2.capacity:"+sb2.capacity());//50
		
		System.out.println("----------------------------");
		
		StringBuffer sb3 = new StringBuffer("hello") ;
		System.out.println("sb3.length:"+sb3.length());
		System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度
		
	}
}

 StringBuffer中的和添加有关的方法
   public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)

  public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

public class StringBufferDemo2 {
	
	public static void main(String[] args) {
		
		//创建一个字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//追加数据
		/*sb.append("hello") ;
		sb.append(true) ;
		sb.append(13.45) ;
		sb.append('A') ;
		sb.append(12.56F);*/
		
		//链式编程
		sb.append("hello").append(true).append(13.45).append('A').append(12.56F);
		
		//public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
		
		sb.insert(5, "world") ;
		//输出
		System.out.println("sb:"+sb);
	}
}

		//创建一个字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//追加数据
		/*sb.append("hello") ;
		sb.append(true) ;
		sb.append(13.45) ;
		sb.append('A') ;
		sb.append(12.56F);*/
		
		//链式编程
		sb.append("hello").append(true).append(13.45).append('A').append(12.56F);
		
		//public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
		
		sb.insert(5, "world") ;
		//输出
		System.out.println("sb:"+sb);
	}
}

 StringBuffer的删除功能:
  public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
  public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!
 

public class StringBufferDemo3 {
	
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//给缓冲区追加数据
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		/*public StringBuffer deleteCharAt(int index)
		需求:要删除当前缓冲区中'e'这个字符
		sb.deleteCharAt(1) ;
		需求:要删除当前缓冲区中第一个'l'这个字符
		sb.deleteCharAt(1) ;*/
		
		//public StringBuffer delete(int start,int end)
		//sb.delete(5, 9) ;
		//从0索引开始,当前缓冲的字符串全部删除掉
		sb.delete(0, sb.length()) ;
		
		//输出
		System.out.println("sb:"+sb);
	}
}//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//给缓冲区追加数据
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		/*public StringBuffer deleteCharAt(int index)
		需求:要删除当前缓冲区中'e'这个字符
		sb.deleteCharAt(1) ;
		需求:要删除当前缓冲区中第一个'l'这个字符
		sb.deleteCharAt(1) ;*/
		
		//public StringBuffer delete(int start,int end)
		//sb.delete(5, 9) ;
		//从0索引开始,当前缓冲的字符串全部删除掉
		sb.delete(0, sb.length()) ;
		
		//输出
		System.out.println("sb:"+sb);
	}
}

StringBuffer的反转功能:

   public StringBuffer reverse():将此字符串中的字符序列直接反转

import java.util.Scanner;

public class StringBufferDemo4 {
	
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
		//可以创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer(line) ;
		//public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
		//反转功能
		 String result = sb.reverse().toString() ;
		 System.out.println("result:"+result);
		
		
	}
}
//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
		//可以创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer(line) ;
		//public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
		//反转功能
		 String result = sb.reverse().toString() ;
		 System.out.println("result:"+result);
		
		
	}
}

 StringBuffer的替换功能:
  public StringBuffer replace(int start, int end,String str)
  从指定位置开始到指定位置结束的字符用str子字符串去替代

public class StringBufferDemo5 {
	
	public static void main(String[] args) {
		
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//给缓冲添加数据
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		//public StringBuffer replace(int start, int end,String str)
		sb.replace(5, 10, "节日快乐") ;
		
		System.out.println("sb:"+sb);
	}
}

		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//给缓冲添加数据
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		//public StringBuffer replace(int start, int end,String str)
		sb.replace(5, 10, "节日快乐") ;
		
		System.out.println("sb:"+sb);
	}
}

StringBuffer的截取功能:
   public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

public class StringBufferDemo6 {
	
	public static void main(String[] args) {
		//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//添加
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		
		
		
		//public String substring(int start)
		//String s1 = sb.substring(5) ;
		//System.out.println("s1:"+s1);
		
		//public String substring(int start,int end)
		String s2 = sb.substring(5,10) ;
		System.out.println("s2:"+s2);
		System.out.println("sb:"+sb);
	}
}
//创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		
		//添加
		sb.append("hello") ;
		sb.append("world") ;
		sb.append("java") ;
		
		
		
		
		//public String substring(int start)
		//String s1 = sb.substring(5) ;
		//System.out.println("s1:"+s1);
		
		//public String substring(int start,int end)
		String s2 = sb.substring(5,10) ;
		System.out.println("s2:"+s2);
		System.out.println("sb:"+sb);
	}
}

 面试题1:
   String,   StringBuffer,  StringBuilder的区别?
  
   String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
   从线程角度考虑:
  StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!
 
   String和StringBuffer作为形式参数
 
   String类型作为形式参数和基本数据类型作为形式参数的效果一样!

 StringBuffer和数组的区别?

   两个共同特点:都属于容器类型的变量
   数组:只能存储同一种数据类型的元素,数组的长度是固定的 
   int[] arr = {10,20,40,50,"hello"}  错误的 
   StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串

关于String和StringBuffer 的一些练习

 类与类之间的转换
   A类型--->B类型
   这里面可能最终使用B类型里面的功能
   B类型--->A类型
   有时候需要的不是B类型,所以又要将B类型-->A类型
 
  StringBuffer--->String之间的相互转换

public class StringBufferTest {
	
	public static void main(String[] args) {
		//String--->StringBuffer
		//定义一个字符串
		String s = "hello" ;
		
		/*StringBuffer sb = "hello" ;
		StringBuffer sb = s ;*/
		//方式1)使用StringBuffer的构造方式:StringBuffer(String str)
		//创建一个字符串缓冲区并指向这个字符串
		StringBuffer sb = new StringBuffer(s) ;
		System.out.println("sb:"+sb);
		
		//方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()
		StringBuffer sb2 = new StringBuffer() ;
		sb2.append(s) ;
		System.out.println("sb2:"+sb2);
		
		System.out.println("--------------------");
		
		//StringBuffer--->String
		//有一个字符串缓冲区对象
		StringBuffer buffer = new StringBuffer("world") ;
		//1)方式1String的另一种构造方法:String(StringBuffer buffer)
		String s2 = new String(buffer) ;
		System.out.println("s2:"+s2);
		//2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
		String s3 = buffer.toString() ;
		System.out.println("s3:"+s3);
	}
}
//String--->StringBuffer
		//定义一个字符串
		String s = "hello" ;
		
		/*StringBuffer sb = "hello" ;
		StringBuffer sb = s ;*/
		//方式1)使用StringBuffer的构造方式:StringBuffer(String str)
		//创建一个字符串缓冲区并指向这个字符串
		StringBuffer sb = new StringBuffer(s) ;
		System.out.println("sb:"+sb);
		
		//方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()
		StringBuffer sb2 = new StringBuffer() ;
		sb2.append(s) ;
		System.out.println("sb2:"+sb2);
		
		System.out.println("--------------------");
		
		//StringBuffer--->String
		//有一个字符串缓冲区对象
		StringBuffer buffer = new StringBuffer("world") ;
		//1)方式1String的另一种构造方法:String(StringBuffer buffer)
		String s2 = new String(buffer) ;
		System.out.println("s2:"+s2);
		//2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
		String s3 = buffer.toString() ;
		System.out.println("s3:"+s3);
	}
}

将数组拼接成一个字符串,分别使用String和StringBuffer实现(定义功能方法)
  
   int[] arr = {11,55,33 ,44 ,22} ;
   形成这样一个字符串:[11, 55, 33, 44, 22] 
  分析:
   1)存在一个数组,静态初始化
  2)分别使用String和StringBuffer类型去完成
  

public class StringBufferTest2 {
	
	public static void main(String[] args) {
		//定义一个数组,静态初始化!
		int[] arr = {11,55,33,44,22} ;
		
		//方式1)使用String类型实现
		String result = arrayToString(arr) ;
		System.out.println("result:"+result);
		
		System.out.println("------------------------");
		//方式2:使用StringBuffer的append功能
		String result2 = arrayToString2(arr) ;
		System.out.println("result2: " + result2);
	}
	
	public static String arrayToString2(int[] arr){
		//1)创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		//sb对象追加左中括号
		sb.append("[") ;
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否是最大索引
			if(x==arr.length-1){
				//append追加
				sb.append(arr[x]);
			}else{
				sb.append(arr[x]).append(", ") ;
			}
		}
		
		sb.append("]") ;
		
		return sb.toString() ; //将StringBuffer--->String
	}
	
	/**
	 * 明确返回值类型:String
	 * 明确参数类型:int[] arr
	 */
	public static String arrayToString(int[] arr){
		
		//定义一个空字符串
		String result = "" ;
		
		//拼接左中括号
		result +="[" ;
		
		//遍历int数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否最大索引
			if(x==arr.length-1){
				//拼接元素以及"]"
				result += arr[x] ;
				result += "]" ;
			}else{
				result += arr[x] ;
				result += ", " ;
			}
		}
		return result ;
	}
}
//定义一个数组,静态初始化!
		int[] arr = {11,55,33,44,22} ;
		
		//方式1)使用String类型实现
		String result = arrayToString(arr) ;
		System.out.println("result:"+result);
		
		System.out.println("------------------------");
		//方式2:使用StringBuffer的append功能
		String result2 = arrayToString2(arr) ;
		System.out.println("result2: " + result2);
	}
	
	public static String arrayToString2(int[] arr){
		//1)创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer() ;
		//sb对象追加左中括号
		sb.append("[") ;
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否是最大索引
			if(x==arr.length-1){
				//append追加
				sb.append(arr[x]);
			}else{
				sb.append(arr[x]).append(", ") ;
			}
		}
		
		sb.append("]") ;
		
		return sb.toString() ; //将StringBuffer--->String
	}
	
	/**
	 * 明确返回值类型:String
	 * 明确参数类型:int[] arr
	 */
	public static String arrayToString(int[] arr){
		
		//定义一个空字符串
		String result = "" ;
		
		//拼接左中括号
		result +="[" ;
		
		//遍历int数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否最大索引
			if(x==arr.length-1){
				//拼接元素以及"]"
				result += arr[x] ;
				result += "]" ;
			}else{
				result += arr[x] ;
				result += ", " ;
			}
		}
		return result ;
	}
}

分别使用String和StringBuffer实现字符串的反转

import java.util.Scanner;

public class StringBufferTest3 {
	
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收
		System.out.println("请您输入一个字符串:");
		String str = sc.nextLine() ;
		
		//方式1:使用String类型进行拼接
		String result = myReverse(str) ;
		System.out.println("result:"+result);
		//方式2:使用StringBuffer的reverse()功能
		
		String result2 = myReverse2(str) ;
		System.out.println("result2:"+result2);
	}
	
	//StringBuffer的rever()方法实现
	public static String myReverse2(String s){
		//创建字符串缓冲区对象h
		/*StringBuffer sb = new StringBuffer(s) ;
		//开始调用反转功能
		sb.reverse() ;
		//返回
		return sb.toString() ;*/
		
		//一步完成:
		return new StringBuffer(s).reverse().toString() ;
	}
	
	
	//String类型的方式进行反转
	public static String myReverse(String s){
		//定义空串
		String result = "" ;
		
		//可以字符组其转成字符数组
		char[] chs = s.toCharArray() ;
		
		//倒着遍历
		for(int x = chs.length-1 ; x >=0 ; x --){
			//空串进行拼接
			result += chs[x] ;
		}
		
		return result ;
	}
}
//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收
		System.out.println("请您输入一个字符串:");
		String str = sc.nextLine() ;
		
		//方式1:使用String类型进行拼接
		String result = myReverse(str) ;
		System.out.println("result:"+result);
		//方式2:使用StringBuffer的reverse()功能
		
		String result2 = myReverse2(str) ;
		System.out.println("result2:"+result2);
	}
	
	//StringBuffer的rever()方法实现
	public static String myReverse2(String s){
		//创建字符串缓冲区对象h
		/*StringBuffer sb = new StringBuffer(s) ;
		//开始调用反转功能
		sb.reverse() ;
		//返回
		return sb.toString() ;*/
		
		//一步完成:
		return new StringBuffer(s).reverse().toString() ;
	}
	
	
	//String类型的方式进行反转
	public static String myReverse(String s){
		//定义空串
		String result = "" ;
		
		//可以字符组其转成字符数组
		char[] chs = s.toCharArray() ;
		
		//倒着遍历
		for(int x = chs.length-1 ; x >=0 ; x --){
			//空串进行拼接
			result += chs[x] ;
		}
		
		return result ;
	}
}

判断一个字符串是否是对称字符串
  
   例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
使用(String和StringBuffer实现这个功能)

分析:
用第一个字符和倒数第一个字符相比较
用二个字符和倒数第二个字符进行比较
...

public class StringBufferTest4 {
	
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
		//方式1:String类型的转换功能
		boolean flag = isSame(line) ;
		System.out.println("flag:"+flag);
		
		//方式2:间接的使用StringBuffer的reverse()功能
		boolean flag2 = isSame2(line) ;
		System.out.println("flag2:"+flag2);
	}
	
	public static boolean isSame2(String s){
		//直接一步
		//new StringBuffer(s).reverse().toString()--->StirngBuffer--->String
		return new StringBuffer(s).reverse().toString().equals(s) ;
	}
	
	/**
	 * 两个明确:
	 * 		返回值类型:boolean
	 * 		参数类型:String s
	 */
	/*public static boolean isSame(String s){
		
		//将字符串转换成字符数组
		char[] chs = s.toCharArray() ;
		
		for(int start = 0,end = chs.length -1 ; start<=end;start++,end--){
			//判断
			if(chs[start] != chs[end]){
				return false ;
			}
			
		}
		return true ;
	}*/
	
	public static boolean isSame(String s){
		//定义一个标记:假设返回值是true
		boolean flag = true ;
		
		//需要字符串转换成字符数组
		char[] chs = s.toCharArray();
		//遍历字符数组,获取前面索引对应的字符和后面索引的字符
		for(int start = 0 ,end = chs.length -1 ; start<=end ; start++,end--){
			//判断
			if(chs[start]!= chs[end]){
				//修改标记
				flag = false ;
				break ;
			}
		}
		return flag ;
	}
}
//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
		//方式1:String类型的转换功能
		boolean flag = isSame(line) ;
		System.out.println("flag:"+flag);
		
		//方式2:间接的使用StringBuffer的reverse()功能
		boolean flag2 = isSame2(line) ;
		System.out.println("flag2:"+flag2);
	}
	
	public static boolean isSame2(String s){
		//直接一步
		//new StringBuffer(s).reverse().toString()--->StirngBuffer--->String
		return new StringBuffer(s).reverse().toString().equals(s) ;
	}
	
	/**
	 * 两个明确:
	 * 		返回值类型:boolean
	 * 		参数类型:String s
	 */
	/*public static boolean isSame(String s){
		
		//将字符串转换成字符数组
		char[] chs = s.toCharArray() ;
		
		for(int start = 0,end = chs.length -1 ; start<=end;start++,end--){
			//判断
			if(chs[start] != chs[end]){
				return false ;
			}
			
		}
		return true ;
	}*/
	
	public static boolean isSame(String s){
		//定义一个标记:假设返回值是true
		boolean flag = true ;
		
		//需要字符串转换成字符数组
		char[] chs = s.toCharArray();
		//遍历字符数组,获取前面索引对应的字符和后面索引的字符
		for(int start = 0 ,end = chs.length -1 ; start<=end ; start++,end--){
			//判断
			if(chs[start]!= chs[end]){
				//修改标记
				flag = false ;
				break ;
			}
		}
		return flag ;
	}
}

Integer

 需求:求一个整数100对应的二进制,八进制,十六进制
  需求:要求出Integer类型范围:
  
 java的jkd5.0以后:还有一些新特性:自动拆装箱,可变参数,增强for循环,静态导入,枚举...
  
  对于每个基本数据类型都会被自动封装成一个引用类型
  基本类型      引用类型
  intInteger
  char            Character
  byte            Byte
  boolean       Boolean
  double         Double
  float             Float
  long             Long
  short           Short
  
  将基本类型--->引用类型的作用:就是为了和String类型作为转换
  
  

public class IntegerDemo {
	
	public static void main(String[] args) {
		//public static String toBinaryString(int i)
		System.out.println(Integer.toBinaryString(100)) ;
		
		//public static String toOctalString(int i)
		System.out.println(Integer.toOctalString(100));
		
		//public static String toHexString(int i)
		System.out.println(Integer.toHexString(100));
		
		//public static final int MAX_VALUE
		//public static final int MIN_VALUE
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483647
	}
}
//public static String toBinaryString(int i)
		System.out.println(Integer.toBinaryString(100)) ;
		
		//public static String toOctalString(int i)
		System.out.println(Integer.toOctalString(100));
		
		//public static String toHexString(int i)
		System.out.println(Integer.toHexString(100));
		
		//public static final int MAX_VALUE
		//public static final int MIN_VALUE
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483647
	}
}

Integer类的构造方式:
  public Integer(int value):将一个int类型的数据封装成一个引用类型
  public Integer(String s):将一个字符数类型封装成一个Integer类型
  注意事项:
  该字符串必须是数字字符串!,否则抛出异常:java.lang.NumberFormatException
 

public class IntegerDemo2 {
	
	public static void main(String[] args) {
		//public Integer(int value)
		//创建一个Integer对象
		Integer i = new Integer(100);
		//Integer i = 100 ;//jdk5以后的自动装箱!
		System.out.println("i:"+i);
		
		//public Integer(String s)
		//String s = "abc" ;
		String s = "20" ;
		Integer ii = new Integer(s) ;
		System.out.println("s:"+s);
	}
}
//public Integer(int value)
		//创建一个Integer对象
		Integer i = new Integer(100);
		//Integer i = 100 ;//jdk5以后的自动装箱!
		System.out.println("i:"+i);
		
		//public Integer(String s)
		//String s = "abc" ;
		String s = "20" ;
		Integer ii = new Integer(s) ;
		System.out.println("s:"+s);
	}
}

 int类型和String类型的相互转换

public class IntegerTest {
	
	public static void main(String[] args) {
		
		//定义一个int类型的数据
		int number = 100 ;
		
		//方式1)字符串拼接符
		String s1 = "" + number ;
		System.out.println("s1:"+s1);
		
		//方式2:int--->Integer类型
		Integer i = new Integer(number) ;
		//Integer--->String
		//public String toString()
		String s2 = i.toString() ;
		System.out.println("s2:"+s2);
		
		//方式3)public static String toString(int i)
		String s3 = Integer.toString(number) ;
		System.out.println("s3:"+s3);
		//方式4)
		//public static Integer valueOf(int i)
		Integer integer= Integer.valueOf(number) ;
		String s4 = integer.toString() ;
		System.out.println("s4:"+s4);
		
		System.out.println("---------------------------");
		
		//定义一个字符串:
		String s = "10" ;
		//方式1:String--->Integer---->int
		Integer ii = new Integer(s) ;
		//public int intValue()以 int 类型返回该 Integer 的值
		int num = ii.intValue() ;
		System.out.println("num:"+num);
		//public static int parseInt(String s)
		int num2 = Integer.parseInt(s) ;
		System.out.println("num2:"+num2);
		
		
		//Integer的内存缓存区:IntegerCashe
		//low = -128
		//high=127
		Integer i1 = 127 ;		//----->底层在封装的时候:Integer integer = Inteter.valueOf(int i) ;
		Integer i2 = 127 ;
		
		
		
		System.out.println(i1==i2);//true
		Integer i3 = 128 ;
		Integer i4 = 128 ;
		System.out.println(i3==i4);//false

	}
}
//定义一个int类型的数据
		int number = 100 ;
		
		//方式1)字符串拼接符
		String s1 = "" + number ;
		System.out.println("s1:"+s1);
		
		//方式2:int--->Integer类型
		Integer i = new Integer(number) ;
		//Integer--->String
		//public String toString()
		String s2 = i.toString() ;
		System.out.println("s2:"+s2);
		
		//方式3)public static String toString(int i)
		String s3 = Integer.toString(number) ;
		System.out.println("s3:"+s3);
		//方式4)
		//public static Integer valueOf(int i)
		Integer integer= Integer.valueOf(number) ;
		String s4 = integer.toString() ;
		System.out.println("s4:"+s4);
		
		System.out.println("---------------------------");
		
		//定义一个字符串:
		String s = "10" ;
		//方式1:String--->Integer---->int
		Integer ii = new Integer(s) ;
		//public int intValue()以 int 类型返回该 Integer 的值
		int num = ii.intValue() ;
		System.out.println("num:"+num);
		//public static int parseInt(String s)
		int num2 = Integer.parseInt(s) ;
		System.out.println("num2:"+num2);
		
		
		//Integer的内存缓存区:IntegerCashe
		//low = -128
		//high=127
		Integer i1 = 127 ;		//----->底层在封装的时候:Integer integer = Inteter.valueOf(int i) ;
		Integer i2 = 127 ;
		
		
		
		System.out.println(i1==i2);//true
		Integer i3 = 128 ;
		Integer i4 = 128 ;
		System.out.println(i3==i4);//false

	}
}

jdk5.0以后的新特性：自动拆装箱

public class IntegerTest2 {
	
	public static void main(String[] args) {
		//创建一个Integer对象
		Integer i = new Integer(100) ;
		i += 200 ;
		System.out.println("i:"+i);
		
		/**
		 * 通过反编译工具查看源码:
		 * 	Integer i = new Integer(100); //将int类型值通过构造的形式自动装箱为Integer类型
			i = Integer.valueOf(i.intValue() + 200);//i.intValue()--->int类型的数据:把Integer--->int:自动拆箱
			自动装箱了
			System.out.println((new StringBuilder("i:")).append(i).toString());
		 */
	}
}
//创建一个Integer对象
		Integer i = new Integer(100) ;
		i += 200 ;
		System.out.println("i:"+i);
		
		/**
		 * 通过反编译工具查看源码:
		 * 	Integer i = new Integer(100); //将int类型值通过构造的形式自动装箱为Integer类型
			i = Integer.valueOf(i.intValue() + 200);//i.intValue()--->int类型的数据:把Integer--->int:自动拆箱
			自动装箱了
			System.out.println((new StringBuilder("i:")).append(i).toString());
		 */
	}
}

Character：

 Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段
  构造方法:
  public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char值。 

public class CharacterDemo {
	
	public static void main(String[] args) {
		//创建一个Character类的对象
		//Character character = new Character((char)97) ;
		Character character = new Character('a') ;
		System.out.println("character:"+character);
	}
}
//创建一个Character类的对象
		//Character character = new Character((char)97) ;
		Character character = new Character('a') ;
		System.out.println("character:"+character);
	}
}

 Character类的判断功能:
   public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
   public static boolean isDigit(char ch)确定指定字符是否为数字。

 Character常用的转换功能:
   public static char toUpperCase(char ch):将指定字符转换成大写
   public static char toLowerCase(char ch):将指定字符转换成小写
 
 

public class CharacterDemo2 {
	public static void main(String[] args) {
		

		//public static boolean isLowerCase(char ch)确定指定字符是否为小写字母
		System.out.println("isLowerCase:"+Character.isLowerCase('a'));
		System.out.println("isLowerCase:"+Character.isLowerCase('A'));
		System.out.println("isLowerCase:"+Character.isLowerCase('0'));
		System.out.println("---------------------------------------");

		//public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
		System.out.println("isUpperCase:"+Character.isUpperCase('a'));
		System.out.println("isUpperCase:"+Character.isUpperCase('A'));
		System.out.println("isUpperCase:"+Character.isUpperCase('0'));
		System.out.println("---------------------------------------");
		
                //public static boolean isDigit(char ch)确定指定字符是否为数字。
		System.out.println("isDigit:"+Character.isDigit('a'));
		System.out.println("isDigit:"+Character.isDigit('A'));
		System.out.println("isDigit:"+Character.isDigit('0'));
		
		
	}
}
	//public static boolean isLowerCase(char ch)确定指定字符是否为小写字母
		System.out.println("isLowerCase:"+Character.isLowerCase('a'));
		System.out.println("isLowerCase:"+Character.isLowerCase('A'));
		System.out.println("isLowerCase:"+Character.isLowerCase('0'));
		System.out.println("---------------------------------------");

		//public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
		System.out.println("isUpperCase:"+Character.isUpperCase('a'));
		System.out.println("isUpperCase:"+Character.isUpperCase('A'));
		System.out.println("isUpperCase:"+Character.isUpperCase('0'));
		System.out.println("---------------------------------------");
		
                //public static boolean isDigit(char ch)确定指定字符是否为数字。
		System.out.println("isDigit:"+Character.isDigit('a'));
		System.out.println("isDigit:"+Character.isDigit('A'));
		System.out.println("isDigit:"+Character.isDigit('0'));
		
		
	}
}

 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)
   分析:
   1)定义三个统计变量
  bigCount 
   smallCount
numberCount
  2)创建键盘录入对象,录入并接收一个字符串
  3)将字符串转换成字符数组
  4)遍历字符数组,获取到每一个字符
  5)使用Character类中的判断功能判断是否是大写,小写,数字字符
  6)输出

import java.util.Scanner;

public class CharacterTest {
	
	public static void main(String[] args) {
		//定义三个统计变量
		int bigCount = 0 ;
		int smallCount = 0 ;
		int numberCount = 0;
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine();
		
		//将字符串转换成字符数组
		char[]  chs = line.toCharArray() ;
		for(int x = 0 ; x < chs.length ; x ++){
			//获取每一个字符
			char ch = chs[x] ;
			
			//判断
			if(Character.isUpperCase(ch)){
				bigCount ++ ;
			}else if(Character.isLowerCase(ch)){
				smallCount ++ ;
			}else if(Character.isDigit(ch)){
				numberCount ++ ;
			}
		}
		
		//输出
		System.out.println("大写字母字符共有:"+bigCount+"个");
		System.out.println("小写字母字符共有:"+smallCount+"个");
		System.out.println("数字字符共有:"+numberCount+"个");
	}
}
//定义三个统计变量
		int bigCount = 0 ;
		int smallCount = 0 ;
		int numberCount = 0;
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine();
		
		//将字符串转换成字符数组
		char[]  chs = line.toCharArray() ;
		for(int x = 0 ; x < chs.length ; x ++){
			//获取每一个字符
			char ch = chs[x] ;
			
			//判断
			if(Character.isUpperCase(ch)){
				bigCount ++ ;
			}else if(Character.isLowerCase(ch)){
				smallCount ++ ;
			}else if(Character.isDigit(ch)){
				numberCount ++ ;
			}
		}
		
		//输出
		System.out.println("大写字母字符共有:"+bigCount+"个");
		System.out.println("小写字母字符共有:"+smallCount+"个");
		System.out.println("数字字符共有:"+numberCount+"个");
	}
}

冒泡排序的思想:

  两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....

public class ArrayTest {
	
	public static void main(String[] args) {
		
		//定义一个数组,静态初始化
		int[] arr = {24,69,80,57,13} ;
		
		System.out.println("排序前:");
		//遍历数组
		printArray(arr) ;
		
		/*//第一次比较
		//arr.length-1:为了防止角标越剧
		//arr.length-1-0:为了减少比较的次数
		for(int x = 0 ; x < arr.length-1-0;x++){
			//判断:两两比较,大的往后方法
			if(arr[x]>arr[x+1]){
				//中间变量进行互换
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] = temp;
			}
		}
		System.out.println("第一次比较后:");
		printArray(arr) ;
		
		//第二次比较:
		for(int x = 0 ; x < arr.length-1-1; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第二次比较后:");
		printArray(arr) ;
		
		//第三次比较:
		//arr.length-1:为了防止角标越界
		////arr.length-1-2:为了减少比较的次数
		for(int x = 0 ; x < arr.length-1-2; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第三次比较后:");
		printArray(arr) ;
		
		//第三次比较:
		//arr.length-1:为了防止角标越界
		////arr.length-1-3:为了减少比较的次数
		for(int x = 0 ; x < arr.length-1-3; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第四次比较后:");
		printArray(arr) ;*/
		/**
		 * 上述代码重复度高,所以改进
		 */
	/*	for(int x = 0 ; x <4 ; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判断
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		
		System.out.println("排序后:");
		printArray(arr) ;*/
		
		/**
		 * 上述代码不够好,如果数组非常多,那么如何进行操作,应该定义一个功能,当前比较的次数是一个数组长度-1次
		 */
		bubbleSort(arr) ;
		System.out.println("排序后:");
		printArray(arr) ;
	}
	
	//冒泡排序的代码
	//最终版代码
	public static void bubbleSort(int[] arr){
		for(int x = 0 ; x < arr.length-1; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判断
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
	}
	
	//遍历数组的功能:[元素1,元素2,....]
	public static void printArray(int[] arr){
		System.out.print("[");
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否是最大索引
			if(x==arr.length-1){
				System.out.println(arr[x]+"]");
			}else{
				System.out.print(arr[x]+", ");
			}
		}
	}
}
//定义一个数组,静态初始化
		int[] arr = {24,69,80,57,13} ;
		
		System.out.println("排序前:");
		//遍历数组
		printArray(arr) ;
		
		/*//第一次比较
		//arr.length-1:为了防止角标越剧
		//arr.length-1-0:为了减少比较的次数
		for(int x = 0 ; x < arr.length-1-0;x++){
			//判断:两两比较,大的往后方法
			if(arr[x]>arr[x+1]){
				//中间变量进行互换
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] = temp;
			}
		}
		System.out.println("第一次比较后:");
		printArray(arr) ;
		
		//第二次比较:
		for(int x = 0 ; x < arr.length-1-1; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第二次比较后:");
		printArray(arr) ;
		
		//第三次比较:
		//arr.length-1:为了防止角标越界
		////arr.length-1-2:为了减少比较的次数
		for(int x = 0 ; x < arr.length-1-2; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第三次比较后:");
		printArray(arr) ;
		
		//第三次比较:
		//arr.length-1:为了防止角标越界
		////arr.length-1-3:为了减少比较的次数
		for(int x = 0 ; x < arr.length-1-3; x ++){
			if(arr[x]>arr[x+1]){
				int temp = arr[x] ;
				arr[x] = arr[x+1] ;
				arr[x+1] =temp ;
			}
		}
		System.out.println("第四次比较后:");
		printArray(arr) ;*/
		/**
		 * 上述代码重复度高,所以改进
		 */
	/*	for(int x = 0 ; x <4 ; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判断
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
		
		System.out.println("排序后:");
		printArray(arr) ;*/
		
		/**
		 * 上述代码不够好,如果数组非常多,那么如何进行操作,应该定义一个功能,当前比较的次数是一个数组长度-1次
		 */
		bubbleSort(arr) ;
		System.out.println("排序后:");
		printArray(arr) ;
	}
	
	//冒泡排序的代码
	//最终版代码
	public static void bubbleSort(int[] arr){
		for(int x = 0 ; x < arr.length-1; x ++){
			for(int y = 0 ; y < arr.length-1-x ; y++){
				//判断
				if(arr[y]>arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}
	}
	
	//遍历数组的功能:[元素1,元素2,....]
	public static void printArray(int[] arr){
		System.out.print("[");
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断是否是最大索引
			if(x==arr.length-1){
				System.out.println(arr[x]+"]");
			}else{
				System.out.print(arr[x]+", ");
			}
		}
	}
}