数组

数组概述

1. 数组是相同类型数据的有序集合
2. 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
3. 其中，每一个数据称作一个数组元素，每个数组元素可以通过一下下标来访问他们

数组声明创建

1. 首先声明数组变量

int[] num;//声明一个数组
或
int nums[];

2. Java语言使用new操作符来创建数组

num = new int[5];//创建一个数组

3. 数组元素是通过索引访问，数组索引从0开始
4. 获取数组长度

arrays.length

练习

计算长度为5的数组{1，2，3，4，5}之和并打印每个数组元素

public class sum {
    public static void main(String[] args){
        int[] num = new int[5];
        for(int i = 1;i<=num.length;i++){
            num[i-1]=i;//下标为0开始赋值
            System.out.println(num[i-1]);
        }
        int sum = 0;
        for(int j = 0;j<num.length;j++){
            sum+= num[j];
        }
        System.out.print(sum);
    }
}

数组使用

反转数组

package com.snowMoon;

public class reverse {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        int[] a = rev(arrays);
        printArray(a);
    }
        public static int[] rev(int[] arrays){
            int[] arr = new int[arrays.length];
            for (int i = arr.length,j = 0;i>0;i--,j++){
                arr[i-1]=arrays[j];
            }
            return arr;
        }
        public static void printArray(int[] arrays){
        for (int i =0;i<arrays.length;i++){
            System.out.println(arrays[i]+" ");
        }
        }
    }

多维数组

二维数组

int a[][] = nwe int[][];

遍历二维数组

public static void main(String[] args){
    int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};
    for(int i = 0;i<arrays.length;i++){
        for(int j = 0;j<arrays[i].length;j++){
            System.out.print(arrays[i][j]);
        }
    }
} 

Arrays类

数组工具类

java.util.Arrays

Java8API文档

冒泡排序

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

        int[] a = {99,88,777,8556,123,12,5,100};
        int[] arr = sort(a);
        System.out.println(Arrays.toString(arr));
    }
    public static int[] sort(int[] arrays){

        int max = 0;
        boolean flag = false;//优化时间复杂度

        for (int i = 0;i< arrays.length-1;i++){
            for (int j = 0;j<arrays.length-1-i;j++){
                if (arrays[j+1]>arrays[j]){//从大到小>，从小到大<
                    max = arrays[j+1];
                    arrays[j+1] = arrays[j];
                    arrays[j] = max;
                    flag = true;
                }

            }
            if (flag == false){
                break;
            }//优化时间复杂度
        }
        return arrays;
    }
}

稀疏数组

............

java07-数组

原文：https://www.cnblogs.com/snowMoon/p/14998248.html