黑马程序员--- 学习笔记(第十三天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
String类
字符串是一个特殊的对象
字符串是一个初始化就不能被修改对象


String s="abc"'
//s是一个类类型变量,"abc"是一个对象


//字符串最大的特点:一但初始化就不可以被改变


字符串既是既是一个对象,也是一个常量


Sring重写了equals方法,用来判断字符串内容是否相等


String s1="ab";
String s2=new String("ab");
//s1和s2的区别?
s1代表一个对象
s2代表有两个对象


String类是用于描述字符串事物,那么它就提供了多个方法对字符串进行操作


常见的操作:
1.获取
1.1获取字符串的长度
length();
1.2根据对象返回字符
charAt(index);//如果访问到了没有的下标,抛字符串越界异常
1.3根据字符串返回下标
indexOf(ch);//返回该字符首次出现位置 如果没找到返回-1
lastIndexOf(ch);//返回该字符最后一次出现位置 如果没找到返回-1
1.4 返回指定索引处的字符ASCII码。
codePointAt(index);


2.判断
2.1是否包含某一个字串
contains(charsequence);
2.2是否有内容
isEmpty();//1.6才有的, 就是判断字符长度是否为0
2.3以指定内容开头,结尾
startsWith();//判断是否以什么开头
endsWith();  //判断是否以什么结尾




特殊之处:indexOf(ch):可以索引第一次出现位置,如果返回-1表示不在
字符串中存在,所以也可以对指定内容判断是否包含
if(indexOf("aa")!=-1)
而且该方法既可以判断,也可以获取出现的位置


2.4判断字符串内容是否相等
equals();
2.5忽略大小写判断字符内容是否相等
equalsIgnoreCase();
3.转化
3.1将字符串数组转字符串
  构造函数 String(char[])
  copyValueOf();
3.2将字符串转为字符数组
toCharArray();
3.3将字节数组转成字符串
  构造函数 String(byte[])
3.4将字符串转成字节数组
getBytes();
3.5.将基本数据类型转成成字符串
valueOf(基本数据类型);


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


4.切割和替换
4.1替换
replace(old,new);//如果替换的字符不存在,返回还是原串
replace(oldCharsequence,newCharsequence);
4.2切割
split(切割的字符);//返回字符串数组
5.字串
5.1获取字串中的一部分
substring(beginIndex);
substring(begin,end);//包含头,不包含尾
6转换,去两端空格,比较
6.1将字串串转成大写或者小写
toUpperCase();//转大写
toLowerCase();//转小写
6.2将两端字符串多个空格去掉
trim();
6.3对两个字符串进行自然顺序比较
compareTo(str);

/*
字符串String 测试类
*/
class Demo1 
{
	public static void main(String[] args) 
	{
		// method_1();
		//method_2();
		//method_3();
		method_4();
	}
	public static void method_1(){
		String s="yingui";

		// int indexOf(int ch) 
	    // 返回指定字符在此字符串中第一次出现处的索引。 
		 sop(s.indexOf('i'));

		// int indexOf(int ch, int fromIndex) 
        //  返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 
		 sop(s.indexOf('i',2));
		
		//int indexOf(String str) 
        //  返回指定子字符串在此字符串中第一次出现处的索引。 
		 sop(s.indexOf("ng"));


		//int indexOf(String str, int fromIndex) 
        //  返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 
		sop(s.indexOf("i",2));
	
		// char charAt(int index) 
        //  返回指定索引处的 char 值。 
			sop(s.charAt(0));

		//  int codePointAt(int index) 
        //  返回指定索引处的字符（Unicode 代码点）。
			sop(s.codePointAt(0));

		 //   int lastIndexOf(int ch) 
       //   返回指定字符在此字符串中最后一次出现处的索引。
	   	  sop(s.lastIndexOf('i'));

		//int lastIndexOf(int ch, int fromIndex) 
         // 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 
		   sop(s.lastIndexOf('i',6));
		
		// int lastIndexOf(String str) 
       //   返回指定子字符串在此字符串中最右边出现处的索引。 
		  sop(s.lastIndexOf("ng"));

		//int lastIndexOf(String str, int fromIndex) 
       //   返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 
		 sop(s.lastIndexOf("i",2));
		
		// int length() 
 		  //     返回此字符串的长度。
		sop(s.length());
	}
 
	public static void method_2(){
		String s="yingui";
		String work="work.java";
		//boolean contains(CharSequence s) 
       //   当且仅当此字符串包含指定的 char 值序列时，返回 true。

		sop(s.contains("ngu"));

	  //  boolean equals(Object anObject) 
       //   将此字符串与指定的对象比较。
	   sop("yingui".equals(s));

		//	   boolean endsWith(String suffix) 
     //     测试此字符串是否以指定的后缀结束。 
		sop(work.endsWith(".java"));
	 //   boolean isEmpty() 
     //     当且仅当 length() 为 0 时返回 true。 
	   sop(work.isEmpty());
	// boolean startsWith(String prefix) 
        //  测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
		sop(work.startsWith("work"));

	//	 boolean equalsIgnoreCase(String anotherString) 
     //     将此 String 与另一个 String 比较，不考虑大小写。
	 sop("YINGUI".equalsIgnoreCase(s));
	}

	public static void method_3(){
	char c[]={'a','c','d','f','g'};
	byte []b={5,5,5,5,8,8};
	//String(char[] value) 
    //      分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
	 sop(new String(c));
	// String(char[] value, int offset, int count) 
   //       分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
	sop(new String(c,0,2));
	
	//String(byte[] bytes) 
    //      通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
	sop(new String(b));
	//	 char[] toCharArray() 
    //      将此字符串转换为一个新的字符数组。 
	String s="yingui";
	char ch[]=s.toCharArray();
	for (char i : ch )
	{
		System.out.println(i);
	}
	//	 byte[] getBytes() 
    //      使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 
	byte []by=s.getBytes();
	 for (byte i : by )
	{
		System.out.println(i);
	}

	//	String(byte[] bytes, int offset, int length) 
     //     通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
	sop(new String(by,0,2));
	//	static String copyValueOf(char[] data) 
   ///       返回指定数组中表示该字符序列的 String。 
	sop(String.copyValueOf(ch));
	
	//static String copyValueOf(char[] data, int offset, int count) 
    //      返回指定数组中表示该字符序列的 String。 
	sop(String.copyValueOf(ch,0,3))	;
	//  static String valueOf(boolean b) 
    //      返回 boolean 参数的字符串表示形式。 
	sop(String.valueOf(true));
	//static String valueOf(char c) 
	//		  返回 char 参数的字符串表示形式。
	sop(String.valueOf('c'));
	///static String valueOf(char[] data) 
	//		  返回 char 数组参数的字符串表示形式。
	sop(String.valueOf(ch));
	//static String valueOf(char[] data, int offset, int count) 
	//		  返回 char 数组参数的特定子数组的字符串表示形式。 
	sop(String.valueOf(ch,0,4));
	//static String valueOf(double d) 
	//		  返回 double 参数的字符串表示形式。 
	sop(String.valueOf(3.414));
	//static String valueOf(float f) 
	//		  返回 float 参数的字符串表示形式。 
	sop(String.valueOf(3.151515f));
	//static String valueOf(int i) 
	//		  返回 int 参数的字符串表示形式。
	sop(String.valueOf(15));
	//static String valueOf(long l) 
	//		  返回 long 参数的字符串表示形式。 
	 sop(String.valueOf(1555555555l));
	}

	public static void method_4(){
	
		String s="ba,ma,jiejie,didi";
		// String[] split(String regex) 
       //   根据给定正则表达式的匹配拆分此字符串。 	
	 	String []arr=s.split(",");
		for(String ss : arr)
			System.out.println(ss);

	  // String replace(char oldChar, char newChar) 
      //    返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 
		sop(s.replace(',','-'));
		
		//String replace(CharSequence target, CharSequence replacement) 
       //   使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 
		sop(s.replace("ba","baba"));
		//  String substring(int beginIndex) 
       //   返回一个新的字符串，它是此字符串的一个子字符串。 
		sop(s.substring(2));
		// String substring(int beginIndex, int endIndex) 
        //  返回一个新字符串，它是此字符串的一个子字符串。 
		sop(s.substring(0,2));
		//String toUpperCase() 
       //   使用默认语言环境的规则将此 String 中的所有字符都转换为大写 
		sop(s.toUpperCase());
		//  String toLowerCase() 
       //   使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 
		sop(s.toLowerCase());
		//  String trim() 
        //  返回字符串的副本，忽略前导空白和尾部空白。 
		String tr="        as         ";
		sop(tr.trim());
		//  int compareTo(String anotherString) 
        //  按字典顺序比较两个字符串。 
		String one="abc";
		String two="acd";
		sop(one.compareTo(two));
		//int compareToIgnoreCase(String str) 
       //   按字典顺序比较两个字符串，不考虑大小写。 
		 two="AAS";
		 sop(one.compareToIgnoreCase(two));
	 }




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

String练习:

/*
字符串练习"

1.模拟一个trim方法,去除两端的空格

2.将一个字符串进行反转,将制定位置字符串进行反转

3.获取一个字符串在另一个字符串中出现的位置
  abkkcxdkkfekkskk
4.获取两个字符中最大相同字串
abcwerthelloyouidert
cvrjhellod
*/
class Demo2 
{
	public static void main(String[] args) 
	{
		String str="       aadda  a     ";
		sop(practice_1(str));
		String s="abcde";
		sop(practice_2(s,0,s.length()));
		sop(practice_2(s));
		String a="kkabkkcdkkeefkkskkasddkk";
		sop(practice_3(a,"kk"));
		String o="abcwerthelloyouidert";
		String t="cvrjhellod";
		sop(practice_4(t,o));
	}
	/*1.模拟一个trim方法,去除两端的空格*/
	public static String practice_1(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);
	}
	/*
	2.将一个字符串进行反转,将制定位置字符串进行反转*/
	public static String  practice_2(String str,int x,int y){
		char ch[]=str.toCharArray();
		for (int i=x,j=y-1;i<j ;i++,j-- )
		{
			swap(ch,i,j);
		}
		return new String(ch);
	}
	public static void swap(char []ch,int x, int y){
		char temp=ch[x];
		ch[x]=ch[y];
		ch[y]=temp;
	}
	public static String practice_2(String str){ 	
		return practice_2(str,0,str.length());
	}
	//3.获取一个字符串在另一个字符串中出现的位置
	public static int practice_3(String str,String key){
		int count=0;
		for (int i=0;((i=str.indexOf(key,i))!=-1) ;i+=key.length())
			count++;
		return count;
	
	}
	//.获取两个字符中最大相同字串
	public static String practice_4(String o,String t){
		String max="";
		String min="";
		max=(o.length()>t.length())?o:t;
		min=(max==o)?t:o;
		for (int i=0; i<min.length();i++ )
		{
			for (int j=0,k=min.length()-i;k!=min.length()+1 ; j++,k++)
			{
				String temp=min.substring(j,k);
				 if(max.contains(temp))
					 return temp;
			}
		}
			return "";
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

StringBuffer类
是字符串的缓冲区,是一个容器
StringBuffer容器的特点:
1.长度是可变的
2.可以一次操作多个数据类型
3.最终会通过toString变成字符串


1.存储
1.1将数据添加到已有数据的末尾处
append();
1.2将数据插入到指定位置
inset(位置,数据);
2.删除
2.1删除某个区间的数据
delete(start,end);
2.2删除指定位置的字符
delete(index);
2.3清空
delete(0,sb.length());
3.获取
3.1根据下标获取位置
charAt();
3.2根据字符返回下标
indexOf();//首次出现的位置


lastIndexOf(); //最后一次出现的位置
3.3获取字符串的长度
length();
3.4截取字符串
subString();//注意:返回的字符串
4.修改
4.1替换某个部分的字符串
replace(start,end,str);
4.2指定位置替换字符串
setCharAt(index,str);
5.反转
4.3反转字符串
reverse
6.将字符串编程数组
getChars(源开始,源结束,目的,目的开始);

class Demo3 
{
	public static void main(String[] args) 
	{
		method_3();
	}
	public static void method_1(){
	StringBuffer sb=new StringBuffer();
	// StringBuffer append(boolean b) 
    //      将 boolean 参数的字符串表示形式追加到序列。 
	 sb.append(true);
	   sop(sb);
	//StringBuffer append(char c) 
    //      将 char 参数的字符串表示形式追加到此序列。
	 sb.append('a');
	   sop(sb);
	//StringBuffer append(char[] str) 
    //      将 char 数组参数的字符串表示形式追加到此序列。
	char []c={'a','b','c'};
	sb.append(c);
	  sop(sb);
	//StringBuffer append(char[] str, int offset, int len) 
    //      将 char 数组参数的子数组的字符串表示形式追加到此序列。
	sb.append(c,0,1);
	  sop(sb);
	//StringBuffer append(CharSequence s) 
    //      将指定的 CharSequence 追加到该序列。 
	String s="string";
	sb.append(s);
	  sop(sb);
	//StringBuffer append(CharSequence s, int start, int end) 
    //      将指定 CharSequence 的子序列追加到此序列。 
	sb.append(s,0,1);
	  sop(sb);
	// StringBuffer append(double d) 
	 //     将 double 参数的字符串表示形式追加到此序列。
	 sb.append(3.45);
	   sop(sb);
	//StringBuffer append(float f) 
     //     将 float 参数的字符串表示形式追加到此序列。
	 sb.append(3.1414f);
	   sop(sb);
	//StringBuffer append(int i) 
     //     将 int 参数的字符串表示形式追加到此序列。
	 sb.append(41545);
	   sop(sb);
	//StringBuffer append(long lng) 
    //      将 long 参数的字符串表示形式追加到此序列。
	sb.append(4545l);
	  sop(sb);
	//StringBuffer append(Object obj) 
     //     追加 Object 参数的字符串表示形式。 
	 sb.append(new String("new"));
	   sop(sb);
	//StringBuffer append(String str) 
     //     将指定的字符串追加到此字符序列。 
	 sb.append(new String("str"));
	   sop(sb);
	// StringBuffer append(StringBuffer sb) 
    //      将指定的 StringBuffer 追加到此序列中。 
	sb.append(new StringBuffer("StringBuffer"));
	  sop(sb);
	//StringBuffer appendCodePoint(int codePoint) 
    //      将 codePoint 参数的字符串表示形式追加到此序列。
	sb.append(97);
	  sop(sb);
	}
	public static void method_2(){
		StringBuffer sb=new StringBuffer("hello");
	//	 StringBuffer insert(int offset, boolean b) 
    //      将 boolean 参数的字符串表示形式插入此序列中。
	sb.insert(0,true);
	sop(sb);
	//	StringBuffer insert(int offset, char c) 
     //     将 char 参数的字符串表示形式插入此序列中。
	 sb.insert(0,'n');
	 sop(sb);
	//	StringBuffer insert(int offset, char[] str) 
      //    将 char 数组参数的字符串表示形式插入此序列中。 
	 char []ch={'w','c'};
	 sb.insert(0,ch);
	 sop(sb);
	//	StringBuffer insert(int index, char[] str, int offset, int len) 
     //     将数组参数 str 的子数组的字符串表示形式插入此序列中。 
	sb.insert(0,ch,0,1);
	sop(sb);
	//	StringBuffer insert(int dstOffset, CharSequence s) 
   //       将指定 CharSequence 插入此序列中。 
	 sb.insert(0,new String("kengdie"));
	 sop(sb);
	//	 StringBuffer insert(int dstOffset, CharSequence s, int start, int end) 
     //     将指定 CharSequence 的子序列插入此序列中。 
	
	sb.insert(0,new String("kengdie"),0,4);
	sop(sb);

	//	StringBuffer insert(int offset, double d) 
	//          将 double 参数的字符串表示形式插入此序列中。 
	sb.insert(0,45.1213);
	sop(sb);
	//	StringBuffer insert(int offset, float f) 
     //     将 float 参数的字符串表示形式插入此序列中。 
	sb.insert(0,3.14f);
	sop(sb);
	//	 StringBuffer insert(int offset, int i) 
     //     将 int 参数的字符串表示形式插入此序列中。 
	sb.insert(0,5555);
	sop(sb);
	//	 StringBuffer insert(int offset, long l) 
     //     将 long 参数的字符串表示形式插入此序列中。 
	sb.insert(0,65666l);
	sop(sb);
	//	 StringBuffer insert(int offset, Object obj) 
     //     将 Object 参数的字符串表示形式插入此字符序列中。 
	sb.insert(0,new String("object"));
	sop(sb);
	//	StringBuffer insert(int offset, String str) 
   //       将字符串插入此字符序列中。 
	 sb.insert(0,new String("str"));
	 sop(sb);
	
	//	StringBuffer deleteCharAt(int index) 
    //      移除此序列指定位置的 char。 
	 sb.deleteCharAt(0);
	 sop(sb);
	//   StringBuffer delete(int start, int end) 
      //    移除此序列的子字符串中的字符。
	  System.out.println("清空之前"+sb.length());
	  sb.delete(0,sb.length());
	   System.out.println("清空之后"+sb.length());

	}
	public static void method_3(){
	
		StringBuffer sb=new StringBuffer("yingui");
		// int indexOf(String str) 
       //   返回第一次出现的指定子字符串在该字符串中的索引。 
		sop(sb.indexOf("y"));
		// int indexOf(String str, int fromIndex) 
       //   从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 
		sop(sb.indexOf("i",2));
		//   void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
       //   将字符从此序列复制到目标字符数组 dst。 
		char []c=new char[3];
		sb.getChars(0,3,c,0);
		for (int i=0;i<c.length ;i++ )
		{
			System.out.println(c[i]);
		}
			//    char charAt(int index) 
      //    返回此序列中指定索引处的 char 值。 
	  sop(sb.charAt(0));
	//	int codePointAt(int index) 
      //    返回指定索引处的字符（统一代码点）。 
	  sop(sb.codePointAt(0));
		// int lastIndexOf(String str) 
        //  返回最右边出现的指定子字符串在此字符串中的索引。
		sop(sb.lastIndexOf("i"));
	//	int lastIndexOf(String str, int fromIndex) 
      //    返回最后一次出现的指定子字符串在此字符串中的索引。
	  sop(sb.lastIndexOf("i",2));
	//	 StringBuffer replace(int start, int end, String str) 
      //    使用给定 String 中的字符替换此序列的子字符串中的字符。
	 sop(sb.replace(0,3,"one"));
	///	StringBuffer reverse() 
     //     将此字符序列用其反转形式取代。 
	 sop(sb.reverse());
		//void setCharAt(int index, char ch) 
     //     将给定索引处的字符设置为 ch。
	 sb.setCharAt(0,'c');
	//	 void setLength(int newLength) 
	sop(sb.length());
 	//	  String substring(int start) 
     //     返回一个新的 String，它包含此字符序列当前所包含的字符子序列。 
	sop(sb.substring(3));
	//	String substring(int start, int end) 
     //     返回一个新的 String，它包含此序列当前所包含的字符子序列。 
	sop(sb.substring(0,3));
	//	 String toString() 
     //     返回此序列中数据的字符串表示形式。
	 sop(sb.toString());


	}



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

StringBuilder类


在JDK1.5版本之后,出现了StringBuilder
StringBuilder是线程不同步的,但效率较高
StringBuffer 是线程同步的,但效率不如StringBuilder


以后开发,推荐使用StringBuilder


升级三个因素:
1.提高效率
2.简化书写
3.提高安全性




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


基本数据类型对象 包装类的常见作用:就是用于基本数据类型和字符串之间的转换


基本数据类型转字符串
基本数据类型+""
基本数据类型.toString();
字符串转成基本数据类型
//静态方法
parseInt();
parseLong();
parseDouble();
parseBoolean();
       //非静态方法
       intValue();


    使用的时候注意,传入格式不正确,会报NumberFormatException
 十进制转其他进制
toBinaryString();
toHexString();
toOctalString();
其他进制转成十进制
parseInt("3c",16);//后面参数接的进制

/*
基本数据类型测试
*/
 Demo4 
{
	public static void main(String[] args) 
	{
		String s="123";
		Integer i=Integer.parseInt(s);
		sop(i+5);
		Integer n=new Integer("500");
		sop(n+20);

		sop(i.intValue());

		/*十进制转二进制*/
		sop(Integer.toBinaryString(6));
		/*十进制转16进制*/
		 sop(Integer.toHexString(60));
		/*十进制转8进制*/
		sop(Integer.toOctalString(90));
		/*其他进制转十进制*/
		sop(Integer.parseInt("3c",16));//16
		sop(Integer.parseInt("50",8)); //8
		sop(Integer.parseInt("110",2));	//2
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

JDK1.5版本之后出现的新特性
Integer x=4;//自动装箱

x=x(原理intValue())+2;//进行了自动拆箱,变成了int类型和2进行加法运算,
在将和进行自动装箱


Integer i=128;
Integer b=128;


Integer one=1;
Integer two=1;
System.out.println(i==b);  //false
System.out.println(one==two);//true
因为one和听我指向了同一个Integer对象,因为当数组在byte范围内时,对于新特性

如果该数值存在,就不会在开辟内存空间

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————