Day06--Java学习之数组

数组

1.数组概述

• 数组就是相同类型数据的有序集合
• 每一个数据成为一个数组元素，每个数组元素通过一个下标来访问他们

2. 数组创建声明

int[] nums = new int[4]; //为nums数组开辟了4个int数据类型的内存空间

注意： 上面那种声明数据变量的方法为首选，下面那种是当时为了C++程序员适应保留的一种写法

​ tips：数组声明的时候只在栈中存放了数据的一个对应数据类型的指针，初始化时会指向新开辟的堆空间，如果越界访问了会抛出异常

3. 数组使用

1. For-Each循环

2. 数组作为方法入参

3. 数据作为返回值

   public class ArrayDemo01 {
          
       public static void main(String[] args) {
          
           int[] nums = {
          1,2,3,4,5};
           for (int i = 0; i < nums.length; i++) {
          
               System.out.println(nums[i]);
           }
           //输入nums.for自动生成
           for (int num : nums) {
          
               System.out.println(num);
           }
   
   
       }
   
       //反转数组
       public static int[] reverse(int[] arrays){
          
           int[] m =new int[arrays.length];
           for (int i = 0; i < arrays.length; i++) {
          
               m[i] = arrays[arrays.length-1-i]
           }
           return m;
       }
   }
   
   

4.多维数组

5.Arrays类

package com.kang.array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo01 {
     
    public static void main(String[] args) {
     


        int[] nums = {
     1,2,3,4,5,9,6,8,0};
        for (int i = 0; i < nums.length; i++) {
     
            System.out.println(nums[i]);
        }
        //输入nums.for自动生成
        for (int num : nums) {
     
            System.out.println(num);
        }
        System.out.println(Arrays.toString(nums));
        Arrays.sort(nums);//数组进行排序，升序
        Arrays.fill(nums,0);//对数组进行填充
        Arrays.fill(nums,2,4,1);//对数组下标为2到4之间的数值进行填充


    }

    //反转数组
    public static int[] reverse(int[] arrays){
     
        int[] m =new int[arrays.length];
        for (int i = 0; i < arrays.length; i++) {
     
            m[i] = arrays[arrays.length-1-i]
        }
        return m;
    }
}

6. 冒泡排序

package com.kang.array;


public class Demo02 {
     
    public static void main(String[] args) {
     
        int[] a ={
     4,7,2,5,1,9,3};
        int[] sort = bubbleSort(a);
        for (int i : sort) {
     
            System.out.println(i);
        }
    }

    //冒泡排序的本质就是比较相邻的两个数，如果一方比一方大或者小则交换顺序
    //一轮冒泡后可以将一个数到达最终的位置
    public static int[] bubbleSort(int[] array){
     
        //外层循环，判断比较的边界
        for (int i = 0; i < array.length-1; i++) {
     
            boolean flag = false;//通过flag减少没有意义的比较
            //内层循环，比较相邻的两个数，比如如果前一个数比后一个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
     
                if(array[j]>array[j+1]){
     
                    int temp =array[j];
                    array[j]= array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if(!flag){
     
                break;   //如果比较一轮发现没有交换也就是本身有序的情况下直接跳出循环
            }
        }
        return array;
    }
}

7.稀疏数组