java常用API知识点总结

黑马程序员_JAVA常用类API(StringBuffer类,数组高级应用,包装类 34人阅读评论(0) 收藏举报------- android培训、java培训、期待与您交流！----------StringBuffer:概念:字符串缓冲区,缓冲区用于存储数据,所以也称之为容器.字符串的组成原理就是通过该类实现的.StringBuffer(掌握)(1)用字符串做拼

zhuimengtianya33

4173人浏览 · 2015-08-22 19:47:49

zhuimengtianya33 · 2015-08-22 19:47:49 发布

黑马程序员_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 
    
 package cn.itcast;  
   
 public class Demo2 {  
   
     public static void main(String[] args) {  
   
         StringBuffer sb = new StringBuffer();  
           
         sb.append("i");  
         sb.append("love");  
         sb.append("java");  
         sb.append("!");  
         sb.append("abcdefg");  
           
         System.out.println(sb.toString());  
         System.out.println(sb.capacity());  
         System.out.println(sb.length());  
           
         StringBuffer sb2 = new StringBuffer("i love code!");  
           
         System.out.println(sb2.capacity());  
     }  
   
 }  

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 
    
 package cn.itcast;  
   
 public class Demo3 {  
   
     public static void main(String[] args) {  
   
         StringBuffer sb = new StringBuffer();  
         sb.append("i love java");  
         sb.append(true);  
         sb.append(new Demo());  
         sb.append(100);  
         // System.out.println(sb);  
   
         StringBuffer sb2 = new StringBuffer();  
   
         //由于StringBuffer可以返回对象本身，所以可以使用链式调用  
         sb2.append(true)  
             .append(100)  
             .append("i love java")  
             .append(new Demo())  
             .append("aabcd")  
             .insert(2, "$$$")  
             .append("abc");  
   
         System.out.println(sb2);  
           
         sb2.delete(0, 3).deleteCharAt(0).reverse();  
         System.out.println(sb2);  
         sb2.replace(0, 10, "oy");  
         System.out.println(sb2);  
           
         String s = sb2.toString();  
         System.out.println(s);  
     }  
   
 }  

数组高级

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

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

代码演示:

[java]view plaincopy 
    
 package cn.itcast2;  
   
 import cn.itcast.Test3;  
   
 /* 
  * 数组排序：将数组的元素按照某种规则从小到大或者从大到小排列 
  * 冒泡排序： 
  *      使用相邻的两个元素依次比较 
  */  
 public class Demo {  
   
     public static void main(String[] args) {  
           
         //冒泡排序：  
         int[] arr = new int[]{12,3,5,87,9};  
         //排序动作  
         for(int i=0; i<arr.length-1; i++){  
             for(int j=0; j<arr.length-1-i; j++) {  
                   
                 if(arr[j]>arr[j+1]) {  
                     int temp = arr[j];  
                     arr[j] = arr[j+1];  
                     arr[j+1] = temp;  
                 }  
             }  
         }  
         //遍历数组  
         Test3.method(arr);  
     }  
 }  

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

代码演示:

[java]view plaincopy 
    
 package cn.itcast2;  
   
 public class Demo2 {  
   
     public static void main(String[] args) {  
         int[] arr = new int[]{12,3,5,87,9};  
           
         for(int i=0;i<arr.length-1;i++) {  
             for(int j=i+1; j<arr.length ; j++) {  
                 if(arr[i]>arr[j]) {  
                     int temp = arr[i];  
                     arr[i]= arr[j];  
                     arr[j]= temp;  
                 }  
             }  
         }  
           
         for (int i = 0; i < arr.length; i++) {  
             System.out.println(arr[i]);  
         }  
     }  
   
 }  

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

前提：数组必须排序

代码演示:

[java]view plaincopy 
    
 package cn.itcast2;  
   
 public class Demo3 {  
   
     public static void main(String[] args) {  
         int[] arr = new int[]{3,5,9,12,87,100,156};  
         int number = 90;  
           
         int index = method(arr,number);  
         System.out.println(index);  
     }  
     public static int method(int[] arr,int number) {  
         //定义索引  
         //定义开始索引  
         int start = 0;  
         //定义结束索引  
         int end = arr.length-1;  
         //定义中间的索引  
         int mid = (start+end)/2;  
         //只要mid不等于number,就继续判断  
         while(arr[mid]!=number) {  
             if(number<arr[mid]) {  
                 //如果要查找的数,比中间的数小,就将最后的索引变为中间的索引-1,后边的素有元素都不再判断了  
                 end = mid-1;  
             }else {  
                 //如果要查找的数,比中间的数大,就将开始的索引变为中间的索引+1,前边的素有元素都不再判断了  
                 start = mid+1;  
             }  
             //如果出现开始的索引大于最后的索引,则说明数组中没有这个元素,直接返回-1  
             if(start>end) {  
                 return -1;  
             }  
             //如果arr[mid]==number,则说明在数组中找到了这个数,直接返回mid即可  
             mid = (start+end)/2;  
         }  
         return mid;  
     }  
   
 }  

Arrays ：数组工具类(我们使用工具类也可以达到相同的结果)

Arrays.sort();使数组排序

包装类

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

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

代码演示:

[java]view plaincopy 
    
 package cn.itcast2;  
   
 public class Demo5 {  
   
     public static void main(String[] args) {  
   
         int i = 100;  
         i = 0x64;  
           
         System.out.println(i);  
         String hexString = Integer.toHexString(100);  
         System.out.println(hexString);  
     }  
   
 }  

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 
    
 package cn.itcast2;  
   
 public class Demo6 {  
   
     public static void main(String[] args) {  
   
         Integer integer = new Integer(1000);  
         Integer integer2 = new Integer("1000");  
           
         System.out.println(integer == integer2);  
         System.out.println(integer.equals(integer2));  
           
         System.out.println(integer);  
           
         int parseInt = Integer.parseInt("10204");  
         System.out.println(parseInt);  
           
         System.out.println(100+"");  
     }  
   
 }  

基本类型包装类：自动装箱拆箱

以Integer为例

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

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

代码体现:

[java]view plaincopy 
    
 package cn.itcast2;  
   
 public class Demo {  
   
     public static void main(String[] args) {  
   
         Integer integer = new Integer(100);  
           
         int i = 100;  
         System.out.println(100-20);  
         System.out.println(integer-20);  
           
         integer = 108;  
         System.out.println(integer);  
           
 //      引用类型的对象不能使用运算符运算  
 //      String s = "100";  
 //      System.out.println(s-20);  
           
 //      Object o = new Object();  
 //      System.out.println(o+100);  
           
         //自动装箱：将int类型的1提升成Integer对象  
         Integer x = 1;  
         //自动拆箱：将Integer对象向下转成int值1  
         //自动装箱：将int类型的2提升成Integer对象  
         x = x + 1;  
           
         Integer integer2 = null;  
         //滤空判断  
         //System.out.println(integer2+100);  
           
     }  
   
 }  

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

代码体现:

[java]view plaincopy 
    
 package cn.itcast;  
 /* 
  * 给定一个字符串找到子串在字符串中出现的次数 
  * String s = "abcitcastabcxxxabc"中的"abc" 
  *            "itcastabcxxxabc" 
  *            "xxxabc" 
  *            ""   -1 结束 
  *      1，先获取子串在整串中第一次出现的位置,如果是-1,说明不存  
  *        在子串.indexOf(String sub) 
 //        如果不是-1,记录住该位置.说明存在,这时定义一个计数   
 //        器,并自增. 
 //      2,接下来,将整串中被查找的去掉,获取剩下没有被查找 
 //         剩余字符串,在进行指定子串查找.查到后计数器继续自增. 
 //      3,不断循环,当最后没有找到指定子串,结束功能,返回计数器. 
  */  
 public class Test {  
   
     public static void main(String[] args) {  
   
         String s = "abcitcastabcxxxabc";  
         String subS = "abc";  
           
         System.out.println(method(s, subS));  
     }  
       
     public static int method(String s,String subS) {  
         //s：从哪个字符串中去找子串  
         //subS：子串  
           
         //获取小串在大串中出现的索引  
         int index = s.indexOf(subS);  
           
         //定义计时器  
         int count = 0;  
         //判断：如果index==-1则表示该字符串中没有子串  
         //如果index！=-1则表示字符串中有子串，记录一次  
         while(index!=-1) {  
             //计数器计数一次  
             count++;  
             //将大串中上一次出现的子串截取  
             s = s.substring(index+subS.length());  
             //重新获取新串中子串的索引  
             index = s.indexOf(subS);  
         }  
           
         //返回计数器次数  
         return count;  
     }  
   
 }  
 ----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
 

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...