04Java数组

2

1. 数组概述

2. 数组声明和创建

3. 数组使用

4. 多维数组

5. Arrays 类

6. 稀疏数组

1.数组定义

2.数组声明和创建

 int[] nums2 = new int[10];//声明和创建

package com.duzehou.array;

public class ArrayDemo02 {
    //数组类型[]  数组名
    public static void main(String[] args) {
        //静态初始化
        int[] a = {1,2,3,4,5,6,7,8};
        Man[] men = {new Man(),new Man(), new Man()};//引用类型的数组

        //动态初始化:包含默认初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
        System.out.println(b[1]);//b[1]被隐式初始化
    }
}

package com.duzehou.array;

public class ArrayDemo01 {
    //数组类型[]  数组名
    public static void main(String[] args) {
        int[] nums1;//1.声明一个数组 首选方法

​        nums1 = new int[10];//2.创建一个数组  可以存放10个int类型的数字

​        int[] nums2 = new int[10];//声明和创建


​        //3.给数组元素赋值
​        nums1[0] = 1;
​        nums1[1] = 2;
​        nums1[2] = 3;
​        nums1[3] = 4;
​        nums1[4] = 5;
​        nums1[5] = 6;
​        nums1[6] = 7;
​        nums1[7] = 8;
​        nums1[8] = 9;
​        nums1[9] = 10;

​        int sum =0;
​        for (int i = 0; i < nums1.length; i++) {
​            sum  = sum +nums1[i];
​        }
​        System.out.println("sum = " + sum);
​    }
}

3.数组使用

• For-Each循环

• package com.duzehou.array;
  
  public class ArrayDemo03 {
  
      public static void main(String[] args) {
         int[] arrays = {1,2,3,4,5};
         //打印全部数组元素
          for (int i = 0; i < arrays.length; i++) {
              System.out.println(arrays[i]);
          }
          System.out.println("==============");
          //打印数组元素之和
          int sum = 0;
          for (int i = 0; i < arrays.length; i++) {
              sum+=arrays[i];
          }
          System.out.println("sum = "+sum );
          System.out.println("============");
          //打印数组元素中的最大值
          int max = arrays[0];
          for (int i = 0; i < arrays.length; i++) {
              if (arrays[i] > max){
                  max = arrays[i];
              }
          }
          System.out.println("max = "+max );
      }
  }
  

• 数组作为方法

• 数组作为返回值

package com.duzehou.array;

public class ArrayDemo04 {

    public static void main(String[] args) {
       int[] arrays = {1,2,3,4,5};
       //JDK1.5  取不到下标
//        for (int array : arrays) {
//            System.out.println(array);
//        }
        printArray(arrays);
        //
        int[] reverse = reverse(arrays);
        System.out.println();
        System.out.println("=================");
        printArray(reverse);
    }

    //数组作为参数
    public static void printArray (int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
    //数组作为返回值
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转操作
        for (int i = 0, j = result.length-1 ; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }

}

4.多维数组

public static void main(String[] args) {
    /**
     * 1,2 array[0]
     * 2,3 array[1]
     * 3,4 array[2]
     * 4,5 array[3]
     */
   int[][] array = {{1,2},{2,3},{3,4},{4,5}};

    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }
    }
    printArray(array[0]);
    System.out.println();
    System.out.println(array[2][0]);
    System.out.println(array[2][1]);
}

5.Arrays 类

public static void main(String[] args) {
    int[] a = {27,8,6,3,2,78,3478,235,7,8,1,2,3,8,6,7,2,3,8,4,7};
    //打印数组元素
    System.out.println(Arrays.toString(a));
    //排序
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));
    //填充；
    Arrays.fill(a,0);
    System.out.println(Arrays.toString(a));
}

冒泡排序

package com.duzehou.array;

import java.util.Arrays;

public class ArrayDemo07 {

    public static void main(String[] args) {
        int[] a = {27,8,6,3,2,78,3478,235,7,8,1,2,3,8,6,7,2,3,8,4,7};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }
    //冒泡排序
    //2.每一次比较都会产生一个最小的数，或者一个最大的数
    //3.下一轮则可以少一次排序
    //4.依次循环直到结束
    public static int[] sort(int[] array) {
        int temp = 0;
        //外层循环，决定循环多少次
        for (int i = 0; i < array.length - 1; i++) {
            //1.比较数组中相邻的两个数，如果第一个数比第二个小，交换他俩的位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1] < array[j]){
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }

        }
        return array;

    }
}

6.稀疏数组