基本类型包装类和数组高级操作

• 基本类型包装类
• • 举例
  • 装箱、拆箱
• 数组高级操作
• • 二分查找
  • 冒泡排序
  • 递归
  • 快排
  • 排序总结
• Arrays

专注于为中小企业提供成都网站建设、成都做网站服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业泸州免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上千企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据，最常用的操作之一就是用于基本数据类型与字符串之间的转换。
几乎所有基本类型的包装类都是该类型关键字的首字母大写，除了以下特例：
int —>Integer
char —>Character

举例

以Integer为例子，包装类几乎都具有以下方法：

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象(过时)
public Integer(String s)	根据 String 值创建 Integer 对象(过时)
public static Integer valueOf​(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf​(String s)	返回一个保存指定值的 Integer 对象 String
static int parseInt(String s)	将字符串类型的整数变成int类型的整数
public static String valueOf(int i)	返回 int 参数的字符串表示形式。该方法是 String 类中的方法

除此之外，还需要对上述数组进行排序

import static java.lang.Integer.parseInt;

public class IntString {public static void main(String[] args) {String str = "91 27 46 38 50";
        //先将字符串分割
        String[] split = str.split(" ");
        int[] number = new int[split.length];
        //然后将分割后的字符串用parseInt转换为int类型
        for (int i = 0; i< number.length; i++) {number[i] = parseInt(split[i]);
        }
        //以下使用的是冒泡排序，最终得出的结果是降序排列，也可以做升序
        for (int i = 0; i< number.length; i++) {int temp = 0;
            for (int j = 0; j< number.length; j++) {if (number[i] >number[j]){temp = number[j];
                    number[j] = number[i];
                    number[i] = temp;
                }
            }
        }
        for (int i = 0; i< number.length; i++) {System.out.print(number[i] + " ");
        }
    }
}

其实上述操作中，不少都有现成的API可以使用，简化版本在之后会提到。

装箱、拆箱

装箱：把基本数据类型转换为对应的包装类类型；
拆箱：把包装类类型转换为对应的基本数据类型。
在使用包装类类型的时候，如果需要进行操作，最好先判断是否为 null。
推荐只要是对象，在使用前就必须进行不为 null 的判断。

public class Integer {public static void main(String[] args) {int age = 23;
        java.lang.Integer.valueOf(age);//装箱，将int包装为Integer
        age += 100;//拆箱，重新转换为int
    }
}

数组高级操作 二分查找

二分查找找得快以及能对半对半的查，前提是要经过排序，没有排序也就无法通过二分查找。
二分查找原理步骤为

1. 最初将排序好的数组的首尾的索引定义为min和max，并且中间定义为mid；
2. 如果要查找的元素大于mid位置的元素，那么min更改为mid+1，max不变，mid变为（min+max）/2，然后继续比较；
3. 如果要查找的元素小于mid位置的元素，那么max更改为mid-1，min不变，mid变为（min+max）/2，然后继续比较；
4. 重复23，直到查找到，返回索引，如果数组不存在这个元素，那么返回-1。

public class HalfSearch {public static void main(String[] args) {int[] numbers = {2, 3, 4, 5, 6, 34, 56, 78, 899};
        //要用二分查找，数组必须是排序好的
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要查找的数：");
        int search = scanner.nextInt();
        System.out.println(binarySearch(numbers, search));
    }
    public static int binarySearch(int[] array, int search){int min = 0;//默认初始是数组头部，索引为0
        int max = array.length;//默认初始是数组尾部，索引为array.length
        while (min<= max){int mid = (min + max)/2;
            int current = array[mid];//定义当前基准为mid位置的元素
            if (current< search){min = mid + 1;
            } else if(current >search){max = mid - 1;
            } else {return mid;
            }
        }
        return -1;
    }
}
//查找6，返回4，即元素6的索引为4。

二分查找相当于每次去掉一半的查找范围。

冒泡排序

相邻的数据两两比较，小的放前面，大的放后面。
如果有n个数据进行排序，总共需要比较n-1次；每一次比较完毕，下一次的比较就会少一个数据参与。

public class PopSearch {public static void main(String[] args) {int[] numbers = {2, 3, 56, 78, 899, 6, 34,4, 5};
        bubbleSort(numbers);
        for (int i = 0; i< numbers.length; i++) {System.out.println(numbers[i]);
        }
    }
    public static void bubbleSort(int[] array){int temp = 0;
        //定义双层for循环，保证每一次元素都是与剩下的所有元素比较过的
        for (int i = 0; i< array.length -1; i++) {for (int j = i+1; j< array.length; j++) {//如果后一个元素比当前元素小，那么将它们互换位置
                if (array[i] >array[j]){temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }

            }
        }
    }
}
//排序后结果为：[2，3，4，5，6，34，56，78，899]

递归

递归就是自己调用自己，能不用就不用，递归很消耗内存。
递归解决问题的思路：

1. 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解；
2. 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算。

递归解决问题要找到两个内容：

1. 递归出口：否则会出现内存溢出；
2. 递归规则：与原问题相似的规模较小的问题。
   

public class Factorial {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要求的阶乘：");
        //一个数的阶乘就是从1到它自己的所有数相乘
        int number = scanner.nextInt();
        System.out.println(factorial(number));
    }
    public static int factorial(int n){if (n == 1) {return 1;
        } else {return n * factorial(n - 1);//递归调用
        }
    }
}

快排

快速排序算法中，每一次递归时以第一个数为基准数，找到数组中所有比基准数小的。再找到所有比基准数大的。小的全部放左边，大的全部放右边，确定基准数的正确位置。

public class QuickSort {public static void main(String[] args) {int[] array = {6,3,7,1,9,4,8,5,2,10};
	        int low = 0,high = array.length - 1;
	        quickRow(array,low,high);
	        for (int i : array){System.out.println(i);
	        }
	    }
    public static void quickRow(int[] array, int low, int high){int i,j,pivot;
        //结束条件
        if (low >= high) {return;
        }
        i = low;
        j = high;
        //选择的节点，这里选择的数组的第一数作为节点
        pivot = array[low];
        while (i< j){//从右往左找比节点小的数，循环结束要么找到了，要么i=j
            while (array[j] >= pivot && i< j){j--;
            }
            //从左往右找比节点大的数，循环结束要么找到了，要么i=j
            while (array[i]<= pivot && i< j){i++;
            }
            //如果i!=j说明都找到了，就交换这两个数
            if (i< j){int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        //i==j一轮循环结束，交换节点的数和相遇点的数
        array[low] = array[i];
        array[i] = pivot;
        //数组“分两半”,再重复上面的操作
        quickRow(array,low,i - 1);
        quickRow(array,i + 1,high);
    }
}

快排操作的步骤：

1. high从右开始找比基准数小的；
2. low从左开始找比基准数大的；
3. 找到后，交换high和low对应的两个值的位置；
4. high继续往左找，low继续往右找，直到high和low指向同一个索引为止；
5. 将基准数与high、low交汇的位置的元素互换位置；
6. 继续操作直到所有的元素排序完成。

排序总结

目前市面上有许多种排序，且都已经经过调试给出了API，因此，除非有特殊要求，否则不需要我们自定义排序方法，可以直接使用别人已经给出的排序方法。
之所以学习排序是为了熟练的对数组元素进行操作，了解一些排序算的基本原理。

Arrays

Arrays 类包含用于操作数组的各种方法，主要有以下几种：

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

由此可见，关于数组的不少操作都有现成的，且提供了API可以快捷的调用，因此，最开始的那一个例题，也就有了更简单的实现方法：

public class IntString {public static void main(String[] args) {String str = "91 27 46 38 50";
        String[] split = str.split(" ");
        int[] number = new int[split.length];
        for (int i = 0; i< number.length; i++) {number[i] = parseInt(split[i]);
        }
        Arrays.sort(number);//排序
        System.out.println(Arrays.toString(number));//转换为字符串输出
    }
}
//[27, 38, 46, 50, 91]

Arrays类中也有构造方法，只不过构造方法被private修饰，外界无法使用，所以帮助文档中也看不到。
不过通过查看源码，我们可以找到如下的内容：
private Arrays() {}

说明Arrays类的设计是采用的常用的工具类的设计思想——构造方法私有，成员都用static修饰。

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

本文名称：Java——基本类型包装类和数组高级操作-创新互联
本文网址：http://cdweb.net/article/eosgg.html