StringBuffer StringBuilder 数组常见操作 Arrays 基本数据类型包装类

「爱情、让人受尽委屈。」 2021-12-08 22:07 247阅读 0赞

## StringBuffer StringBuilder 数组常见操作 Arrays 基本数据类型包装类 ##

# （一）StringBuffer #

## 1.常见对象(StringBuffer类的概述 ##

A:StringBuffer类概述  
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。  
而StringBuffer就可以解决这个问题

## 2常见对象(StringBuffer类的构造方法) ##

A:StringBuffer的构造方法：  
public StringBuffer(): 无参构造方法

public StringBuffer(int capacity):	指定容量的字符串缓冲区对象
    	public StringBuffer(String str):		指定字符串内容的字符串缓冲区对象
    B:StringBuffer的方法：
    	public int capacity()：返回当前容量。	理论值
    	public int length():返回长度（字符数）。 实际值

构造方法和长度方法的使用

public class MyTest {
        public static void main(String[] args) {
            //String 类
            //String str="a"+"b"+"c";
           // String str="abc";
    
       // StringBuffer :他就是存储字符的容器，长度可变
        //可变字符序列
        //StringBuffer()
        //构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
        //超过了默认容量，可以自动扩充
        StringBuffer sb = new StringBuffer();
        int capacity = sb.capacity(); //获取缓冲区的容量
        System.out.println(capacity);
        int length = sb.length(); //获取长度 实际你往容器中存了多少个字符
        System.out.println(length);
        //Object 类
        //toString();
        StringBuffer sb2 = sb.append("abc"); //往容器中追加内容
        System.out.println(sb2.toString());//
    
    }
    
    }

## 3常见对象(StringBuffer的添加功能) ##

A:StringBuffer的添加功能  
public StringBuffer append(String str): 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身  
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身  
B:案例演示  
StringBuffer的添加功能

public class MyTest2 {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer();
            //StringBuffer sb2 = sb.append("abc");
    
        //String s = sb.toString();
       // String s1 = sb2.toString();
        // sb.toString()==sb2.toString()  s==s1
      //  sb == sb2
        //System.out.println(sb.toString() == sb2.toString());
    
       // System.out.println(sb==sb2); //true
        //append(100) 往容器中追加内容，返回的还是原来的那个容器
        sb.append(100).append(1000).append("abc");
        String s = sb.toString();
        System.out.println(s);
    }
    
    }

## 4常见对象(StringBuffer的删除功能) ##

A:StringBuffer的删除功能  
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身  
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身  
B:案例演示  
StringBuffer的删除功能

public class MyTest2 {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer();
            sb.append("红尘来呀来去呀去都是一场梦");
            sb.deleteCharAt(0);//根据索引删除单个字符
          //  sb.delete()
            int index = sb.indexOf("都");
           // sb.lastIndexOf()
            //根据起始索引，和终止索引删除一段内容
            sb.delete(index,sb.length());
            System.out.println(sb);
    
    }
    
    }

## 5常见对象(StringBuffer的替换和反转功能) ##

A:StringBuffer的替换功能  
public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换  
B:StringBuffer的反转功能  
public StringBuffer reverse(): 字符串反转  
C:案例演示  
StringBuffer的替换和反转功能

public class MyTest3 {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer();
            sb.append("红尘来呀来去呀去都是一场梦");
            //根据起始索引和终止索引替换容器中的一段内容，返回的还是容器本身
            StringBuffer replace = sb.replace(0, sb.lastIndexOf("去")+1, "abc");
            System.out.println(replace);
            System.out.println(sb);
            System.out.println(replace==sb);
    
       sb.reverse(); //反转容器中的数据，返回的还是原来的容器
        System.out.println(sb.toString());
    
    }
    
    }

## 6常见对象(StringBuffer的截取功能及注意事项) ##

## A:StringBuffer的截取功能 ##

public String substring(int start): 从指定位置截取到末尾  
 public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置  
B:注意事项  
 注意:返回值类型不再是StringBuffer本身  
C:案例演示  
 StringBuffer的截取功能及注意事项

## 7常见对象(StringBuffer和String的相互转换) ##

A:String – StringBuffer  
a:通过构造方法  
b:通过append()方法  
B:StringBuffer – String  
a: 使用substring方法  
b:通过构造方法  
c:通过toString()方法  
C:案例演示  
StringBuffer和String的相互转换

# (二)StringBuilder #

## 1常见对象(String和StringBuffer分别作为参数传递) ##

A:形式参数问题  
String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递  
StringBuffer作为参数传递

# （三）数组常见操作 #

## 1.常见对象(数组高级冒泡排序原理) ##

冒泡排序原理  
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

public class MyTest {
        public static void main(String[] args) {
             int[] arr={24, 69, 80, 57, 13,30,10,-1,0};
        //tuiDao(arr);
    
        for (int j = 0; j <arr.length-1; j++) {
            //第2轮比较3次
            for (int i = 0; i < arr.length - 1-j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
    
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    
    private static void tuiDao(int[] arr) {
        //第一轮比较4次
        for (int i = 0; i < arr.length-1; i++) {
            if(arr[i]>arr[i+1]){
                int t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
    
        }
    
        //第2轮比较3次
        for (int i = 0; i < arr.length - 1-1; i++) {
            if (arr[i] > arr[i + 1]) {
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
    
        }
    
        //第3轮比较2次
        for (int i = 0; i < arr.length - 1 - 1-1; i++) {
            if (arr[i] > arr[i + 1]) {
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
    
        }
    
        //第4轮比较1次
        for (int i = 0; i < arr.length - 1 - 1 - 1-1; i++) {
            if (arr[i] > arr[i + 1]) {
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
    
        }
    }
    
    }

## 2常见对象(数组高级选择排序原理图解) ##

1:选择排序原理  
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

public class MyTest2 {
        public static void main(String[] args) {
            //选择排序：每次拿一个元素跟后面的元素挨个比较，小的往前换，经过一轮比较，最小元素就会出现在最前面
            int[] arr = {24, 69, 80, 57, 13,30,30,30,100,300,-1,0};
           // tuiDao(arr);
            for (int index = 0; index < arr.length-1; index++) {
                for (int i = 1 + index; i < arr.length; i++) {
                    if (arr[index] > arr[i]) {
                        int t = arr[index];
                        arr[index] = arr[i];
                        arr[i] = t;
                    }
                }
            }
            System.out.println(Arrays.toString(arr));
    
    }
    
    private static void tuiDao(int[] arr) {
        //第一轮 从0索引处开始比 比4次
        int index = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
        }
    
        //第二轮
    
        index=1;
        for (int i = 1+index; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
        }
    
        index = 2;
        for (int i = 1 + index; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
        }
    
        index = 3;
        for (int i = 1 + index; i < arr.length; i++) {
            if (arr[index] > arr[i]) {
                int t = arr[index];
                arr[index] = arr[i];
                arr[i] = t;
            }
        }
    }
    
    }

# （四）Arrays #

## 1.常见对象(Arrays类的概述和方法使用) ##

A:Arrays类概述  
针对数组进行操作的工具类。  
提供了排序，查找等功能。  
B:成员方法  
public static String toString(int\[\] a)  
public static void sort(int\[\] a)  
public static int binarySearch(int\[\] a,int key)

# (五)常见对象(基本类型包装类的概述) #

## 1\_常见对象(基本类型包装类的概述) ##

A: 需求:  
a:将100转换成二进制 , 八进制 , 十六进制  
b:判断一个数是否在int的范围内  
B:为什么会有基本类型包装类  
为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.  
C:常用操作: 常用的操作之一：用于基本数据类型与字符串之间的转换。  
D:基本类型和包装类的对应  
byte Byte  
short Short  
int Integer  
long Long  
float Float  
double Double  
char Character  
boolean Boolean

## 2.常见对象(Integer类的概述和构造方法) ##

A:Integer类概述  
通过JDK提供的API，查看Integer类的说明

Integer 类在对象中包装了一个基本类型 int 的值,  
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，  
还提供了处理 int 类型时非常有用的其他一些常量和方法

B:构造方法  
public Integer(int value)  
public Integer(String s)  
C:案例演示  
使用构造方法创建对象

public class MyTest2 {
        public static void main(String[] args) {
            //Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
            //
            //此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。
        //    B:
        //    构造方法
    	//public Integer( int value)
    	//public Integer(String s)
            int num=100;
            Integer integer = new Integer(num);
            String s = integer.toString();
            System.out.println(s);//"100";
    
        Integer integer1 = new Integer("110000"); //要的是字面上来看是一个数字的字符串
        //NumberFormatException: 数字格式化异常
    
        System.out.println(integer1);
    
    }
    
    }

## 3常见对象(String和int类型的相互转换) ##

A:int – String  
a:和""进行拼接  
b:public static String valueOf(int i)  
c:int – Integer – String  
d:public static String toString(int i)  
B:String – int  
a:String – Integer – intValue();  
b:public static int parseInt(String s)  
C:案例演示  
String和int类型的相互转换

public class MyTest3 {
        public static void main(String[] args) {
            //A:
            //int --String
            int num=100;   //"100"
            //方式1：
            String str=num+"";
            //方式2
            String s = String.valueOf(num);
            //方式3
            String s1 = new Integer(num).toString();
    
       //"100"------100  String-----int
        String strNum="100"; //-----100
    
        Integer integer = new Integer(strNum);
        int i = integer.intValue();
        System.out.println(i);
    
        //方式2
        int num2 = Integer.parseInt(strNum);
        System.out.println(num2);
    }
    
    }

## 4.常见对象(JDK5的新特性自动装箱和拆箱) ##

A:JDK5的新特性  
自动装箱：把基本类型转换为包装类类型  
自动拆箱：把包装类类型转换为基本类型  
B:案例演示  
JDK5的新特性自动装箱和拆箱

Integer ii = 100;
    ii += 200;

C:注意事项  
在使用时，Integer x = null;代码就会出现NullPointerException。  
建议先判断是否为null，然后再使用。

public class MyTest {
        public static void main(String[] args) {
    
        //JDK1.5
        //自动装箱：将一个基本类型，直接包装成他的包装类型
        //自动拆箱：将一个包装类型，转化成他所对应的基本类型
        int a=100;
        Integer integer = new Integer(a);
        Integer num = a; //自动装箱
    
        Integer integer1 = new Integer(10);
    
        Integer integer2 = new Integer(20);
         int r= integer1 + integer2;
       // 将一个包装类型，转化成他所对应的基本类型
        System.out.println(r);
    
       //都有哪些操作
    
        Integer ii = 100; //自动装箱
    
        ii += 200; //自动拆箱 自动装箱
    
        System.out.println(ii);
    
        //手动拆装箱
    
        Integer integer3 = new Integer(10);
    
        Integer integer4= new Integer(20);
    
        int num11 = integer3.intValue();//手动拆箱
    
        int num22 = integer4.intValue(); //手动拆箱
    
        int rr=num11+num22;
    
        Integer integer5 = Integer.valueOf(rr); //手动装箱
    
    }
    
    }