day13String获取判断切割替换。最大子串。StringBuffer。基本数据类型对象包装类如Integer。进制转换。自动装箱。

/*
String 类(java.lang.String)

public final class String
final 代表不能有子类

字符串是一个特殊的对象。
字符串一旦初始化就不可以改变。

String str = "abc"//这样定义方便。str是一个类类型变量，“abc”是一个对象。
			//字符串最大特点，一旦被初始化，就不可以被改变。
			str = "kk"值不是变了吗？
			不是abc变了，是str变了，指向了kk。abc的内容没有变过。

String str1 = new String("abc");
有一个构造函数。
str == str1//false
str.equals(str1)//true

为什么equals相等了呢？因为String复写了Object中的equals方法，
定义了自己独特的内容，该方法用来判断字符串是否相等。

str和str1有什么区别？面试题。
str在内存中代表一个对象，
String str1 = new String("abc");str1在内存中代表二个对象。



String s1 = "abc";
String s2 = new String ("abc");
String s3 = "abc";

s1==s2 false//
s1==s3 true//指向同一个对象。
--------
String 是用来描述字符串事物。那么它提供了多个方法对字符串进行操作。

主要学习二个方面。1不能改变，2常见方法

"abcd"
1：获取	
	1.1字符串的长度。 int length();返回此字符串的长度。

	1.2根据位置获取位置上的某个字符
		char charAt(int index) 
	1.3根据字符获取字符在字符串中的位置
		int indexOf(int ch) 返回的是ch指定字符在此字符串中第一次出现处的索引。
		indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
		
		int indexOf(String str)返回str在字符串第一次出现的位置
		int lastIndexOf(int ch);

2：判断
	2.1字符串中是否包含某一个子串
		boolean contains(CharSequence s) 
		
		特殊之处：indexOf(str):可以索引第一次出现的位置，
		如果返回-1，表示该str不在字符串中存在，
		所以也可以用于对指定判断是否包含。
		if(str.indexOf("aa")!=-1)
		而且该方法可以判断，又可以获取出现的位置。

	2.2字符串中是否有内容 
		 boolean isEmpty();1.6才有，判断lenth()为0，返回true;
	2.3字符串是否以指定内容开头
		boolean startsWith(Str);
	2.4字符串是否以指定内容结尾
		boolean endsWith(Str);
	2.5判断字符串的内容是否相同
		boolean equals(str);复写了Object类中的equals方法。
	2.6判断内容是否相同，并忽略大小写
		boolean equalsIgnoreCase();
		//邮箱用户名
	
	总结，自己多看多用String 中的方法，多用几次，必须熟练掌握。



3.转换
	3.1将字符数组转成字符串
		String(char[] value) 
		String(char[] value, int offset, int count) 
		//将字符数组中的一部分转成字符串

		静态方法：
			static String copyValueOf(char[]);
			static String copyValueOf(char[] data, int offset, int count) 
			返回指定数组中表示该字符序列的 String。

			static String valueOf(char[]);

	3.2将字符串转成字符数组
		char[] toCharArray() 将此字符串转换为一个新的字符数组。
		
		
	3.3将字节数组转成字符串
		String(byte[] value) 
		String(byte[] value, int offset, int count) 
	3.4将字符串转成字节数组
		byte[] getBytes();
	3.5将基本数据类型转成字符串
		static String valueOf(int)
		static String valueOf(double)
		//3+"";//String.valueOf(3);

		特殊：、字符串和字节数组在转换过程中，是可以指定编码表的。

4.替换
	replace(char oldChar, char newChar)
	返回一个新的字符串，它是通过用 newChar 
	替换此字符串中出现的所有 oldChar 得到的。

	replace(CharSequence target, CharSequence replacement) 

5切割
	String[] split(regex);

6子串。获取字符串中的一部分
	String substring(begin)
	String substring(begin,end);

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

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

		while(s.charAt(pos++)==" ")

		int x = s.length()-1;
		while(s.charAt(x)==" ");
		x--;

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

*/



class TestString
{
	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));//返回正数表示s1大。
	}
	public static void method_sub()
	{
		String s = "abcdef";

		sop(s.substring(2));//从指定位置开始到结尾,如果不存在，会出现角标异常
		sop(s.substring(2,4));//从指定位置开始。包含头，不包含尾。s.substring(0,s.length());
	}
	public static void method_split()
	{
		String s = "zhangsa,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('a','n');
		//如果要替换的字符不存在，返回的是原串。

		String s1 = s.replace("java","world");

		sop("s="+s);//s不变
		sop("s1="+s1);
	}
	public static void method_trans()
	{
		char[] arr = {'a','b','c','d','e','f'};
		String s = new String(arr,1,3); 
		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()
	{
		//1.获取各方法
		String str = "abcdeakpf";
		//长度
		sop(str.length());

		//根据索引获取字符
		sop(str.charAt(4));
		//当访问到字符串中不存在的角标时，会发生StringIndexOutOfBoundsException

		//根据字符获取索引
		sop(str.indexOf('a',3));//5,  
		sop(str.indexOf('m',3));//'m'如果没有找到，返回-1；

		反向索引一个字符，从后面开始查找,出现的位置。
		sop(str.lastIndexOf('a'));//5
	}

	public static void main(String[] args) 
	{
		//method_get();
		//method_is();
		//method_trans();
		//method_replace();
		//method_split();
		//method_sub();
		method_7();

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


//字符串练习题1---------4。java

package day13;

public class StringTest1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "jlabclisojowbcdojlio";
		String s = "osafabcjlbcdio";
		//System.out.println("str:"+trimTest(str));
		//System.out.println("str2:"+myResoure(str));
		//System.out.println("str2:"+myResoure_2(str,2,5));
		//System.out.println(myTest3(s,str));
		//getSubString(s,str);
		System.out.println("substring:"+getSubString(s,str));

	}
	 
	public static String getSubString(String str1,String str2)
	{
		//二个字符串最大的子串
		String str_1 = str1.length()>str2.length()?str1:str2;
		String str_2 = str1.length()<str2.length()?str1:str2;
		
		
		for(int length=str_2.length();length>0;length--)
		{
			for(int start = 0;start<str_2.length()-length+1;start++)
			{
				while(str_1.contains((str_2.substring(start,start+length))))
					return str_2.substring(start,start+length);
			}
		}
		return "";
		
	}
	
	public static int myTest3(String s,String ss)
	{
		//s在ss里出现的次数
		int count = 0;
		while(true)
		{
			int i = ss.indexOf(s);
			if(i==-1)
				break;
			ss = ss.substring(i+s.length());//不能写i+1.
			count++;
		}
		return count;
	}
	
	public static String myResoure_2(String str,int start,int end)
	{
		//反转部分字符串
		String str_1 = str.substring(0,start);
		String newStr = str.substring(start,end);
		String str_2 = str.substring(end,str.length());
		
		return str_1+myResoure(newStr)+str_2;
	}
	
	public static String myResoure(String str)
	{
		//反转字符串
		char[] arr = str.toCharArray();
		char[] newArr = new char[arr.length];
		for(int x=0;x<arr.length;x++)
		{
			newArr[arr.length-x-1] = arr[x];
		}
		return new String(newArr);
	}
	
	public static String trimTest(String str)
	{
		//去掉两端的空格
		int start = 0;int end = 0;
		char[] arr = str.toCharArray();
		if (arr.length == 0)
		{
			return "";
		}
		for(int x =0;x<arr.length;x++)
		{
			if(arr[x]!=' ')
			{
				start = x;
				break;
			}
		}
		for(int x =0;x<arr.length;x++)
		{
			if(arr[arr.length-x-1]!=' ')
			{
				end = arr.length-x-1;
				break;
			}
		}
		return str.substring(start,end+1);
	}

}

/*
StringBuffer是字符串缓冲区，是一个容器。
三个特点：
1长度是可以变化的。
2可以直接操作多个数据类型。
3最终会通过toString方法变成字符串
C create U update R read D delete

1.存储
StringBuffer append():将指定数据作为参数添加到指定数据的结尾处
StringBuffer insert(index,数据)：可以将数据插入到指定index位置
2删除
StringBuffer delete(int start,int end)删除缓冲区中的数据，
包含start，不包含end

StringBuffer deleteCharAt(index)
删除指定位置的字符

3获取
charAt(int index);
int indexOf(String str)
int lastIndexOf(String str)
int length()
string substring(int start,int end);注意返回。

4修改
StringBuffer replace(int start,int end,String str)

void setCharAt(int index,char ch) //注意没有返回值

5反转
StringBuffer reverse();

6将缓冲区的指定数据存储到指定字符数组中
void getChars(int scrBegin,int srcEnd,char[] dst,int dstBegin)
int dstBegin从哪一位开始存

---------------------------------------

在jdk1.5之后出现了StringBuilder

StringBuffer是线程同步，安全的，有锁。建议多线程使用。
StringBuilder是线程不同步的，不安全的，快捷。建议单线程使用。


java升级三个方面。
1。效率
2。简化书写
3。安全性
*/

class  StringBufferDemo
{
	public static void main(String[] args)
	{
		method_del();
	}
	public static void method_update()
	{
		StringBuffer sb = new StringBuffer("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());
		
		//删除c
		//sb.delete(2,3);
		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(("sb1==sb ") + (sb==sb1));//相等，返回同一个对象。
		sb.insert(1,"qq");//如果数字超出范围，角标越界。
		sop(sb.toString());
		//sop(sb1.toString());
	}

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

/*
基本数据类型对象包装类
byte Byte
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character

最常见操作:
就是用于基本数据类型和字符串类型之间做转换

基本数据类型转成字符串
	: 1. 基本数据类型+""
		2.基本数据类型.toString(基本数据类型值);
		如：Integer.toString(34);

字符串转成基本数据类型(关键部分)
xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123")//将字符串参数作为有符号的十进制整数进行解析。
boolean b = Boolean parseBoolean("true");

非静态的：Integer i = new Integer("123");//必须传入数字字符串
			int num = i.intValue();
			对象调用方式
			

十进制转成其他进制
toBinaryString();2
toHexString();16
toOctalString();8

其他进制转成十进制
int x = Integer.parseInt("110",2);
int x = Integer.parseInt("3c",16);
*/

class  IntegerDemo
{
	public static void main(String[] args) 
	{
		//sop("int max:"+Integer.MAX_VALUE);//最大值

		int num = Integer.parseInt("123");//必须传入数字格式的字符串

		sop("num="+(num+4));

		long x =Long.parseLong("123");

		sop(Integer.toBinaryString(-6));

	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}
<pre class="java" name="code">/*
JDK1.5版本以后新特性
*/

class IntegerDemo1 
{
	public static void main(String[] args) 
	{
		Integer x = new Integer(4);
		Integer x = 4;//自动装箱。//new Integer(4)还可以运算

		x = x+2;//x+2:x进行自动拆箱，变成了int类型，和2进行加法运算
				//再将和进行装箱赋值给x.(x.intValue)
			//注意Integer x = null;不能进行运算。


				/*
				Integer m = 128;
				Integer n = 128;
				//m==n吗？false

				Integer a = 127;
				Integer b= 127;

				a==b?true :指向了同一个Integer对象
				因为当数值在byte范围内，对于新特性，
				如果该值已经存在，就不会开辟新空间
				*/
	}
	
}