基本数据类型包装类Integer、二分查找、冒泡排序、递归、Arrays

黄嘉炜Ethan

已于 2022-11-24 16:02:35 修改

阅读量195

点赞数

文章标签： java 数据结构开发语言

于 2022-11-09 16:00:03 首次发布

本文链接：https://blog.csdn.net/ethanhuangjiawei/article/details/127766049

版权

基本数据类型包装类：

好处：将基本数据类型封装成对象的好处是可以在对象中定义更多的功能方法操作该数据

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer:

public Integer(int value)	根据int值创建Integer对象（已过时）
public Integer(String s)	根据String创建Integer对象（已过时）
public static Integer valueOf(int value)	返回表示指定的int值的实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer对象String

注意：现在一般用 valueOf 获取对象

integer i =100;

对象 = 默认基本数据类型

jdk1.5的特性，自动装箱

装箱：把一个基本数据类型，变成对应的包装类

自动：java底层会帮我们自动调用valueOf方法

int i2 = i；

jdk1.5的特性，自动拆箱

拆箱：把一个包装类型，变成对应得到基本数据类型

Integer i = 100；自动装箱---java底层会帮我们自动调用valueOf方法，等式右边即Integer.valueOf(100) ，将int值转成Integer

i += 200；（ i = i + 200 ；等式右边的i自动拆箱，让Integer值转为int，再与100进行相加运算）

（i = 300；运算完之后又进行自动装箱，将int赋值给Integer i）

注意：当Integer i = null；

i += 100；

会报错，空指针异常

null可以赋值给引用数据类型Integer，但无法转成int

Integer i = null；

if（ i ！= null）{

i += 100；

sout （i）；-----------------这里打印的是引用地址？还是int？

}

以后在使用包装类型的时候，如果做操作，最好先判断是否为null

结论：只要是对象，在使用前就必须进行不为null的判断

Integer的成员方法：

static int parseInt(String s)

将字符串类型的整数转成int类型的整数

注意：只能是整数，否则报错

int → String

String → int

int i = 30;

方式一：

String s = i + " ";

方式二：

String s = String.valueOf( i );

String i = "12";

int s =Integer.parseInt( i );

数组的高级操作：（需要深入理解）理解还不够透彻

二分查找

冒泡排序

二者可以配合使用，都属于算法

二分查找：

前提：数组元素必须按大小排序

int[] ints = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
int s = 11;

int mm = mm(ints, s);
System.out.println(mm);

元素	1	2	3	4	5	6	7	8	9	10	11
索引	0	1	2	3	4	5	6	7	8	9	10
长度	ints.length = 11

private static int mm(int[] ints, int s) {
    int min = 0;
    int max = ints.length - 1;

主要是用mid中位数作为锚点去控制范围，直至标中

    while (min <= max) {--------------必须加上等号，否则当max=min=mid=s时，会输出-1
        int mid = (max + min) / 2;-------注意是加号不是减，且要放在while循环里，不然mid动不了
        if (ints[mid] > s) {
            max = mid - 1;  ------------由于除数取整，另外mid本身如果和s一致，就会走else，输出mid，所以mid本身是对比过了，直接mid-1
        } else if (ints[mid] < s) {
            min = mid + 1;
        } else {

            return mid;
        }
    }
    return -1;--------------不能返回0，因为有0索引
}

冒泡排序：

排序：将一组数据按固定的规则进行排序

冒泡排序：相邻的数据两两比较，小的放前面，大的放后面，（简单理解就是从小到大排序）

在创建方法时，可以考虑：

1.我现在要干什么？-----二分查找？冒泡排序

2.我干这件事情需要什么？-----数组、元素

3.我干完了，要不要把结果返回调用者？------把索引返回调用者

int[] w = {5,2,6,5};
int[] ints1 = mm2(w);
for (int i = 0; i < ints1.length; i++) {
    System.out.println(ints1[i]);
}

public static int[] mm2(int[] a) {

    /*for (int j = 1; j < a.length+1; j++) {//length = 4  控制次数
        for (int i = 0; i < a.length-j; i++) { //0-     控制索引
            if (a[i] > a[i + 1]) {
                int temp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = temp;
            }
        }
    }*/
    for (int j = 0; j < a.length-1; j++) {//length = 4  控制次数 0、1、2 三轮
        for (int i = 0; i < a.length-1-j; i++) {
            //   元素：  5  2  6  5
            //   索引：  0  1  2  3
            //   a.length = 4
            //   控制索引 因为有a[i+1]，若不-1，a[3+1] a的最大索引为3，没有4，则所以i最大值只能是小于4-1 = 3 ，
            // 又是小于，所以i最大只能取2， [2+1] = 3  a[3] = 5·否则空指针异常
            if (a[i] > a[i + 1]) {
                int temp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = temp;
            }
        }
    }
    return a;
}

分析冒泡排序：

元素	1	2	3	4	5	6	7	8	9	10
索引	0	1	2	3	4	5	6	7	8	9

已知：length = 10，

经过测试 j = 5 时开始排序混乱，j = 6 排序正常

（此处可以先了解看下面，有些内容简写）

1.解决全部比对问题

2.解决代码冗余问题

外循环

for (int j = 0; j < a.length-1; j++)

内循环

for (int i = 0; i < a.length-1-j; i++)

当 j = 5 时

for（j = 5 , j < length -4）j <10 -4， j<6 即j能取到的最大值为5

当 j = 6 时

虽然排序功能能实现，但未做到全部相邻的元素比对，即索引（0和1）（1和2）（2和3）

为什么j = 6 以上都会对呢？

因为1、2、3被比对的次数太多，单单索引（0，1）就被比对了8次，（1，2）7次，（2，3）6次，正确的几率很大

但因为未对所有元素进行比对，仍存在不准确的风险

for（i = 0 ； i < length - 1 - j ）

当 j = 6时

i < length - 1 - j = 10 - 1 - 6 = 3

即 i < 3 即 i的最大值只能取2

当 i = 2

a[ i ] > a[ i + 1 ] ?

a[ 2 ] > a[ 3 ] ?

但我们要比对完整

即比对到索引0 ，数组全部比对完

即 a[ 0 ] > a[ 0 + 1 ] ?

即 i = 0

for（i = 0 ； i < length - 1 - j = 10 - 1 - 9 = 0）

即for（i = 0 ； i < 0 ）

此时 j = 9 ，但请注意，此时内循环条件不达标，不会执行，此时出现了代码冗余

往前进一位，j = 8

即 for（i = 0 ； i < length - 1 - 8 = 10-9 = 1 ）

即 for（i = 0 ； i < 1 ）

此时内循环可以执行

即 a[ 0 ] > a[ 0 + 1 ]

所以当 j = 8 时，数组所有索引对比完成，且不产生多余代码

当j = 8为最大值时

for (int j = 8; j < a.length = 10 - 1 = 9 )

即 for （ j = 8 ; j < 9）

结论为：for (int j = 0; j < a.length-1; j++)为最优

递归：

含义：以编程角度来看，递归指的是方法定义中调用方法本身的现象

作用：大事化小，小事化了，将复杂问题化为与原问题相似的规模较小的问题

注意点：

递归出口：否则会出现内存溢出 StackOverflowError ：栈内存溢出

递归规则：与原问题相似的规模较小的问题（更靠近出口）

private static int sum(int i) {
    if (i == 1){
        return 1;
    }else{
        return i * sum(i-1);
    }
}

理解：

i = 5

sum（i）： 5 * sum（5 - 1）

sum（5 - 1）： 4*sum（4-1）

...

sum(2)：2*sum(2 - 1);

sum(1) : return 1;然后1再往上递归

阶乘：即5*4*3*2*1

出口：1

规则：n*（n-1）

Arrays：（只需记住是为数组服务的）

作用：快捷调用数组方法，例如：二分查找、冒泡排序、直接打印数组元素

public static String toString(int[ ] a)	返回指定数组的内容的字符串表现形式
public static void sort(int[ ] a )	按照数字顺序排列指定的数组
public static int binarySearch(int[ ] a , int key)	利用二分查找返回指定元素的索引