黑马程序员——JAVA数组

最新推荐文章于 2024-02-24 00:02:47 发布

skyHeXin

最新推荐文章于 2024-02-24 00:02:47 发布

阅读量305

点赞数

本文链接：https://blog.csdn.net/skyHeXin/article/details/46437081

版权

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

(1)数组：存储同种数据类型的多个元素的容器。

(2)特点：每一个元素都有编号从0开始，最大编号是数组长度-1，方便操作这些元素。

(3)定义格式：A数据类型[] 数组名；
B数据类型数组名[]；

(4)数组的初始化：
A:动态初始化
只给长度，系统给出默认值。
举例：int[] arr = new int[3];
B:静态初始化
给出值，系统决定长度。
举例：int[] arr = new int[]{1,2,3};
简化版：int[] arr = {1,2,3};

(5)数组的内存分配及特点：

int[] arr = new int[4];

内存分配图：

(6)Java的内存分配：
A:栈存储局部变量
B:堆存储所有new出来的
C:方法区
D:本地方法区(系统相关)
E:寄存器(CPU使用)

栈内存：
用于存储局部变量，当变量所属的作用域一旦结束，所占空间会自动释放。
堆内存：
数组和对象，通过new建立的实例都存放在堆内存中。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值，根据类型的不同而不同。整数类型是0，小数类型是0.0或0.0f，boolean类型是false，char类型是'\u0000'。
如果将数组的引用实体设置为null，也就是实体不再被使用，那么会在不确定的时间内被垃圾回收器回收。

(7)数组操作常见问题:

数组脚标越界异常(ArrayIndexOutOfBoundsException)：访问到了数组中的不存在的脚标时发生。

class ArrayDemo{
public static void main(String[] args){
int[] arr = new int[3];
System. out.println(arr[3]);
}
}

运行结果：

空指针异常(NullPointerException)：当引用型变量没有指向任何实体时，用其操作实体，就会发生该异常。

class ArrayDemo{
public static void main(String[] args){
int[] arr = null;
System. out.println(arr[0]);
}
}

运行结果：

直接打印数组的引用变量，打印出来的结果是数组初始地址的哈希值。

ArrayDemo.java
class ArrayDemo{
public static void main(String[] args){
int[] arr = new int[3];
System. out.println(arr);
}
}

"[I"表示的是int类型数组，"@"后面的内容表示数组初始地址的哈希值。

数组常见操作:

遍历并打印数组元素:

class ArrayDemo{
public static void main(String[] args) {
int[] arr = {22,33,20,18};
for(int x = 0; x < arr.length; x += 1){
System.out.println("arr[" + x + "] = " + arr[x] + ";");
}
}
}

运行结果：

获取最值：

思路：

1、需要进行比较，并定义变量记录住每次比较后较大的值。

2、对数组中的元素进行遍历取出，和变量中记录的元素进行比较。

如果遍历到的元素大于变量中记录的元素，就用变量该记录住大的值。

3、遍历结果，该变量记录就是最大值。

两个明确：

明确一：结果。是数组中的元素：int类型。

明确二：未知内容。数组。

示例1：通过定义变量记录较大的值的方式实现。

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {89,34,-270,17,3,100};
int max = getMax(arr);
System.out.println("max = " + max);
}
public static int getMax(int[] arr){
int maxElement = arr[0];
for(int x = 1; x < arr.length; x++){
if(arr[x] > maxElement)
maxElement = arr[x];
}
return maxElement;
}
}

运行结果:

示例2：通过定义变量记录较大的值的索引方式实现。

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {89,34,-270,17,3,100};
int max = getMax(arr);
System.out.println("max = " + max);
}
public static int getMax(int[] arr){
int maxIndex = 0;
for(int x = 1; x < arr.length; x++){
if(arr[x] > arr[maxIndex])
maxIndex = x;
}
return arr[maxIndex];
}
}

运行结果:

排序(选择排序，冒泡排序):

选择排序

思路：
1、首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元素，就互换内容。
2、经过第一轮比较之后，此时第一个元素就是数组中最小的元素。然后再拿第二个元素与除第一个元素和其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。
3、依次类推，直到最后一个元素。

具体流程如下图所示：

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {89,34,-270,17,3,100};
System.out.print("排序前数组：" );
printArray(arr);
selectSort(arr);
System.out.print("排序后数组：" );
printArray(arr);
}
public static void selectSort(int[] arr){
for(int x = 0; x < arr.length - 1; x++){
for(int y = x + 1; y < arr.length; y++){
if(arr[x] > arr[y]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
public static void printArray(int[] arr){
System. out.print("[" );
for(int x = 0; x < arr.length; x++){
if(x != arr.length - 1)
System.out.print(arr[x] + "," );
else
System.out.println(arr[x] + "]" );
}
}
}

运行结果:

P.S.
1、上面的selectSort方法之所以不用返回int数组的原因是因为：arr引用变量是对传入selectSort方法中作为参数的数组的引用，selectSort方法执行完毕之后，我们依然可以通过arr引用变量操作传入的数组。所以，没有必要再通过返回值获取。
2、上面的选择排序算法效率比较低，因为数组每一个元素与剩下的元素比较就是为了获得最小的元素并且与之互换。例如：{89,34,-270,17,3,100}这个数组，第一轮就要互换4次才能使第一个元素存储的是这个数组中最小的元素。如果是这样，那么更高效率的方式则是只需要通过两个变量，一个记录最小值，一个记录最小值所在的角标即可。等当前元素与余下的所有元素比较完，直接互换，这样只需互换一次就能达到目标，效率自然就会提高。

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {89,34,-270,17,3,100};
System.out.print("排序前数组：" );
printArray(arr);
selectSort(arr);
System.out.print("排序后数组：" );
printArray(arr);
}
public static void selectSort(int[] arr){
for(int x = 0; x < arr.length - 1; x++){
int num = arr[x];
int index = x;
for(int y = x + 1; y < arr.length; y++){
if(num > arr[y]){
num = arr[y];
index = y;
}
}
//如果最小的就是自己，就没有必要执行swap操作
if(index != x)
swap(arr,x,index);
}
}
public static void swap(int[] arr, int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void printArray(int[] arr){
System. out.print("[" );
for(int x = 0; x < arr.length; x++){
if(x != arr.length - 1)
System.out.print(arr[x] + "," );
else
System.out.println(arr[x] + "]" );
}
}
}

运行结果

冒泡排序
思路：
1、首先在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
2、经过第一轮比较，最大的元素就已经存储到数组最右边的结点中了。
3、第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
4、依照此方式，一直到只有第一和第二个元素互相比较而结束。
具体流程如下图所示：

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {89,34,-270,17,3,100};
System.out.print("排序前数组：" );
printArray(arr);
bubbleSort(arr);
System.out.print("排序后数组：" );
printArray(arr);
}
public static void bubbleSort(int[] arr){
for(int x = 0; x < arr.length - 1; x++){
for(int y = 0; y < arr.length - 1 -x; y++){
if(arr[y] > arr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[" );
for(int x = 0; x < arr.length; x++){
if(x != arr.length - 1)
System.out.print(arr[x] + "," );
else
System.out.println(arr[x] + "]" );
}
}
}

运行结果:

在真实开发中，是不可能让我们自己去写这些排序算法的，因为JDK中已经提供好了API可以直接供我们调用。

import java.util.Arrays;
class ArrayDemo{
public static void main(String[] args) {
int[] arr= {89,34,-270,17,3,100};
System.out.print("排序前数组：" );
printArray(arr);
Arrays.sort(arr);
System.out.print("排序后数组：" );
printArray(arr);
}
public static void printArray(int[] arr){
System. out.print("[" );
for(int x = 0; x < arr.length; x++){
if(x != arr.length - 1)
System.out.print(arr[x] + "," );
else
System.out.println(arr[x] + "]" );
}
}
}

运行结果:

折半查找(二分查找)

示例：简单遍历查找方式

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {4,1,5,7,8,4,2};
int index = getIndex(arr,2);
System.out.println("index = " + index);
}
public static int getIndex(int[] arr, int key){
for(int x = 0; x < arr.length; x++){
if(arr[x] == key)
return x;
}
return -1;
}
}

运行结果:

P.S.
如果一个数组是无序的，那么可以通过简单遍历查找的方式查找到某个元素所在的角标。但是如果一个数组是有序的，那么就可以通过一种更高效的方式达到相同的目的，也就是二分查找。

思路：
1、设置三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为（max+min）/2。
2、查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
3、如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。设置max = mid - 1，mid = (max + min)/2，重复第1、2步的操作。
4、如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。设置min = mid + 1，mid = (max + min)/2，重复第1、2步的操作。
5、如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值，此时返回-1。

具体流程如下图所示：

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {13,15,19,28,33,45,78,106};
int index = binarySearch(arr,78);
System. out.println("index = " + index);
}
public static int binarySearch(int[] arr, int key){
int max,min,mid;
min = 0;
max =arr. length - 1;
mid = (max + min)/2;
while(arr[mid] !=key){
if(key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
if(max < min)
return -1;
mid = (max + min)/2;
}
return mid;
}
}

运行结果：

代码2：

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {13,15,19,28,33,45,78,106};
int index = binarySearch(arr,78);
System.out.println("index = " + index);
}
public static int binarySearch(int[] arr, int key){
int max,min,mid;
min = 0;
max = arr. length - 1;
while(min <= max){
mid = (max + min) >> 1;
if(key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
}

运行结果：

P.S.
给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，那么这个元素的存储的角标如何获取？
可以先通过二分查找，返回min的值，然后将待插入元素存在角标为min的数组位置，数组中角标为min以及比min大的角标所在的数组元素全部往后顺延一个位置。
代码：

class ArrayDemo{
public static void main(String[] args) {
int[] arr= {13,15,19,28,33,45,78,106};
int index = binarySearch(arr,44);
System.out.println("index = " + index);
}
public static int binarySearch(int[] arr, int key){
int max,min,mid;
min = 0;
max = arr. length - 1;
while(min <= max){
mid = (max + min) >> 1;
if(key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
else
return mid;
}
return min;
}
}

运行结果：

说明：由上面的结果可以看到，如果要向数组{13,15,19,28,33,45,78,106}中插入值为44的元素，那么应该插入的位置角标是5，角标为5以及其后的元素都应该往后顺延一个位置。

P.S.
在实际开发中，二分查找也不需要我们自己去写，JDK中已经提供了相关的API供调用。

示例：

import java.util.Arrays;
class ArrayDemo{
public static void main(String[] args) {
int[] arr= {13,15,19,28,33,45,78,106};
int index = Arrays.binarySearch(arr,44);
System.out.println("index = " + index );
}
}

运行结果：

说明：返回的是-6而不是5的原因可以通过API文档查找到：

练习：获取一个十进制整数的2、8、16进制表现形式。

注意：

1、什么时候使用数组呢？
2、如果数据出现了对应关系，而且对应关系的一方是有序的数字编号，并作为角标使用，这时候必须要想到数组的应用。
3、将这些数据存储到数组中，根据运算的结果作为角标直接去查数组中对应的元素即可,这种方式称为查表法。

思路：
1、首先判断如果传入的十进制数为0，那么它的2、8、16进制都是0，直接返回0，不需要再执行余下的程序。
2、如下面的示意图中所示，以将十进制数转换成十六进制数为例：
      将60与15进行与操作，其值就是60的十六进制的最低位。
      再将60无符号右移4位，再与15进行与操作，其值就是60的十六进制的倒数第二位。
3、由上面的例子可以总结出，将一个十进制数转换为十六进制的步骤就是：
      将十进制数与15相与，将结果存储到一个数组的最低位。
      然后将十进制数右移4位，再与15进行与操作，其值就是该数对应的十六进制的倒数第二位。
      再右移4位，与15相与...直到相与结果为0为止。
4、进而可以推理得到，10进制转换为2和8进制的规律与转换为16进制很相似，只是偏移量和相与的数字不同而已。
      10进制转换为2进制的偏移量为1，相与数字为1。
      10进制转换为8进制的偏移量为3，相与数字为7。
  具体示意图如下所示：

import java.util.Arrays;
class ArrayDemo{
public static void main(String[] args) {
toHex(60);
toBin(-6);
}
//十进制-->二进制
public static void toBin(int num){
trans(num,1,1);
}
//十进制-->十六进制
public static void toHex(int num){
trans(num,15,4);
}
//十进制-->八进制
public static void toOctal(int num){
trans(num,7,3);
}
//进制转换的通用方法
public static void trans(int num, int base,int offset){
if(num == 0){
System.out.println("0" );
return;
}
char[] chs = {'0','1' ,'2' ,'3' ,'4' ,'5' ,'6' ,'7' ,'8' ,'9' ,'A' ,'B' ,'C' ,'D' ,'E' ,'F' };
char[] arr = new char[32];
int pos = arr.length ;
while(num != 0){
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
System. out.println("pos = " + pos);
for(int x = pos; x < arr.length; x++){
System.out.print(arr[x]);
}
System.out.println();
}
}

运行结果：