java常用API知识点总结

                     黑马程序员_JAVA常用类API(StringBuffer类,数组高级应用,包装类

 34人阅读 评论(0) 收藏 举报

------- android培训java培训、期待与您交流!----------

StringBuffer:

概念:字符串缓冲区,缓冲区用于存储数据,所以也称之为容器.字符串的组成原理就是通过该类实现的.

StringBuffer(掌握)
(1)用字符串做拼接,比较耗时并且也耗内存,而这种拼接操作又是比较常见的,为了解决这个问题,Java就提供了
  一个字符串缓冲区类。StringBuffer供我们使用。
(2)StringBuffer的构造方法
A:StringBuffer()
B:StringBuffer(int size)
C:StringBuffer(String str)
(3)StringBuffer的常见功能(自己补齐方法的声明和方法的解释)
A:添加功能
append()
insert()
B:删除功能
deleteCharAt()
delete()
C:替换功能
replace()
D:反转功能
reverse()
E:截取功能(注意这个返回值)
substring()
一.StringBuffer与String的区别

效率更快,避免了过多字符串常量垃圾对象的产生

前者用于生成字符串,后者用于表示字符串

前者为常量,后者是“可变化的量”

二.StringBuffer的方法:

构造方法

public StringBuffer()  创建一个容量为16的缓冲区

public StringBuffer(String str)  构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容

该字符串的初始容量为 16 加上字符串参数的长度。 

普通方法

容量public int capacity() 返回当前容量        可以容纳的字符数

长度public int length()  返回内容的长度       已经容纳的字符数

代码演示:

[java] view plaincopy
  1. package cn.itcast;  
  2.   
  3. public class Demo2 {  
  4.   
  5.     public static void main(String[] args) {  
  6.   
  7.         StringBuffer sb = new StringBuffer();  
  8.           
  9.         sb.append("i");  
  10.         sb.append("love");  
  11.         sb.append("java");  
  12.         sb.append("!");  
  13.         sb.append("abcdefg");  
  14.           
  15.         System.out.println(sb.toString());  
  16.         System.out.println(sb.capacity());  
  17.         System.out.println(sb.length());  
  18.           
  19.         StringBuffer sb2 = new StringBuffer("i love code!");  
  20.           
  21.         System.out.println(sb2.capacity());  
  22.     }  
  23.   
  24. }  

StringBuffer普通方法

public StringBuffer append(XX xx)  追加  返回对象本身

public StringBuffer insert(int 插入的位置, XX xx)  插入  返回对象本身

public StringBuffer delete(int start, int end)  删除元素

public StringBuffer deleteCharAt(int index) 删除元素

public StringBuffer reverse() 将此字符序列用其反转形式取代

public StringBuffer replace(int start, int end, String str)  从哪开始到哪结束,替换成str

StringBuffer的一般使用顺序:   String >> StringBuffer(加工内容) >> String

代码演示:

[java] view plaincopy
  1. package cn.itcast;  
  2.   
  3. public class Demo3 {  
  4.   
  5.     public static void main(String[] args) {  
  6.   
  7.         StringBuffer sb = new StringBuffer();  
  8.         sb.append("i love java");  
  9.         sb.append(true);  
  10.         sb.append(new Demo());  
  11.         sb.append(100);  
  12.         // System.out.println(sb);  
  13.   
  14.         StringBuffer sb2 = new StringBuffer();  
  15.   
  16.         //由于StringBuffer可以返回对象本身,所以可以使用链式调用  
  17.         sb2.append(true)  
  18.             .append(100)  
  19.             .append("i love java")  
  20.             .append(new Demo())  
  21.             .append("aabcd")  
  22.             .insert(2"$$$")  
  23.             .append("abc");  
  24.   
  25.         System.out.println(sb2);  
  26.           
  27.         sb2.delete(03).deleteCharAt(0).reverse();  
  28.         System.out.println(sb2);  
  29.         sb2.replace(010"oy");  
  30.         System.out.println(sb2);  
  31.           
  32.         String s = sb2.toString();  
  33.         System.out.println(s);  
  34.     }  
  35.   
  36. }  

数组高级

数组排序:将数组的元素按照某种规则从小到大或者从大到小排列

冒泡排序:使用相邻的两个元素依次比较

代码演示:

[java] view plaincopy
  1. package cn.itcast2;  
  2.   
  3. import cn.itcast.Test3;  
  4.   
  5. /* 
  6.  * 数组排序:将数组的元素按照某种规则从小到大或者从大到小排列 
  7.  * 冒泡排序: 
  8.  *      使用相邻的两个元素依次比较 
  9.  */  
  10. public class Demo {  
  11.   
  12.     public static void main(String[] args) {  
  13.           
  14.         //冒泡排序:  
  15.         int[] arr = new int[]{12,3,5,87,9};  
  16.         //排序动作  
  17.         for(int i=0; i<arr.length-1; i++){  
  18.             for(int j=0; j<arr.length-1-i; j++) {  
  19.                   
  20.                 if(arr[j]>arr[j+1]) {  
  21.                     int temp = arr[j];  
  22.                     arr[j] = arr[j+1];  
  23.                     arr[j+1] = temp;  
  24.                 }  
  25.             }  
  26.         }  
  27.         //遍历数组  
  28.         Test3.method(arr);  
  29.     }  
  30. }  

选择排序使用一个元素,一次与后边的元素进行比较

代码演示:

[java] view plaincopy
  1. package cn.itcast2;  
  2.   
  3. public class Demo2 {  
  4.   
  5.     public static void main(String[] args) {  
  6.         int[] arr = new int[]{12,3,5,87,9};  
  7.           
  8.         for(int i=0;i<arr.length-1;i++) {  
  9.             for(int j=i+1; j<arr.length ; j++) {  
  10.                 if(arr[i]>arr[j]) {  
  11.                     int temp = arr[i];  
  12.                     arr[i]= arr[j];  
  13.                     arr[j]= temp;  
  14.                 }  
  15.             }  
  16.         }  
  17.           
  18.         for (int i = 0; i < arr.length; i++) {  
  19.             System.out.println(arr[i]);  
  20.         }  
  21.     }  
  22.   
  23. }  

二分法查找:依次将所查找数据与中心数据对比,根据大小调整数据边界

前提:数组必须排序

代码演示:

[java] view plaincopy
  1. package cn.itcast2;  
  2.   
  3. public class Demo3 {  
  4.   
  5.     public static void main(String[] args) {  
  6.         int[] arr = new int[]{3,5,9,12,87,100,156};  
  7.         int number = 90;  
  8.           
  9.         int index = method(arr,number);  
  10.         System.out.println(index);  
  11.     }  
  12.     public static int method(int[] arr,int number) {  
  13.         //定义索引  
  14.         //定义开始索引  
  15.         int start = 0;  
  16.         //定义结束索引  
  17.         int end = arr.length-1;  
  18.         //定义中间的索引  
  19.         int mid = (start+end)/2;  
  20.         //只要mid不等于number,就继续判断  
  21.         while(arr[mid]!=number) {  
  22.             if(number<arr[mid]) {  
  23.                 //如果要查找的数,比中间的数小,就将最后的索引变为中间的索引-1,后边的素有元素都不再判断了  
  24.                 end = mid-1;  
  25.             }else {  
  26.                 //如果要查找的数,比中间的数大,就将开始的索引变为中间的索引+1,前边的素有元素都不再判断了  
  27.                 start = mid+1;  
  28.             }  
  29.             //如果出现开始的索引大于最后的索引,则说明数组中没有这个元素,直接返回-1  
  30.             if(start>end) {  
  31.                 return -1;  
  32.             }  
  33.             //如果arr[mid]==number,则说明在数组中找到了这个数,直接返回mid即可  
  34.             mid = (start+end)/2;  
  35.         }  
  36.         return mid;  
  37.     }  
  38.   
  39. }  
Arrays:数组工具类(我们使用工具类也可以达到相同的结果)

Arrays.sort();使数组排序

包装类

基本数据类型包装类:对应每一种基本数据类型

以Integer为例,调用基本类型包装类对象的方法

代码演示:

[java] view plaincopy
  1. package cn.itcast2;  
  2.   
  3. public class Demo5 {  
  4.   
  5.     public static void main(String[] args) {  
  6.   
  7.         int i = 100;  
  8.         i = 0x64;  
  9.           
  10.         System.out.println(i);  
  11.         String hexString = Integer.toHexString(100);  
  12.         System.out.println(hexString);  
  13.     }  
  14.   
  15. }  
Integer:

构造方法:

public Integer(int value)

public Integer(String s)throws NumberFormatException

public static int parseInt(String s)throws NumberFormatException  将字符串转成int

public static Integer valueOf(int i)    将int转成字符串

public int intValue()  将Integer对象转成int值

代码演示:

[java] view plaincopy
  1. package cn.itcast2;  
  2.   
  3. public class Demo6 {  
  4.   
  5.     public static void main(String[] args) {  
  6.   
  7.         Integer integer = new Integer(1000);  
  8.         Integer integer2 = new Integer("1000");  
  9.           
  10.         System.out.println(integer == integer2);  
  11.         System.out.println(integer.equals(integer2));  
  12.           
  13.         System.out.println(integer);  
  14.           
  15.         int parseInt = Integer.parseInt("10204");  
  16.         System.out.println(parseInt);  
  17.           
  18.         System.out.println(100+"");  
  19.     }  
  20.   
  21. }  
基本类型包装类:自动装箱拆箱

  以Integer为例

装箱:使用引用数据类型的时候,可以给基本类型.  即将基本数据类型提升成基本数据类型包装类对象

拆箱:使用基本数据类型时候,可以直接使用基本数据类型包装类对象.即将基本数据类型包装类对象向下转为基本数据类型

代码体现:

[java] view plaincopy
  1. package cn.itcast2;  
  2.   
  3. public class Demo {  
  4.   
  5.     public static void main(String[] args) {  
  6.   
  7.         Integer integer = new Integer(100);  
  8.           
  9.         int i = 100;  
  10.         System.out.println(100-20);  
  11.         System.out.println(integer-20);  
  12.           
  13.         integer = 108;  
  14.         System.out.println(integer);  
  15.           
  16. //      引用类型的对象不能使用运算符运算  
  17. //      String s = "100";  
  18. //      System.out.println(s-20);  
  19.           
  20. //      Object o = new Object();  
  21. //      System.out.println(o+100);  
  22.           
  23.         //自动装箱:将int类型的1提升成Integer对象  
  24.         Integer x = 1;  
  25.         //自动拆箱:将Integer对象向下转成int值1  
  26.         //自动装箱:将int类型的2提升成Integer对象  
  27.         x = x + 1;  
  28.           
  29.         Integer integer2 = null;  
  30.         //滤空判断  
  31.         //System.out.println(integer2+100);  
  32.           
  33.     }  
  34.   
  35. }  

练习:给定一个字符串找到子串在字符串中出现的次数

代码体现:

[java] view plaincopy
  1. package cn.itcast;  
  2. /* 
  3.  * 给定一个字符串找到子串在字符串中出现的次数 
  4.  * String s = "abcitcastabcxxxabc"中的"abc" 
  5.  *            "itcastabcxxxabc" 
  6.  *            "xxxabc" 
  7.  *            ""   -1 结束 
  8.  *      1,先获取子串在整串中第一次出现的位置,如果是-1,说明不存  
  9.  *        在子串.indexOf(String sub) 
  10. //        如果不是-1,记录住该位置.说明存在,这时定义一个计数   
  11. //        器,并自增. 
  12. //      2,接下来,将整串中被查找的去掉,获取剩下没有被查找 
  13. //         剩余字符串,在进行指定子串查找.查到后计数器继续自增. 
  14. //      3,不断循环,当最后没有找到指定子串,结束功能,返回计数器. 
  15.  */  
  16. public class Test {  
  17.   
  18.     public static void main(String[] args) {  
  19.   
  20.         String s = "abcitcastabcxxxabc";  
  21.         String subS = "abc";  
  22.           
  23.         System.out.println(method(s, subS));  
  24.     }  
  25.       
  26.     public static int method(String s,String subS) {  
  27.         //s:从哪个字符串中去找子串  
  28.         //subS:子串  
  29.           
  30.         //获取小串在大串中出现的索引  
  31.         int index = s.indexOf(subS);  
  32.           
  33.         //定义计时器  
  34.         int count = 0;  
  35.         //判断:如果index==-1则表示该字符串中没有子串  
  36.         //如果index!=-1则表示字符串中有子串,记录一次  
  37.         while(index!=-1) {  
  38.             //计数器计数一次  
  39.             count++;  
  40.             //将大串中上一次出现的子串截取  
  41.             s = s.substring(index+subS.length());  
  42.             //重新获取新串中子串的索引  
  43.             index = s.indexOf(subS);  
  44.         }  
  45.           
  46.         //返回计数器次数  
  47.         return count;  
  48.     }  
  49.   
  50. }  
  51. ----------- android培训java培训、java学习型技术博客、期待与您交流! ------------
展开阅读全文
博主设置当前文章不允许评论。

没有更多推荐了,返回首页