黑马程序员——API中的类

                                                  黑马程序员——API中的类
 ---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a 
href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ -------------------------------
                                                 
String:本身是final类 修饰字符串
1.对象一旦初始化，就不能够改变


String s1="abc"; s1是一个类型变量，“abc”是一个对象。
String s2=new String("abc");
String s3=new String("abc");
注意：
1.equals比较两个对象内容是否相等
s2.equals(s3) // ture;
2. ==比较的是值是否相等
s1==s2 //false 地址值不一样
 
package com.string.api;


import com.sun.org.apache.xpath.internal.operations.Equals;


public class StringConstruction {


/**
* @param args
*/
public static void main(String[] args) {
stringConstrcuctionDemo();
System.out.println("***************************");
stringConstrcuctionDemo1();

stringDemo(); //比较对象


}
private static void stringConstrcuctionDemo(){ //构造函数
char []arr={'w','d','L','b','c'};

String s=new String(arr,1,3);
System.out.print(s);
}
public static void stringConstrcuctionDemo1(){
String s=new String();//等效于String s="" 空引用  不等效于 String s=null;

byte [] arr={32,67,98,11,35};
String s1=new String(arr);
System.out.print(s1);
}
private static void stringDemo(){
String a="abc"; //创建字符串对象在常量池中

String b =new String("abc"); //new 个对象在堆中

System.out.print(a==b); //false 地址值不一样，
System.out.print(a.equals(b)); //equals 比较两个对象是否相等
}
}
练习题：


package com.string.api;


public class StringTest2 {


/**
* 查找一个字符字串在这个字符串出现的次数
* 分析：查找字符串是否存在，获取存在位置,使用indexof 完成
*     2.找到就记录其位置，剩余继续查找，剩余字符串起始位置是当前位置+字串长度
*     3通过循环查找，找不到就-1，用记录器记录
*/
public static void main(String[] args) {

String str="abadedcdabalecabaywzyw";
String son="aba";  //要查找的字串

int count=getStringcount(str, son);
System.out.print("记录数是："+count);




}
public static int getStringcount(String str,String son){ //定义计数器方法
int count=0;
int index=0;

while((index=str.indexOf(son,index))!=-1){
index=index+son.length();  
count++;
}
return count; 

}
/*
*   截取获取字串在整串的次数
*/
public static int getSonStringcount(String str,String son){ //定义计数器方法
//定义计数器
int count=0;
//定义出现的位置
int index=0;

while((index=str.indexOf(son))!=-1){
str=str.substring(index+son.length());  
count++;
}
return count; 

}


}
                                              
StringBuffer 是个容器，字符串缓存区
特点：1.存储内容可修改，
      2.长度是可以改变的。
   3.可以存储不同类型的数据
   4.最终要转换成字符串进行使用


既然是个容器对象，具备哪些功能？


1.添加
StringBuffer.append(date);
StringBuffer insert(index,date);


2.删除
StringBuffer delete(start,end);//包含头，不含尾，删除start到end-1 的元素
StringBuffer deleteCharAt(int,index);//删除指定位置


3.查找
char charAt(index);


4.修改
StringBuffer replace(start,end,string);将start至end-1替换成string
void setCharAt(index,char);替换指定位置
void setLength(len);将原字符串置为指定长度的字符串


5.反转
  StringBuffer reverse();


6.将缓冲区中的指定数据存储到字符数组中


  void getChars(int srcBegin,int srcEnd,char[] dst,int dstbegin)






package com.string.api;


public class StringBuffer {




void  StringBuffer(String string) {
// TODO Auto-generated constructor stub  //构造方法
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub


}
private static  void bufferMethodDemo1(){

StringBuffer sb=new StringBuffer("abce");//
         //  sb。delete(1,3);  //sb方法出错，要构造方法
}


private static  void bufferMethodDemo2(){

StringBuffer sb=new StringBuffer("abce");//
         //  sb。delete(1,3);
    //sb.insert(2,"qq");
}

private static  void bufferMethodDemo(){

StringBuffer sb=new StringBuffer("abce");//创建缓冲区对象
         //  sb。delete(1,3);
    //sb.insert(2,"qq");
  //sb.append(4).append(false);
}




}


StringBuilder
特点：StringBuilder 与 StringBuffer 功能类似
1.StringBuilder 线程不同步，用于单线程，提高效率。
2.StringBuffer 是线程同步的，多用于多线程。


package com.string.api;


public class StringBuilder {


/**
* @param args
*/
public static void main(String[] args) {

int [] arr={3,1,6,8,4};
String s=arrToString(arr);

System.out.print(s);


}
public static String  arrToString(int [] arr){  //数组转换成字符串
StringBuilder sb=new StringBuilder();
            sb.append("[");
            for(int i=0;i<arr.length;i++){
            if(i!=arr.length-1){
            sb.append(arr[i]+",");
             
            }else{
            sb.append(arr[i]+"]");
            }
            }

return  sb.toString();

}
private void append(String string) {  //创建append 方法
// TODO Auto-generated method stub

}

public static String  arrToString1(int [] arr){  ///数组转换成字符串

           String str="[";
            for(int i=0;i<arr.length;i++){
            if(i!=arr.length-1){
            str+=arr[i]+",";
             
            }else{
            str+=arr[i]+"]";
            }
            }

return  str;

}


}
打印：
com.string.api.StringBuilder@2c1e6b


StringBuffer 和 StringBuilder区别：，
StringBuffer 同步、线程安全，适用于多线程
StringBuilder 不同步 线程不安全，适用单线程，效率高


包装类及使用
1.基本类型对象的包装类
方便操作基本类型值，将其封装成对象，定义了属性和行为，丰富数据操作


左边到右边是封装，右转左则是拆箱，装箱与拆箱是一个相互的过程。
基本类型         封装类型
byte              Byte
short             Short
int               Integer
float             Float
double            Double


package com.study;


public class Test {


/**
* @param args
*/
public static void main(String[] args) {

// 十进制——>其他进制
System.out.println(Integer.toBinaryString(50));
System.out.println(Integer.toOctalString(50));
System.out.println(Integer.toHexString(50));


System.out.println(Integer.parseInt("ab", 16));


}






}
自动装箱：
如果装箱的是一个字节，那么数据会共享，不会再开辟空间。
package com.study;


public class WrapperDemo {


/**
* @param args
*/
public static void main(String[] args) {

// 十进制——>其他进制
int num=3;
num=num+5;
 
Integer i=4;//i=new Integer(4)  自动装箱，将int——>封装Integer
i=i+8; // i=new Integer(i.intValue()+8); //拆箱动作  i.intValue()

Integer a=new Integer(128);
Integer b=new Integer(128);

System.out.println(a==b); //false
System.out.println(a.equals(b));//true

          System.out.println(i);
          System.out.println("*********************");
          show( a);
          System.out.println("*********************"); 
          Integer x=128;
          Integer y=128;
          
      System.out.println(x==y); //false
System.out.println(x.equals(y));


}

public static void show(Object a){  //Object a=new Integer(55);
System.out.print(a);
}






}


习题：将字符串数值从小到大排序
package com.study;


import java.util.Arrays;






public class Test {


/**
*将字符串数值从小到排序
*分析：字符串中的值是用空格进行分隔的
*使用字符串对象分割方法将大串分成小串
*小字符串转换成int 可以使用包装类
*/
private static final String SPACE=" "; //静态常量  空格

public static void main(String[] args) {

String number="20 49 -12 87 21";
System.out.println(number);
number=sortStringNumber(number);
System.out.println("排序后的字符串是");
System.out.println(number);



}

public static String sortStringNumber(String number){  //排序
//1.将字符串变成字符数组
String [] arr=stringToArray(number);
//2.将字符串数组变成int数组  
int [] num_arr=toIntArray(arr);

//3.对Int 数组排序
mySortArray(num_arr);
 
//4.再将排序后的Int数组转成字符串
String temp=arrayToString(num_arr);


return temp;


}
//1.将字符串变成字符数组
public static String[] stringToArray(String number){  //字符串转字符数组方法

String [] arr=number.split(SPACE);

return arr; //返回数组类型


}

//2.字符串数组转换INT数组
public static int[] toIntArray(String [] arr){  
int [] num_arr=new int[arr.length];
for(int i=0;i<num_arr.length-1;i++){
num_arr[i]=Integer.parseInt(arr[i]);
}

return num_arr; 


}
//3.Int 数组排序
public static void mySortArray(int[] num_arr){
Arrays.sort(num_arr);
}


public static String arrayToString(int[] num_arr){
//4.再将排序后的Int数组转成字符串
      StringBuilder sb=new StringBuilder();
      for(int i=0;i<num_arr.length;i++)
      if(i!=num_arr.length-1){
      sb.append(num_arr[i]+SPACE);
      
      }else{
      sb.append(num_arr[i]);
      }
return sb.toString();

}


}




---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a 
href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ -------------------------------