黑马程序员 java 基础 毕向东 面向对象 String StringBuffer StringBuilder 基本数据类型包装类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
黑马程序员 java 基础 毕向东 面向对象 String StringBuffer StringBuilder 基本数据类型包装类

1:String 简介

package day13String;

public class StringDemo1 {
	public static void main(String[] args) {
		String string1="abc";//string1 是类类型对象，“abc”是对象
		//字符串最大特点：一旦被初始化，就不可以被改变
		System.out.println("string1.hashCode():"+string1.hashCode());
		string1="aaa";
		System.out.println("string1.hashCode():"+string1.hashCode());
		//改变的是string1指向的对象地址
		/*-------------------------------------------------------------*/
		String string2=new String("abcd");//有两个对象   
		String string3="";
		String string4=new String();
		
		String string5=new String("abcd");
		System.out.println("string2.hashCode():"+string2.hashCode());
		System.out.println("string5.hashCode():"+string5.hashCode());
		
		String string6="abc";
		System.out.println("string1.hashCode():"+string1.hashCode());
		System.out.println("string6.hashCode():"+string6.hashCode());

		/* String 
		string1 有一个对象
		String2 和String5 有  两个对象
		方法区
		静态区
		常量池：固定不变的放在这里，字符串不会改变
		当字符内容相同时，不再创建新地址
		*/
		
	}

}

2：String 常用方法 length、 charAt 、replace 、indexOf、contains、stratWith、endWith、isEmpty、toArray、getBytes

package day13String;

/*
 * 描述字符串常见事物
 * 那么他就提供了多个方法对字符串进行操作
 * 常见方法：
 * ”abcdd“
 * 1：获取
 * 		1.1：字符串包含的字符数 ，即长度  length（）；获取长度
 * 		1.2：根据位置获取位置上的字符
 * 			char  charAt（int index）;
 * 		1.3:根据字符获取位置
 * 			int indexOf（int ch） ch 是ASCII码
 * 				返回ch在字符串第一次出现的位置
 * 			int indexOf（int ch，int Fromindex）从fromindex开始，返回ch在字符串第一次出现的位置
 * 
 * 2：判断
 * 		2.1 是否包含某个字符串
 * 			boolean contains(CharSequence chs);
 * 			特殊的地方：
 * 			indexOf(str )
 * 			也可以判断是否包含制定字符
 * 			该方法就可以判断，有可以获取出现的位置
 * 		2.2 字符串是否有内容
 * 			boolean isEmpty():原来就是判断长度是否为0
 * 		2.3 字符串是否已制定内容开头
 * 			boolean startsWith(String s);
 * 		2.4 字符串是否已制定内容结尾
 * 			boolean endsWith(String s);
 * 		2.5：判断字符串内容是否相同，复写了Object的方法
 * 			boolean equals();
 * 			boolean equalsIgnoreCase();? 忽略大小写
 * 3 转换
 * 		3.1： 将字符数组转成字符串
 * 				构造函数  String（char【】）
 * 						String（char[] ,int offset,int count）
 * 				静态方法  static String copyValueOf（char []）
 * 				静态方法  static String copyValueOf（char []）
 * 		3.2：将字符串转成字符数组
 * 				char[] toCharArray();
 * 		3.3：将字节数组转成字符串
 * 				构造函数  String（byte【】）
 * 						String（byte[] ,int offset,int count）
 * 		3.4： 将字符串转成字节数组
 * 				byte[]  geyBytes();
 * 		3.4：将基本类型转成字符串
 * 
 * 				静态方法  static String valueOf（char []）
 * 特殊：字符串和字符数组在转换过程中，可以指定编码表
 * 4:替换
 * 		String replace(char oldchar, char newchar)
 * 5:切割
 * 		String[] spilt( regex );
 * 6:子串
 * 		获取字符串中的一部分
 *     String subString( begin);
 *     String subString( begin，end);
 *7:转换  去除空格 比较
 *		7.1将字符串转成大写或者小写
 *			String toUpperCase（）；
 *			String toLowerCase（）；
 *		7.2将字符串两端的空格去掉
 *			String trim（）；
 *		7.3对两个字符串进行自然顺序的比较、
 *			int compareTo(String )
 *如果参数字符串等于此字符串，则返回 0 值；
 *如果按字典顺序此字符串小于字符串参数，则返回一个小于 0 的值；
 *如果按字典顺序此字符串大于字符串参数，则返回一个大于 0 的值。

 * 		
 * */
public class StringMethodDemo {
	public static void method_trans() {
		char[] arr={'a','b','c','d','e','f','g'};
		String string=new String(arr);
		sop(string);
	    string=new String(arr,1,3);
	    sop(string);
		
	    String string2="adagadgasd";
	    char [] chs=string2.toCharArray();
	    for (int i = 0; i < chs.length; i++) {
			sop("ch="+chs[i]);
		}
	}
	public static void method_is() {
		String string="ArrayDemo.java";
		sop(string.startsWith("Array"));
		sop(string.endsWith(".java"));
		sop(string.contains("Demo"));
	}
	public static void method_replace() {
		String string="ArrayDemo.java";
		String string2=string.replace('d', 'v');
		/*如果要替换的字符不存在，返回原串*/
		sop(string);
		sop(string2);
		
		String string3=string.replace("java","world");
		sop(string);
		sop(string3);
	}
	public static void method_splite() {
		String string="ArrayDemo.java,Hello.java";
		String s[]=string.split(",");
		System.out.println("--------1------");
		for (int i = 0; i < s.length; i++) {
			sop(s[i]);
		}

		System.out.println("-------2-------");
		String string2="ABBCDA";
//		String string2="ABBCD";
//		String string2="BBCDA";
		String s2[]=string2.split("A");
		for (int i = 0; i < s2.length; i++) {
			sop(s2[i]);
		}
		System.out.println("-------3-------");
		String s3[]=string2.split("BB");
		for (int i = 0; i < s3.length; i++) {
			sop(s3[i]);
		}
		System.out.println("------4--------");
	}
	public static void method_sub() {
		String string="ArrayDemo.java";
		sop(string.substring(2));//从指定位置到结尾
		sop(string.substring(2,4));//包含头不包含尾
	}
	public static void method_7() {
		String string="    Array  Demo. java  ";
		sop(string.toUpperCase());
		sop(string.toLowerCase());
		
		sop(string.trim());
		
		String string2="abac";
		String string3="abad";
		sop(string2.compareTo(string3));
	}
	public static void main(String[] args) {
		
		methon_get();
		method_is();
		method_trans();
		method_replace();
		method_splite();
		method_sub();
		method_7();
	}
	static void methon_get(){
		String s1="abcdefb";
		//长度
		sop(s1.length());
		
		//根据索引获取字符
		sop(s1.charAt(2));

//		sop(s1.charAt(32));
		//索引超过长度发生 java.lang.StringIndexOutOfBoundsException:
		//根据字符获取索引
		sop(s1.indexOf('b'));
		sop(s1.indexOf('b',2));

		sop(s1.indexOf('x'));//如果没有返回-1
		
		//反向索引
		sop(s1.lastIndexOf('b'));
		
	}
	static void sop(Object  o){
		System.out.println(o);
	}

}

3String 练习1

package day13String;

/*
1，模拟一个trim方法，去除字符串两端的空格。
	思路：
	1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
		结尾处判断空格也是如此。
	2，当开始和结尾都判断到不是空格时，就是要获取的字符串。

2，将一个字符串进行反转 将字符串中指定部分进行反转
	思路：
	1，曾经学习过对数组的元素进行反转。
	2，将字符串变成数组，对数组反转。
	3，将反转后的数组变成字符串。
	4，只要将或反转的部分的开始和结束位置作为参数传递即可。

*/
public class StringTest {

	public static void main(String[] args) {
		String string1="66aaaaaaaaaaa aaaaaaaa     ";
		System.out.println("<"+string1+">");
		System.out.println("<"+myTrim(string1)+">");
		
		System.out.println("<"+reverseString(string1)+">");

		System.out.println("<"+reverseString(string1,1,2)+">");
	}
	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 String reverseString(String str)
	{
		
		/*
		//字符串变数组
		char [] chs=str.toCharArray();
		reverse(chs);

		return new String(chs);
		//将数字编成字符串
		*/
		return reverseString( str,0,str.length()-1);
	}
	public static String reverseString(String str,int start,int end)
	{
		//字符串变数组
		char [] chs=str.toCharArray();
		reverse(chs,start,end);

		return new String(chs);
		//将数字编成字符串
		
	}
	public static void  reverse(char[] chs)
	{
		for (int start = 0,end=chs.length-1;start<end; start++,end--) {
			swap(chs,start,end);
		}
	}
	public static void  reverse(char[] chs,int x,int y)
	{
		for (int start = x,end=y;start<end; start++,end--) {
			swap(chs,start,end);
		}
	}
	private static void swap(char[] cha,int start,int end){
		char temp=cha[start];
		cha[start]=cha[end];
		cha[end]=temp;
	}
}

4 String练习2

package day13String;

public class StringTest2 {
/*
 * 3，获取一个字符串在另一个字符串中出现的次数。
	"abkkcdkkefkkskk"
	思路：
	1，定义个计数器。
	2，获取kk第一次出现的位置。
	3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
		每获取一次就计数一次。
	4，当获取不到时，计数完成。

*/
	public static int  getSubCount(String str,String key) {
		int count=0;
		int index=0;
		while((index=str.indexOf(key))!=-1){
			str=str.substring(index+key.length());
			System.out.println("str="+str);
			count++;
		}
		return count;
	}
	public static int  getSubCount_2(String str,String key) {
		int count=0;
		int index=0;
//		int fromIndex=0;
		while((index=str.indexOf(key, index))!=-1){
			index+=key.length();
			System.out.println("index ="+index);
			count++;
		}
		return count;
	}
	public static void main(String[] args) {
		
		String string="abooablloaoab";
		System.out.println(getSubCount(string, "ab"));
		System.out.println(getSubCount_2(string, "ab"));
	}

}

5 String 练习3

package day13String;

public class StringTest3 {
	/*
	4，获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
		"abcwerthelloyuiodef"
		"cvhellobnm"
		思路：
			1，将短的那个子串按照长度递减的方式获取到。
			2，将每获取到的子串去长串中判断是否包含，
				如果包含，已经找到！。
	*/
	public static void main(String[] args) {
		String string1="asfasfHellosdf";
		String string2="Hello";
		System.out.println(getMaxSubsString(string1,string2));
	}
	static String getMaxSubsString(String string1,String string2){
		String maxString="";
		String minString="";
		maxString= maxString.length()>minString.length()?string1:string2;
		minString =maxString ==string1?string2:string1;
		for (int x = 0; x < string2.length(); x++) {
			for (int y=0,z=string2.length()-x;z!=string2.length()+1;y++,z++) {
				String temp=string2.substring(y, z);
				System.out.println(temp);
				if (string1.contains(temp)) {
					return temp;
				}
			}
		}
		return null;
		
	}

}

6 StringBuffer 和 StringBuilder 简介以及常用方法append insert delete deleteCharAt replace getChars

package day13String;

public class StringBufferDemo {
/*StringBuffer 是字符串缓冲区
 * 是一个容器
 * 而且长度可变
 * 可以操作多种数据类型
 * 最终通过toString编程字符串
 * CURD
 * 1：存储
 * 		StringBUffer append（）；将指定数据作为参数添加到已有数据结尾处。
 * 		面团理论
 * 		StringBuffer insert(index ,数据)；
 * 2：删除
 * 		StringBuffer delete（start，end）删除数据，包含头。不包含尾部
 * 		StringBuffer deleteCharAt（index） 删除制定位置字符
 * 3：获取
 * 		charAt()
 * 		indexOf()
 * 		lastIndexOf（）；
 * 		substring（start，end）
 * 4：修改
 * 		StringBuffer replace（start，end，String str）；
 * 		void setCharAt（index,char）
 * 5：翻转
 * 		StringBuffer reverse（）;
 * 6:	void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
 * 		将StringBUffer存在字符数组中
 * 
 * 
 *  JDK  1.5 之后出现了StringBuilder 
 * 一个可变的字符序列。
 * 此类提供一个与 StringBuffer 兼容的 API，
 * ------------》但不保证同步。
 * 该类被设计用作 StringBuffer 的一个简易替换，
 * ------------》用在字符串缓冲区被单个线程使用的时候
 * （这种情况很普遍）。
 * 如果可能，建议优先采用该类，
 * 因为在大多数实现中，
 * -------------》它比 StringBuffer 要快。 
 * 
 * StringBuilder  线程不同步
 * StringBuffer   线程同步
 * 单线程清空洗StingBuilder更快
 * 将 StringBuilder 的实例用于多个线程是不安全的。
 * 如果需要这样的同步，则建议使用 StringBuffer。 
 * 建议使用StringBUilder
 * 
 * 升级3因素
 * ：
 * 1：提供效率
 * 2：简化书写
 * 3：提高安全性
 * */
	public static void main(String[] args) {
//		method_replace();
		method_getChars();
	}
	static void method_delete(){
		StringBuffer sb=new StringBuffer();
		sop(sb);
		StringBuffer sb1=sb.append(123456789);
		sop(sb);
		sb.insert(1, "aaa");
		sop(sb);
		sb.delete(2,4);
		sop("delete(2,4):"+sb);
		sb.deleteCharAt(3);
		sop(sb==sb1);
		sop(sb);
		sb.delete(0,sb.length());
		sop("delete(0,sb.length():"+sb);
		sop(sb1);
	}
	static void method_replace(){
		StringBuffer sb=new StringBuffer("123456789");
		sop(sb);
		sb.replace(2,5,"aaaaa");
		sop(sb);
		sb.setCharAt(2,'A');
		sop(sb);
	}
	static void method_getChars(){
		StringBuffer sb=new StringBuffer("123456789");
		sop(sb);
		char [] dst=new char[6];
		sb.getChars(2,5,dst,2);
		for (int i = 0; i < dst.length; i++) {
			sop("-->"+dst[i]);
		}
		sop(sb);
		sb.setCharAt(2,'A');
		sop(sb);
	}
	static void method_add(){
		StringBuffer sb=new StringBuffer();
		sop(sb);
		StringBuffer sb1=sb.append(34);
		sb.insert(1, "aaa");
		sop(sb==sb1);
		sop(sb);
		sop(sb1);
	}
	static void sop(Object o){
		System.out.println(o);
	}

}

7 基本数据类型封装类 Integer Long Float Double 简介和常用方法

package day13String;
/*
 * 基本数据类型 对象包装类
 * 基本数据类型byte 对象  类 Byte
 * short Short
 * int Integer
 * long Long
 * boolean Boolean
 * float Float 
 * char Character
 * double Double
 * 基本数据类型包装类最常用的作用是
 * 基本数据类型和字符串之间的转换
 * 
 * 基本数据类型  ------》字符串
 * 		基本数据类型 +“”；
 * 		基本数据类型.toString(基本数类型值)
 * 字符串------------》基本数据类型
 * 			基本数据类型.parseInt(String )
 * 
 * 10 进制----》其他进制
 *       toBinaryString();
 *       toHexString();
 *       toOctalString();
 * 其他进制----》十进制
 * 		parsrInt(String  ,int radix)radix 
 * 		使用第二个参数指定的的基数，
 * 将字符串参数解析为有符号的整数
 * */
public class IntegerDemo {
	public static void main(String args[]) {
		sop("int max:"+Integer.MAX_VALUE);
		sop(Integer.toString(55));
		sop(String.valueOf(222));
		sop(String.valueOf(254.5));
		int num=Integer.parseInt("15");
		sop(num+44);
		long a=Long.parseLong("2255");
		sop(a+44);
		double ad=Double.parseDouble("2255.5");
		sop(ad+44);
		boolean b=Boolean.parseBoolean("false");
		sop(b);
		
		sop(Integer.toBinaryString(-6));
		sop(Integer.toHexString(60));
		int x1=Integer.parseInt("10", 2);
		sop(x1);
		sop(Integer.parseInt("110", 2));
		
		Integer i=new Integer("123");
		int x=i.intValue();
		sop(x);
	}
	static void sop(Object o){
		System.out.println(o);
	}
}

8 Integer jdk 1.5 后新特性

package day13String;

/*JDK 1.5 之后出现 的特性*/
public class IntegerDemo1 {
	public static void main(String args[]) {
		Integer x=new Integer("123");
		Integer y=new Integer(123);
		sop("x==y:"+(x==y));//比较地址
		sop("x.equals(y)："+x.equals(y));
		//Integer x2=null;
		Integer x2=41;//自动装箱  new Integer
		x2=x2+2; 
		/*自动拆箱
		 * 变成int类型和 2进行加法运行，在进行装箱
		 * 赋值给  */
		
		Integer m=128;
		Integer n=128;
		sop("m==n:"+(m==n));//false
		
		Integer m1=127;
		Integer n1=127;
		sop("m==n:"+(m1==n1));//true
		/*'
		 * m1  和 m2  指向了同一个对象
		 * 因为 当数值在byte范围内是，对于新特性
		 * 如果该值已经存在，则不会开辟新的空间*/
	}
	static void sop(Object o){
		System.out.println(o);
	}
}

《黑马程序员_毕向东_Java基础视频教程第13天》

主要介绍了java 中常用字符串的封装类String，以及相关类StringBuffer 、StringBuilder 的常用方法

还介绍了java中 int float double byte 的对应基本数据类型封装类Integer、Float、Double、Byte 的特性和常用方法