14 StringBuffer类与Arrays类冒泡选择排序Integer

最新推荐文章于 2021-07-03 10:42:11 发布

guoyoubuji

最新推荐文章于 2021-07-03 10:42:11 发布

阅读量668

点赞数

分类专栏： java系统学习

本文链接：https://blog.csdn.net/guoyoubuji/article/details/53184655

版权

java系统学习专栏收录该内容

23 篇文章 0 订阅

订阅专栏

01_常见对象(StringBuffer类的概述)

A:StringBuffer类概述
- 通过JDK提供的API，查看StringBuffer类的说明
- 线程安全的可变字符序列
B:StringBuffer和String的区别
- String是一个不可变的字符序列
- StringBuffer是一个可变的字符序列 (增删改)

02_常见对象(StringBuffer类的构造方法)

A:StringBuffer的构造方法：
- public StringBuffer():无参构造方法
- public StringBuffer(int capacity):指定容量的字符串缓冲区对象
- public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
B:StringBuffer的方法：
- public int capacity()：返回当前容量。理论值(不掌握)
- public int length():返回长度（字符数）。实际值
C:案例演示
- 构造方法和长度方法的使用

03_常见对象(StringBuffer的添加功能)

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

**StringBuffer是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组
        当调用添加的方法时,不会再重新创建对象,在不断向原缓冲区添加字符**所以下面的代码返回结果是一样的
     */
    public static void main(String[] args) {

        StringBuffer sb = new StringBuffer();
        StringBuffer sb2 = sb.append(false);
        StringBuffer sb3 = sb.append("dddddddd");
        StringBuffer sb4 = sb.append(100);
//引用不一样，但地址一样，除非每次添加后马上输出

        System.out.println(sb.toString());          //StringBuffer类中重写了toString方法,显示的是对象中的属性值
        System.out.println(sb2.toString());
        System.out.println(sb3.toString());
        System.out.println(sb4.toString());

    }

04_常见对象(StringBuffer的删除功能)

A:StringBuffer的删除功能
- public StringBuffer deleteCharAt(int index):
  - 删除指定位置的字符，并返回本身
- public StringBuffer delete(int start,int end):
  - 删除从指定位置开始指定位置结束的内容，并返回本身
  - 包含头不包含尾

05_常见对象(StringBuffer的替换和反转功能)

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

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

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

07_常见对象(StringBuffer和String的相互转换)

A:String – StringBuffer
- a:通过构造方法
- b:通过append()方法
B:StringBuffer – String
- a:通过构造方法
- b:通过toString()方法
- c:通过subString(0,length);

08_常见对象(把数组转成字符串)

A:案例演示

需求：把数组中的数据按照指定个格式拼接成一个字符串

举例：
    int[] arr = {1,2,3};    
输出结果：
    "[1, 2, 3]"

用StringBuffer的功能实现

09_常见对象(字符串反转)

A:案例演示

需求：把字符串反转
    举例：键盘录入"abc"        
    输出结果："cba"

用StringBuffer的功能实现

10_常见对象(StringBuffer和StringBuilder的区别)

A:StringBuilder的概述
- 通过查看API了解一下StringBuilder类
B:面试题
- String,StringBuffer,StringBuilder的区别
- StringBuffer和StringBuilder的区别
- StringBuffer是jdk1.0版本的,是线程安全的,效率低
- StringBuilder是jdk1.5版本的,是线程不安全的,效率高
- String和StringBuffer,StringBuilder的区别
- String是一个不可变的字符序列
- StringBuffer,StringBuilder是可变的字符序列

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

A:形式参数问题
- String作为参数传递
- StringBuffer作为参数传递
B:案例演示
- String和StringBuffer分别作为参数传递问题

    public static void main(String[] args) {
        String a="hengge";
        change(a);
        System.out.println(a);   //"hengge";

    }

    public static void change(String b) {
        System.out.println(b);     //"hengge";
        b+="dddddd";
        System.out.println(b);     //dddddd

    }//完成任务之后就被弹栈
    String 虽然是引用数据类型，但参数传递还是和基本数据类型是一样的
}

StringBuffer

public class Test2 {
public static void main(String[] args) {
        StringBuffer a = new StringBuffer("hengge");
        change(a);
        System.out.println(a); // "hengge";

    }

    public static void change(StringBuffer b) {
        b.append("dddddd"); // "henggeddddddd";

    }

}

12_常见对象(数组高级冒泡排序原理图解)

A:画图演示

需求：
    数组元素：{24, 69, 80, 57, 13}
    请对数组元素进行排序。

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

这里写图片描述

13_常见对象(数组高级冒泡排序代码实现)

A:案例演示
- 数组高级冒泡排序代码

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

A:画图演示
- 需求：
  - 数组元素：{24, 69, 80, 57, 13}
  - 请对数组元素进行排序。
  - 选择排序
    - 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

这里写图片描述

15_常见对象(数组高级选择排序代码实现)

A:案例演示
- 数组高级选择排序代码
  *
  自己用esplise做的，冒泡和选择比较次数都是21次
  即n-1+n-2+n-3+n-n
  奇数个的是((n-1)/2)*n次
  偶数个的是(n/2)*n-n/2次

public class TestMao {

    public static void main(String[] args) {
        int[] arr={2,4,1,66,77,8,3};
        //mapPao(arr);
        select(arr);
        System.out.println(Arrays.toString(arr));

    }
    private static void select(int[] arr){
    int b=0;

    for (int i = 0; i < arr.length; i++) {
        for (int j =i+1; j < arr.length; j++) {
            b++;
            System.out.println(Arrays.toString(arr)+j+"   "+i);
            if(arr[i]<arr[j]){
                int a=arr[j];
                arr[j]=arr[i];
                arr[i]=a;

            }
            System.out.println(b);
        }
    }
    }
    private static void mapPao(int[] arr) {
        int b=0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {

                b++;
                if(arr[j]>arr[j+1]){
                    int a=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=a;

            }

            System.out.println(b);
        }
    }



    }}

16_常见对象(数组高级二分查找原理图解)

A:画图演示
- 二分查找
- 前提：数组元素有序
- 一半一半的查找，min mid max三个值来判断低价高价，如果低价了，min就是mid+1，如果高价了，max就是mid-1

17_常见对象(数组高级二分查找代码实现及注意事项)

A:案例演示
- 数组高级二分查找代码
- *
B:注意事项
- 如果数组无序，就不能使用二分查找。
  - 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

public class Demo2_Array {

    /**
     * * A:案例演示
            * 数组高级二分查找代码
        * B:注意事项
            * 如果数组无序，就不能使用二分查找。
                * 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77};
        System.out.println(getIndex(arr, 22));
        System.out.println(getIndex(arr, 66));
        System.out.println(getIndex(arr, 88));
    }

    /*
     * 二分查找
     * 1,返回值类型,int
     * 2,参数列表int[] arr,int value
     */

    public static int getIndex(int[] arr, int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;

        while(arr[mid] != value) {                  //当中间值不等于要找的值,就开始循环查找
            if(arr[mid] < value) {                  //当中间值小于了要找的值
                min = mid + 1;                      //最小的索引改变
            }else if (arr[mid] > value){            //当中间值大于了要找的值
                max = mid - 1;                      //最大的索引改变
            }

            mid = (min + max) / 2;                  //无论最大还是最小改变,中间索引都会随之改变

            if(min > max) {                         //如果最小索引大于了最大索引,就没有查找的可能性了
                return -1;                          //返回-1
            }
        }
        return mid;
    }
}

18_常见对象(Arrays类的概述和方法使用)

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

public class Demo3_Arrays {

    /**
        * public static String toString(int[] a)
        * public static void sort(int[] a)
        * public static int binarySearch(int[] a,int key)
        * 
        *  public static String toString(int[] a) {
                if (a == null)                              //如果传入的数组是null
                    return "null";                          //返回null
                int iMax = a.length - 1;                    //iMax最大索引
                if (iMax == -1)                             //如果数组中没有元素
                    return "[]";                            //返回[]

                StringBuilder b = new StringBuilder();      //线程不安全,效率高
                b.append('[');                              //将[添加到字符串缓冲区中
                for (int i = 0; ; i++) {                    //遍历数组,判断语句没有写默认是true
                    b.append(a[i]);                         //把第一个元素添加进字符串缓冲区
                    if (i == iMax)                          //如果索引等于了最大索引值
                        return b.append(']').toString();    //将]添加到字符串缓冲区,在转换成字符串并返回
                    b.append(", ");                         //如果不等于最大索引就将, 添加到缓冲区
                }
            }

         private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
                int low = fromIndex;                //最小索引0
                int high = toIndex - 1;             //最大索引数组长度-1

                while (low <= high) {               //最小索引小于等于最大索引可以循环判断
                    int mid = (low + high) >>> 1;   //求出中间索引值,(最小+最大)/2
                    int midVal = a[mid];            //通过中间索引获取中间值

                    if (midVal < key)               //中间索引对应的值小于查找的值
                        low = mid + 1;              //最小索引变化
                    else if (midVal > key)          //中间索引对应的值大于查找的值
                        high = mid - 1;             //最大索引变化
                    else
                        return mid; // key found    //找到了
                }
                return -(low + 1);  // key not found.//-插入点 - 1
            }
     */
    public static void main(String[] args) {
        int[] arr = {33,22,11,44,66,55};
        System.out.println(Arrays.toString(arr));           //数组转字符串

        Arrays.sort(arr);                                   //排序
        System.out.println(Arrays.toString(arr));

        int[] arr2 = {11,22,33,44,55,66};
        System.out.println(Arrays.binarySearch(arr2, 22));
        System.out.println(Arrays.binarySearch(arr2, 66));
        System.out.println(Arrays.binarySearch(arr2, 9));   //-插入点-1
    }

}
中间是binarySearch和toString的原码

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

A:为什么会有基本类型包装类
- 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
B:常用操作
- 常用的操作之一：用于基本数据类型与字符串之间的转换。
C:基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

20_常见对象(Integer类的概述和构造方法)

A:Integer类概述
- 通过JDK提供的API，查看Integer类的说明
- Integer 类在对象中包装了一个基本类型 int 的值,
- 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
- 还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
- public Integer(int value)
- public Integer(String s)
C:案例演示
- 使用构造方法创建对象

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

A:int – String
- a:和”“进行拼接
- b:public static String valueOf(int i)
- c:int – Integer – String(Integer类的toString方法())
- d:public static String toString(int i)(Integer类的静态方法)
B:String – int
- a:String – Integer – int
- public static int parseInt(String s)

22_常见对象(JDK5的新特性自动装箱和拆箱)

A:JDK5的新特性
- 自动装箱：把基本类型转换为包装类类型
- 自动拆箱：把包装类类型转换为基本类型
B:案例演示
- JDK5的新特性自动装箱和拆箱
  Integer i2 = 100; //自动装箱,把基本数据类型转换成对象
  int z = i2 + 200; //自动拆箱：把包装类类型转换为基本类型
C:注意事项
- 在使用时，Integer x = null;代码就会出现NullPointerException。
- 建议先判断是否为null，然后再使用。

23_常见对象(Integer的面试题)

A:Integer的面试题

看程序写结果

Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
System.out.println("-----------");

Integer i3 = new Integer(197);
Integer i4 = new Integer(197);
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));
System.out.println("-----------");

Integer i5 = 97;
Integer i6 = 97;
System.out.println(i5 == i6);
System.out.println(i5.equals(i6));
System.out.println("-----------");

Integer i7 = 197;
Integer i8 = 197;
System.out.println(i7 == i8);
System.out.println(i7.equals(i8));

public static void main(String[] args) {
        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2);               //**false**
        System.out.println(i1.equals(i2));          //**true**
        System.out.println("-----------");

        Integer i3 = new Integer(197);
        Integer i4 = new Integer(197);
        System.out.println(i3 == i4);               //**false**
        System.out.println(i3.equals(i4));          //**true**
        System.out.println("-----------");

        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);               //**true**
        System.out.println(i5.equals(i6));          //**true**
        System.out.println("-----------");

        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);
        System.out.println(i7.equals(i8));          //**true**

        /*
         * **-128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取**
         * 如果超过了byte取值范围就会再新创建对象
         * 原码：-128到127之间的数作为了一个数组，超过了就新创建对象
         * public static Integer valueOf(int i) {
                assert IntegerCache.high >= 127;
                if (i >= IntegerCache.low && i <= IntegerCache.high)            //i>= -128 && i <= 127
                    return IntegerCache.cache[i + (-IntegerCache.low)];
                return new Integer(i);
            }

guoyoubuji

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
14 StringBuffer类与Arrays类*冒泡选择排序*Integer

01_常见对象(StringBuffer类的概述)A:StringBuffer类概述通过JDK提供的API，查看StringBuffer类的说明线程安全的可变字符序列 B:StringBuffer和String的区别 String是一个不可变的字符序列StringBuffer是一个可变的字符序列 (增删改)02_常见对象(StringBuffer类的构造方法)A:StringBuf
复制链接

扫一扫