String类中的方法

package day13;

/**
 * 
 * @author zhaocx1
 * 
 */
public class StringDemo {
	public static void main(String[] args)// 主函数，整个函数的切入点
	{

		String s1 = "abc";// s1是一个类类型变量，"abc"是一个对象。
							// 字符串最大特点：一旦被初始化就不可以被更改。
		String s2 = new String("abc");

		/*
		 * s1和s2有什么区别： s1在内存中有一个对象 s2在内存中有两个对象
		 */
		System.out.println(s1 == s2);
		System.out.println(s1.equals(s2));// String类复写类Object类中equals方法，该方法用于判断字符串是否相同。
											// equals用来判断地址值。

		String a1 = "中国";
		String a2 = new String("中国");
		System.out.println(a1 == a2);
		System.out.println(a1.equals(a2));

	}

}

package day13;
/**
 * 
 * @author zhaocx1
 * 字符串的取出方法及相关内容
 */
/*
 * 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在字符串中出现的位置。
 * 
 * 2.判断。
 *  2.1字符串中是否包含某一个子串。
 *     boolean contains(str):
 *     特殊之处：indexof(str):可以索引第一次出现的位置，如果返回-1，表示str不再字符串中存在。
 *     所以，也可以用于对指定判断是否包含。
 *     if(str.indexOf("aa")!=-1)
 *     
 *     而且该方法既可以判断，也可以获取出现的位置。contains值判断好一些，indexOf同时好一些。
 *     
 *  2.2字符串中是否有内容。
 *     boolean isEmpty():原理就是判断长度是否为0.
 *  2.3字符串是否是以指定内容开头。
 *     boolean startsWith(str);
 *  2.4字符串是否是以指定内容结尾。
 *  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[] getByte():
 *  3.5将基本数据类型转成字符串。
 *      String valueOf(int)
 *      String valueOf(double)
 *      
 *特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
 */
public class StringDemo1 {
	public static void main(String[] args) {//主函数 ，整个函数的切入点
		method_trans();//调用方法
		method_is();
		method_get();
	}

	public static void method_trans() {//定义一个静态方法
		char[] arr = { 'a', 'b', 'v', 'x', 's', 'f' };//声明一个字符数组
		String s = new String(arr);//将字符数组转成字符串
		sop("s=" + s);//打印字符串内容
	}

	public static void method_is() {//顶以一个静态方法
		String str = "ArrayDemo.java";//定义一个字符串

		// 判断文件名称是否是Array单词开头。
		sop(str.startsWith("Array"));
		// 判断文件名称是否是.java的文件。
		sop(str.endsWith(".java"));
		// 判断文件中是否包含Demo.
		sop(str.contains("Demo"));
	}

	public static void method_get() {
		String str = "abcdeakpf";
		// 长度
		sop(str.length());
		
		// 根据索引获取字符。
		sop(str.charAt(4));// 当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException.
		
		// 根据字符获取索引。
		sop(str.indexOf('a', 3));// 没有找到，返回-1.
		// 反向索引一个字符出现位置。
		sop(str.lastIndexOf("a"));
	} 

	
	/*
	 * String s1="abc"; String s2=new String("abc"); String s3="abc";
	 * System.out.println(s1==s2); System.out.println(s1==s3); }
	 */
	public static void sop(Object obj) {//定义一个打印方法，接受的是Object类，基本数据类型的提升，String和int都可以打印。
		System.out.println(obj);
	}

}

package day13;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 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对两个字符串进行自然顺序的比较。 in compareTo(string);
 */
public class StringDemo2 {
	public static void main(String[] args) {// 主函数，整个函数的切入点
		method_7();// 调用静态方法
		method_sub();
		method_split();
		method_replace();
	}

	public static void method_7() {// 定义静态方法
		String s = "    Hello Java   ";// 声明一个字符串
		sop(s.toLowerCase());// 将字符串内容以小写形式打印出来
		sop(s.toUpperCase());// 将字符串内同以大写形式打印出来
		sop(s.trim());// 取出字符串前后的空格

		String s1 = "abc";
		String s2 = "aaa";
		sop(s1.compareTo(s2));// 对两个字符串进行比较
	}

	public static void method_sub() {
		String s = "abcdefg";
		sop(s.substring(2));// 从指定位置开始到结尾获取字符串内容。如果角标不存在，会出现字符串角标越界异常。
		sop(s.substring(2, 4));// 包含头，不包含尾。s.substring(0,s.length());
	}

	public static void method_split() {
		String s = "zhangsan,lisi,wangwu";
		String[] arr = s.split(",");// 以某种形式对字符串内容进行切割
		for (int x = 0; x < arr.length; x++) {
			sop(arr[x]);
		}
	}

	public static void method_replace() {
		String s = "hello java";
		// String s1 = s.replace('q', 'n');//如果要替换的字符不存在，返回的还是原串。

		String s1 = s.replace("java", "world");// 对字符串内容进行替换
		sop("s=" + s);
		sop("s1=" + s1);
	}

	public static void sop(Object obj) {// 定义打印方法，参数为Objec类型
		System.out.println(obj);
	}

}

package day13;
/**
 * 
 * @author zhaocx1
 * String类中的其它方法
 */
public class StringDemo3 {
	public static void main(String[] args) {//主函数，整个函数的切入点
		method_is();
		//method_trans();//调用静态方法
	}

	public static void method_trans() {//定义一个静态方法
		char[] arr = { 'a', 'd', 'c', 'b' };//声明一个字符数组

		String s = new String(arr, 1, 3);// 从脚标为1的位置开始取3个
		sop("s" + s);//打印获取的字符串内容
		String s1 = "sbcnff";//声明一个字符串
		char[] chs = s1.toCharArray();//将字符串转换成字符数组
		for (int x = 0; x < s1.length(); x++)
			sop("chs=" + chs[x]);//对字符数组进行遍历，打印字符数组内容

	}

	public static void method_is() {
		//String s1="abcnuhoabsnbf";
		// sop(s.length());//获取字符串的长度
		// sop(s.charAt(4));//获取字符串某角标的元素
		//sop(s1.lastIndexOf('n'));//从最后 一个角标开始往前数，某元素首次出现的角标位置
		// sop(s.indexOf('n',3));//从某一个角标位置开始，获取某一个元素的角标

		String s = "ArrayDemo.java";//声明一个字符串
		sop(s.isEmpty());//判断字符串是否为空
		sop(s.startsWith("Arr"));//判断字符串的开头
		sop(s.contains("De"));//判断字符串是否包含某些字符串
		sop(s.endsWith(".java"));//判断字符串的结尾

	}

	public static void sop(Object obj) {//定义打印方法，接受的参数是Object类
		System.out.println(obj);
	}
}

package day13;
/**
 * 
 * @author zhaocx1
 * 练习：取出字符串两端的空格
 */
class StringTest1 {

	public static void main(String[] args) {//主函数，整个函数的切入点
		String s = "    ab cd     ";//定义一个两端带有空格的字符串
		sop("(" + s + ")");//打印没有操作前的字符串内容
		s = myTrim(s);//切割空格
		sop("(" + s + ")");//打印操作后的字符串
	}

		// 练习 一，去除字符串两端空格。
	public static String myTrim(String str) {//定义一个静态方法，返回的是字符串。传递的参数内容必须是字符串
		int start = 0, end = str.length() - 1;
		while (start <= end && str.charAt(start) == ' ')
			start++;
		while (start <= end && str.charAt(end) == ' ')
			end--;
		return str.substring(start, end + 1);

	}
	public static void sop(String str) {//定义一个打印方法，接受的参数内容必须是Object类
		System.out.println(str);
	}
}

package day13;

/**
 * 
 * @author zhaocx1
 * 
 */
// 练习二：将字符串进行反转。
/*
 * 思路：1.将字符串变成数组。2.对数组反转。3.将数组变成字符串。
 */
class StringTest2 {
	public static void sop(String str) {
		System.out.println(str);
	}

	public static void main(String[] args) {
		String s = "    ab cd     ";// 定义一个字符串
		sop("(" + s + ")");// 输出字符串内容
		sop("(" + reverseString(s) + ")");//开始对字符串进行反转
	}

	public static String reverseString(String s) {
		// 字符串便数组。
		char[] chs = s.toCharArray();
		// 反转数组。
		reverse(chs);
		// 将数组变成字符串。
		return new String(chs);
	}

	private static void reverse(char[] arr) {// 定义一个静态的反转方法，并以字符数组作为参数
		for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
			swap(arr, start, end);// 调用交换符合条件的元素的位置的方法
		}
	}
	// 定义一个方法用来交换符合条件的元素的位置
	private static void swap(char[] arr, int x, int y) {
		char temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}

}

package day13;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * StringBuffer是一个容器，初始化之后可以对字符串内容进行修改。 String不可以。
 *
 * 是字符串缓冲区，是一个容器。 特点：
 * 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)
 *    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 dst,int dstBegin)
 * 
 *JDK1.5版本之後出現了StringBuilder.
 *StringBuffer是線程同步的。
 *StringBuilder是縣城不同步。
 *
 *以後開發，建議使用StringBuilder.
 *升級三個因素：
 *1.提高效率。
 *2.簡化書寫。
 *3.提高安全性。
 */
public class StringBuffer1 {
	public static void main(String[] args) {
		method_del();
		method_update(); 
	}

	public static void method_update() {
		//定义一个容器，并对容器进行初始化值
		StringBuilder sb = new StringBuilder("abcde");
		//将初始化的值进行替换
		sb.replace(1, 4, "java");
        //在指定位置插入一个字符
		sb.setCharAt(2, 'k');
       //输出字符串内容
		sop(sb.toString());
	}

	public static void method_del() {
		//定义一个容器，并对容器进行初始化值
		StringBuffer sb = new StringBuffer("abcde");
		//对指定角标位置的元素进行删除
		sb.delete(1, 3);
		//删除全部元素
		sb.delete(0, sb.length());
		//对指定角标位置的元素进行删除
		sb.deleteCharAt(2);
		 //输出字符串内容
		sop(sb.toString());
	}

	public static void method_add() {
		//定义一个容器，用于存储信息
		StringBuffer sb = new StringBuffer();
        //将指定数据添加到数据结尾处
		sb.append("abc").append(true).append(34);
		// StringBuffer sb1=sb.append(34);
		// sop("sb=sb1:"+(sb==sb1));
        //在指定位置插入某个元素
		sb.insert(1, "qq");
		sop(sb.toString());// abctrue34
		// sop(sb.toString());

	}

	public static void sop(String str) {// 定义一个静态打印方法，参数可接受的类型为字符串类型

		System.out.println(str);
	}
}

package day13;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 *基本數據類型對象包裝類。
 *   基本數據類型                                      引用數據類型
 * byte（小寫就是關鍵字、類型）  Byte（大寫就是類）
 *    short                 Short
 *    int                   Integer
 *    boolean               Boolean
 *    float                  Float
 *    double                 Double
 *    char                   Character
 *    
 *基本數據類型對象包裝類的最常見作用。
 *就是用於基本數據類型和字符串類型之間做轉換。
 *
 *基本數據類型轉成字符串。
 *    基本數據類型+""
 *    基本數據類型.toString(基本數據類型值);
 *    如：Integer.toString(34);//將34整數變成“34”。
 *字符串轉成基本數據類型。
 *   基本數據類型包裝：xxx a=Xxx.parseXxx(String);
 *   int a=Integer.parseInt("123");
 *   double b=Bouble. parseDouble("12.23");
 *   
 *   boolean b=Boolean.parseBoolean("true");
 *   
 *十進制轉成其它進制：
 * toBinaryString();
 * toHexString();
 * toOctalString();
 *其它進制轉成十進制：
 * parseInt(string,radix);
 */
public class BaseDataBaoZhuangDemo {
	public static void sop(String str)
	{
		System.out.println(str);
	}
	public static void main(String[] args)
	{
		//證書類型的最大值
		//sop("int max:"+Integer.MAX_VALUE);
		
		//將字符串轉成整數。
		int num=Integer.parseInt("123");//必須傳入數字格式的字符串。
		long x=Long.parseLong("123");
		
		sop("num="+(num+4));
		sop(Integer.toBinaryString(-6));//十进制转化成二进制
		sop(Integer.toHexString(60));//十进制转化成十六进制
		
		int a= Integer.parseInt("110",2);//将二进制转化成十进制
		sop("a="+a);
	} 

}