java基础语法之数组（内含冒泡排序）

目录

数组

数组的定义：

一维数组

数组的创建：

使用建议：

数组访问：

数组长度

数组的遍历：

二维数组

二维数组的遍历：

数组与方法

数组使用时常见的问题

Java中的内存划分

1栈内存

2.堆内存：

3.方法区：

4.本地方法栈：

5.寄存器：

冒泡排序：

---

数组

数组的定义：

在内存中开辟一块合适的空间（一串连续的空间），可以同时存放多个相同类型的数据值；

一维数组

可以存储相同类型的一组数据

声明数组：

在内存中开辟一块合适的空间（一串连续的空间）

特点：

1.是引用数据类型

2.数组中的多个数据类型必须统一

3.数组的长度一旦定义不可改变；

数组的创建：

1.动态初始化：

动态初始化数组的格式：

数据类型[] 数组名称= new 数据类型[数组长度];

double[] arrays = new double[6];

[]代表的是数组

new代表创建数组的动作

2.静态初始化：

静态初始化数组的格式：

数据类新[] 数组名称= new 数据类新[]{元素1,元素2,元素3...};

省略格式：

数据类新[] 数组名称={元素1,元素2,元素3...}；

int[] arrays = new int[]{1，2，3，4}；
//等价于
int[] arrays = {1，2，3，4}；

注意事项：

1.不定义数组长度，但数组会根据元素个数来自动定义数组长度；

2.静态初始化标准格式可拆，省略格式不可拆分；

使用建议：

元素确定的情况，可以使用静态初始化，但元素不确定的情况下只能使用动态初始化；

数组访问：

直接打印输出数组名称得到的是数组对应的内存地址的哈希值；

访问数组的格式：

数组名[索引值]

索引：int类型数组元素的下标；

注意：

索引值范围（0~数组长度-1）

使用动态初始化数组时，其中的元素将会自动拥有一个默认值，规则如下：

整形：默认0

浮点型：默认0.0

字符型：默认‘\u0000’

Boolean：默认false

引用类型：默认null

注意事项：

静态初始化，也会有默认值，但是直接会被大括号中的元素替换掉；

数组长度

数组名称.length

数组长度一旦被定义，程序运行期间不可改变。

数组的遍历：

对数组中的元素进行逐一，挨个处理；

二维数组

本质上还是一个一维数组，它的每一个元素又是一个一维数组

public class Demo11Array {
    public static void main(String[] args) {
        //定义二维数组
        int[][] arr1=new int[4][5];
​
        int[][] arr2=new int[2][];
        arr2[0]=new int[2];
        arr2[1]=new int[3];
​
        //3.
        int[][] arr3={{1,3,4},{2,3}};
​
​
​
    }
}
​

二维数组的遍历：

需要用的for循环的嵌套；

数组与方法

数组可以作为方法的参数

代码示例

public class Demo9ArrayParam {
    public static void main(String[] args) {
        int[] array = {10, 23, 45, 78, 89};
//        System.out.println(array);
//        printArray(array);
​
        int[] cal = cal(13, 24);
        System.out.println("和的结果："+cal[0]);
    }
}

数组可以作为方法的返回值

一个方法可以有0，1，多个参数，但是返回值只能有0个或1个，不能有多个返回值

如果希望一个方法中产生的多个结果进行返回，

解决办法：使用数组作为返回值类型即可

 代码示例：

public static int[] cal(int a, int b) {
        int sum = a + b;
        int mul = a - b;
​
        int[] arr = new int[2];
        arr[0] = sum;
        arr[1] = mul;
​
        return arr;
   }

方法名称	说明
boolean equals(array1,array2)	比较array1和array2两个数组是否相等
sort(array)	对数组array的元素进行升序排列
String toString(array)	将一个数组array转换成一个字符串
void fill(array,val)	把数组array所有的元素都赋值为val
copyOf(array,length)	把数组array复制成一个长度为length的新数组
int binarySearch(array,val)	查询元素值val在数组array中的下标（要求数组必须已经按照升序排列）

代码示例：

package cn.zhm;
​
import java.util.Arrays;
​
/**
 * Arrays类
 */
public class Demo10Arrays {
    public static void main(String[] args) {
        //equals（）：比较两个数组是否相等
        int[] arr1 = {10, 20, 30, 40};
        int[] arr2 = {10, 20, 30, 40};
        int[] arr3 = {10, 30, 20, 40};
​
        boolean result = Arrays.equals(arr1, arr3);
        System.out.println(result);
​
        //sort():对数组元素进行升序排序
        Arrays.sort(arr3);
​
        for (int i : arr3) {
            System.out.print(i + "\t");
        }
​
        System.out.println();
        //toString()
        System.out.println(Arrays.toString(arr3));
        //fill()
​
        Arrays.fill(arr3, 40);
        System.out.println(Arrays.toString(arr3));
        //copyOf()
        int[] newArr = Arrays.copyOf(arr2, 5);
        System.out.println(Arrays.toString(newArr));
​
        //binarySearch()
        int[] nums={45,34,67,89,56};
        Arrays.sort(nums);
        int index = Arrays.binarySearch(nums, 45);
        System.out.println(index);
​
​
    }
}

​

数组使用时常见的问题

数组索引越界异常。

数组的索引编号从0到长度-1结束

如果访问数组时，编号不存在就会发生数组索引越界

所有的引用类型变量，都可以赋值为一个null值，代表什么都没有

Java中的内存划分

1栈内存

存放的都是方法的局部变量；

局部变量：方法参数，或者方法（）内部变量；

2.堆内存：

凡是new出来的内容都在堆内存中；

堆内存中的内容都有一个16进制地址

堆内存中的数据，都有一个默认值；

3.方法区：

存放的时候.class想关的信息，包括方法的信息

4.本地方法栈：

与操作系统相关

5.寄存器：

与CPU相关

 

冒泡排序：

分析：

每次去比较相邻的两个数，进行交换

外层循环去控制比较轮数；

内层循环控制每轮比较的次数；

package cn.ybk;
​
/**
 * 冒泡排序
 *
 */
public class DemoBubbleSort {
    public static void main(String[] args) {
        //定义一个数组
        int[] arrays = {100,98,78,32,23,87,65};
        int temp;//定义一个临时变量用于交换
        for (int i=1;i<arrays.length;i++){
            //外层循环比较轮数
            for(int j=0;j<arrays.length-i;j++){
                //内层循环控制每轮比较的次数
                if(arrays[j]>arrays[j+1]){
                    temp=arrays[j];
                    arrays[j]=arrays[j+1];
                    arrays[j+1]=temp;
                }
            }
        }
        //打印
        for (int array : arrays) {
            System.out.print(array + "\t");
        }
    }
}