Java.String(学习笔记)

学习Java时的代码笔记，排版可能有些问题，代码拿来直接就可以用，毕竟全手打，难免会有错，欢迎指正

/*
String类
字符串是一个特殊的对象
字符串一旦初始化就不可以被改变
String str = "abc";
String str1 = new String("abc");
有什么区别？
*/
class StringMainDemo1
{
	public static void main(String[] args)
	{
		String s = new String(); //这种方式不多见
		String s1 = ""; //这里和上面是一回事
		String s2 = "abc";//s2是一个类类型变量，"abc"是一个对象
		String s3 = new String("abc"); //和上面一回事
		/*
		S1和S2有什么区别
		S1在内存中有一个对象
		S2在内存中有两个对象
		*/
		System.out.println(s2==s3);
		System.out.println(s2.equals(s3));
	}
}
//==================================================================
class StringMainDemo2
{
	public static void main(String[] args)
	{
		String s1 = "abc";
		String s2 = new String("abc");
		String s3 = "abc"; //发现abc已经存在了，它就不会在开辟空间了，而是直接引用，它们指向同一个对象
		System.out.println(s1==s2);
		System.out.println(s1==s3);
	}
}
/*
String常见功能-获取和判断
String类适用于描述字符串事物
那么它就提供了多个方法对字符串进行操作
常见的操作有哪些？
1.获取
	1.1 字符串中包含的字符数，也就是字符串的长度
	    	int length() //返回此字符串的长度
	1.2 根据位置获取位置上的某个字符
	    	char charAt(int index)
	1.3 根据字符获取该字符在字符串中的位置
	    它接受的是Acsii码，所以是int类型，它有重载形式
	    	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) //可以索引str第一次出现的位置，如果返回-1,表示该str不在字符串中存在
	    			  //所以，也可以用于对指定str判断是否包含
	    		example:
	    			if(str.indexOf("aa")!=-1) //那么包含
	    			而且该方法既可以判断又可以获取出现的位置
	    			那么判断时到底用哪个方法呢？
	    		     答:如果你只为判断，就用contains，如果你又想判断，又想获取出现的位置
	    		        那么就用indexOf
	2.2 字符串中是否有内容
	    boolean isEmpty(); //原理就是判断，length是否为0
	2.3 字符串是否是以指定内容开头
	    boolean startsWith(str);
	2.4 字符串是否是以指定内容结尾
	    boolean endsWith(str);
	2.5 判断字符串的内容是否相同
	    boolean equals(str); //重写了Object类中的equals方法
	2.6 判断内容是否相同，并忽略大小写
	    boolean equalsIgnoreCase();
*/
class StringMainDemo3
{
	public static void main(String[] args)
	{
		method_get();
		method_is();
	}
	//获取
	public static void method_get()
	{
		String str = "abcdeakpf";
		//长度
		sop(str.length());
		//根据索引获取字符
		sop(str.charAt(4));
		//根据字符获取索引
		sop(str.indexOf('a',3)); //如果没有找到，返回-1
		//反向索引一个字符出现的位置
		sop(str.lastIndexOf("a")); //角标不会发生改变
		
	}
	//判断
	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 sop(Object obj)
	{
		System.out.println(obj);
	}
}
/*
String-常见功能-转换
1.将字符数组转换成字符串
	构造函数:String(char[])
		 String(char[],offset,count) //将字符数组中的一部分转换成字符串
	静态方法:static String copyValueOf(char[]);
		 static String copyValueOf(char[] data,int offset,int count)
		 static String valueOf(char[]); //将基本数据类型转换成字符串
2.将字符串转换成字符数组
	方法:char[] toCharArray()
3.将字节数组转换成字符串
	构造函数:String(byte[])
		 String(byte[],offset,count) //将字节数组中的一部分转换成字符串
4.将字符串转换成字节数组
	方法:byte[] getBytes()
*/
class StringMainDemo4
{
	public static void method_trans()
	{
		char[] arr = {'a','b','c','d','e','f'};
		String s = new String(arr);
		System.out.println("s="+s);
		
		//String s = new String(arr,1,3); //1表示从1下标开始，3表示取几个
		//System.out.println("s="+s);		
	}
}
/*
String-常见功能-切割和替换
	切割:
		String[] split(regex); //regex表示分隔符
	替换:
		String replace(char oldChar,char newChar);
		//如果要替换的字符不存在，返回的还是原串
	子串:
		String substring(int beginIndex) //获取一个字符串中的子串
		String substring(int beginIndex, int endIndex)
*/
class StringMainDemo5
{
	public static void main(String[] args)
	{
		method_replace();
		method_split();
		method_substring();
	}
	//切割
	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('a','n'); //把a替换成n
		String s2 = s.replace("java","world"); //替换字符串
		sop("s="+s);
		sop("s1="+s1);
		sop("s2="+s2);
	}
	//子串
	public static void method_substring()
	{
		String s = "abcdef";
		sop(s.substring(2));//从下标为2的开始到结尾处
		sop(s.substring(2,4));//从下标为2的开始到以下标为0的开始到下标为4的位置
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
/*
String-常见功能-转换、比较和去除空格
	转换:将字符串转换成大写或者小写
	     String toUpperCase();
	     String toLowerCase();
	去除:将字符串两端的多个空格去除
	     String trim();
	比较:对两个字符串进行自如顺序的比较
	     int compareTo(str);
*/
class StringMainDemo6
{
	public static void main(String[] args)
	{
		method_zhtrim();
	}
	//转换-去空格
	public static void method_zhtrim()
	{
		String s = "   Hello Java    ";
		sop(s.toUpperCase()); //转大写
		sop(s.toLowerCase()); //转小写
		sop(s.trim());//去除两端的空格
		 
	}
	//比较
	public static void method_compareTo()
	{
		String s1 = "abc"; 
		String s2 = "aaa";
		sop(s1.compareTo(s2)); //比较ascii值s1>s2返回正数，小于s2返回负数，等于s2返回0
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}	
}
/*
字符串练习1:
模拟一个trim方法,去除字符串两端的空格
思路:
	1.判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止
	  结尾处判断空格也是如此.
	2.当开始和结尾都判断到不是空格时，就是要获取的字符串
*/
class StringTestMainDemo1
{
	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)
	{
		System.out.println(str);
	}
}
/*
StringBuffer
字符串的组成原理就是通过该类实现的
StringBuffer可以对字符串内容进程增删
StringBuffer是一个容器
特点:
StringBuffer是可变长的
StringBuffer可以操作多个数据类型
StringBuffer最终会通过toString方法变成字符串
StringBuffer的功能:
1.存储
	StringBuffer append(data) //将指定的数据作为参数添加到已有数据的结尾处
	StringBUffer insert(index,data) //将指定的数据作为参数插入到已有数据的指定处
2.删除
	StringBuffer delete(start,end) //删除缓冲区中的数据，包含start,不包含end
	StringBuffer deleteCharAt(int index) //删除指定位置的字符
3.获取
	char 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 srcBegin, int srcEnd, char[] dst, int dstBegin)
*/
class StringBufferMainDemo1
{
	public static void main(String[] args)
	{
		method_add();
		method_delete();
		method_update();
		method_getChars();
		
	}
	//添加
	public static void method_add()
	{
		StringBuffer sb = new StringBuffer();
		sb.append("abc").append(true).append(35).insert(1,"qq");
		sop(sb.toString()); //abctrue35
		/*
		StringBuffer sb1 = sb.append(34);
		sop(sb.toString());
		sop(sb1.toString());
		sop("sb==sb1:"+(sb==sb1)); //两个对象相等
		*/	
	}
	//删除
	public static void method_delete()
	{
		StringBuffer sb = new StringBuffer("abcdef");
		sb.delete(1,3);//adef 1是b d是3 不包含end所以，不包含d 那么只删除bc
		sb.delete(0,sb.length()); //清空缓冲区
		sb.deleteCharAt(2); //删除指定位置的字符
		sop(sb.toString()); 
	}
	//修改
	public static void method_update()
	{
		StringBuffer sb = new StringBuffer("abcdef");
		sb.replace(1,4,"java"); //从1到4替换成Java
		sb.setCharAt(2,'k'); //将2角标替换成k
	}
	//将缓冲区中指定数据存储到指定字符数组中
	public static void method_getChars()
	{
		StringBuffer sb = new StringBuffer("abcdef");
		char[] chs = new char[4];
		sb.getChars(1,4,chs,1); //在sb对象中从1下标开始，到4下标结束，把数据插入到chs数组中，1下标开始的地方
		for(int x =0; x<chs.length; x++)
		{
			sop("chs["+x+"]="+chs[x]+";");
		}
	}
	public static void sop(String str)
	{
		System.out.println(str);
	}

}
/*
在jdk1.5版本之后，出现了StringBuilder，不同处在于
StringBuffer是线程同步的
	缺点，如果是单线程，会每次判断锁，所以效率不高
StringBuilder是线程不同步的
	因此，单线程用StringBuilder，多线程用StringBuffer
	以后开发建议使用StringBuilder
升级三个因素
1.提高效率
2.简化书写
3.提高安全性
*/
/*
基本数据类型对象包装类
byte//基本数据类型      Byte//引用数据类型
short//基本数据类型	    Short//引用数据类型
int//基本数据类型 	    Integer//引用数据类型
long//基本数据类型      Long//引用数据类型
boolean//基本数据类型   Boolean//引用数据类型
double//基本数据类型    Double//引用数据类型
char//基本数据类型      Char//引用数据类型	
基本数据类型对象包装类最常见的作用，就是用于
基本数据类型和字符串类型之间做转换
基本数据类型转成字符串
	基本数据类型+""
	基本数据类型.toString(基本数据类型值);
	如: Integer.toString(34); //将34整数变成"34"
字符串转成基本数据类型
	Integer.parseInt("123") //将字符串类型转换成int型
十进制转换成其他进制
	toBinaryString();
	toHexString();
	toOctalString();
其他进制转换成十进制
parseInt(string,radix) //将指定的字符串转换成指定的进制表现形式，此方法是静态的
对象调用方式
Integer另一种表现形式
Integer i = new Integer("123");
int x = i.intValue(); //这个方法是静态的
*/
class IntegerMainDemo1
{
	public static void main(String[] args)
	{
		//取整数类型的最大值
		sop("int max :" + Integer.MAX_VALUE);
		int num = Integer.parseInt("123");
		sop("num+"(num+4)); //127
		int x = Integer.parseInt("110",10); //将110转换成10进制
		int x1 = Integer.parseInt("110",2); //将110转换成2进制
	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}
class IntegerMainDemo2
{
	public static void main(String[] args)
	{
		method();
		//新特性
		Integer x = 4; //自动装箱,帮你省略了new Integer(4)，简化了书写
		x = x + 2;//x+2:x进行了自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x
		//那么它如何拆箱的呢？
		x.intValue(); //拆箱原理
		Integer m = 128;
		Integer n = 128;
		sop("m==n:"+(m==n)); //false

		Integer a = 127;
		Integer b = 127;
		sop("m==n:"+(a==b)); //true,因为a和b指向了同一个Integer对象，因为当数值在byte范围内容
		//对于新特性，如果该数值已经存在则不会在开辟新空间
	}

	public static void method()
	{
		Integer x = new Integer("123");
		Integer y = new Integer(123);
		sop("x==y:"+(x==y));
		sop("x.equals(y):"+x.equals(y)); //这里equals比较的是数值是否相同
	}

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