java基础之数组

数组简介： 数组(Array)是 Java 语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合， 目的是用来一次存储多个数据。数组是程序中实现很多算法的基础，可以在一定程度上简化 代码的书写。
备注：

1. 数组的好处：数组里的每个元素都有编号，编号从 0开始，并且依次递增，方便操作这 些元素；
2. 使用 Java 数组：必须先声明数组，再给该数组分配内存；
3. 数组对应在内存中一段连续空间。
4. 数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须 是同一类数据类型。

一维数组的声明与初始化：
一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素； 一维数组的声明方式： typevarName[]; 或 type[]varName;
(推荐) intage[];int[]age;
数组的长度一旦确定,就不能改变,也就数组是定长的;
我的总结：java语言声明数组的时候不能指定其长度（元素的个数） Eg：int a[5];
//非法初始化： Java 中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每 个数组元素赋值；
数组初始化的两种方式：
静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；
格式：数组名 =new 数组类型[]{元素1,元素2,元素3…元素 n};
简化语法：数组名 ={元素 1,元素 2,元素3…元素n};
动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值； 格式：数组名 =new 数组类型[数组长度];
我的总结： 不能静态和动态初始化同时使用： 也就是说不能同时指定数组的长度和元素；

public class demo01 {
    public static void main(String[] args) {
        //创建一个数组
        int[] age = new int[10];
        //动态初始化
        for (int i = 0; i < age.length; i++) {
            age[i] = i;
            System.out.print(age[i] + "  ");
        }
    }
}

数组的使用：
Java 语言的数组索引是从 0 开始的，也就是说数组里的第一个元素的索引是 0,第二个元素的 索引是 1，依次可以类推。
常见操作： 给数组元素赋值 数组名[索引]= 数组类型的值 ;
访问数组元素 数组类型 变量 = 数组名[索引];
得到数组的长度 int len = 数组名.length; //length 是数组的属性 遍历数组
(备注：length 属性和循环语句） 数组元素的索引范围（0，长度—1）

public class demo02 {
    public static void main(String[] args) {
        int[] age = {1, 3, 3, 1, 5, 6, 5};
        //双层循环，定住一个在考虑下一个
        for (int i = 0; i < age.length; i++) {
            for (int j = i + 1; j < age.length; j++) {
                if (age[i] == age[j]) {
                    System.out.println("有重复的！" + age[i] + " " + age[j]);
                    break;
                }
            }
        }
    }
}``
求数组的最大值

数组求最大值：

//求最大值
public class demo03 {
    public static void main(String[] args) {
        int age[] = new int[] {12,23,56,88,45,19,78};
        int max = age[0];
        for (int i = 0; i < age.length; i++) {
            if (max < age[i]){
                max = age[i];
            }
        }
        System.out.println("数组的最大值max为：" + max);
    }
}

经典的冒泡算法：

    public static void bubblesort(int[] array) {
        for (int i = 0; i < (array.length - 1); i++) {
            //让每一次比较的元素减少，-1是为了防止数组角标越界
            for (int j = 0; j < (array.length - 1 - i); j++) {
                //相邻两元素相比
                if (array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
    }

选择算法

package com.huihui;

import java.util.Arrays;

public class demo04 {
    public static void main(String[] args) {
        int[] age = {11, 24, 54, 313, 516, 905, 192, 32, 12, 323};
        for (int i = 0; i < age.length; i++) {
            for (int j = i + 1; j <= age.length - 1; j++) {
                if (age[i] > age[j]) {
                    int temp = age[i];
                    age[i] = age[j];
                    age[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(age));
    }
}

分配内存空间：
分配内存空间 数组名=new 数据类型[数组长度]；
new 关键字用来实现为数组或对象分配内存 （堆内存） 数组具有固定的长度。
获取数组的长度： 数组名.length

定义数组+分配内存空间 数据类型[]数组名=new 数据类型[数组长度];
定义数组时不指定长度，分配空间时指定数组长度；
如：Stringcities[] =new String[6];

总结：初始化=定义数组+分配空间+赋值