java数组

一、数组的定义

        1.数组的概念

        2.初始化数组

 二、数组的使用

        1.访问数组

        2.遍历数组

三、冒泡排序

        1.算法步骤 （取自菜鸟教程）

        2.代码实现

一、数组的定义
        1.数组的概念
        数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

        数组既可以存储基本数据类型，也可以存储引用数据类型。

        数组是一组相关数据的集合，一个数组实际上就是一连串的变量。

        声明一个数组就是在内存空间划出一串连续的相同类型的空间。

        2.初始化数组
        初始化数组有动态初始化和静态初始化两种

        动态初始化：在创建数组时，只定义数组中元素的个数，并未给里面的元素进行赋值

数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[数组长度];
数组存储的数据类型 数组名字[ ] = new 数组存储的数据类型[数组长度];
int [] array = new int [ 10 ];
int array[]=new int [10];
//可以拆分
int [] arr;
arr=new int[10];
         静态初始化：在创建数组时不定义数据元素个数，而直接将数组里的数据内容进行赋值，编译器会自己判定数组有几个元素，后面的数据必须与前面定义的数据类型一致

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
int[] array1 =new int [] {0,1,2,3,4,5,6,7,8,9};  
// 可以拆分 
int[] array1;
array1 = new int[]{1,2,3,4,5,6,7,8,9};
数据类型[] 数组名 = {元素1,元素2,元素3…};//不可拆分
int[] array1 ={0,1,2,3,4,5,6,7,8,9}; 

 二、数组的使用
                数组元素根据类型不同，会有不同的初始值。

        1.访问数组
        通过数组的下标进行访问，数组在内存中是一块连续的内存空间。数组的下标是从0开始的，所以数组用下标访问最大能到数组长度-1

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(array[3]);
    }
}
        数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1

public static void main(String[] args) {
     int[] arr = new int[]{1,2,3,4,5}; 
     //打印数组的属性，输出结果是5
      System.out.println(arr.length);
}
        2.遍历数组
        for循环打印数组

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
}
         for each打印数组

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int x:array) {
            System.out.print(x+" ");
        }
    }
}
        to String打印数组

import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(Arrays.toString(array));
    }
}
三、冒泡排序
        冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

        1.算法步骤 （取自菜鸟教程）
                比较相邻的元素。如果第一个比第二个大，就交换他们两个。

                对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

                针对所有的元素重复以上的步骤，除了最后一个。

                持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

        2.代码实现
public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请随机输入十个整数：");
        int[] arr = new int[10];
        for (int j = 0; j < arr.length; j++) {
            System.out.println("请给第" + (j + 1) + "位赋值");
            arr[j] = sc.nextInt();
        }
        int num = 0;
//        排序轮数
        for (int i = 0; i < arr.length - 1; i++) {
//            比较次数
            for (int k = 0; k < arr.length - 1 - i; k++) {
                if (arr[k] > arr[k + 1]) {//相邻元素两两相比
                    num = arr[k + 1];//交换元素
                    arr[k + 1] = arr[k];
                    arr[k] = num;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }