Java 数组

一、数组简介

• 数组是多个雷同类型数据的组合，实现对这些数据的对立治理
• 数组属援用类型，数组型数据是对象(Object)
• 数组中的元素能够是任何数据类型，包含根本类型和援用类型
• 数组类型是繁多，只能寄存雷同类型的数据
• 数组一旦创立，大小就是固定的
• 数组中每个元素都有本人的地位(下标), 从 0 开始

所以数组个别用来寄存大小固定的数据：例如寄存班级学生问题

int scores = {100,90,98,99,88,80}

二、创立数组

要害数组的关键字:[]

int [] a 和 int a[]含意是一样的，[]和 变量名 前后是没有关系的。

2.1 只申明不赋值

type [] var; 或者 type var [] ;

例如:

int score[];
int [] score;
Object [] obj;  //Object 是 java 语法中老祖宗

2.2 申明并赋值

type [] var = new type[size]; // 创立的是数据，数组的元素为空。值默认的就是该类型的默认值

type [] var = {elm,elem2,elem3,…} // 创立的同时，把数据也赋值了

public static void main(String[] args) {

    // 申明 默认值
    int score[] = new int[9];
    for(int i = 0;i<score.length;i++) {System.out.print(score[i]+"\t");
    }

    System.out.println("------------");
    // 创立并且赋值
    int score2[] = {100,90,88,85,66};
    for(int i = 0;i<score2.length;i++) {System.out.print(score2[i]+"\t");
    }

2.3 new 数组内存模型

new:java 中的关键字，次要作用用来在内存中，开拓新的空间，从而创立新的对象

2.4 下标操作元素

2.4.1 通过下标给元素赋值

int score[] = new int[9];

// 指定元素赋值
score[2] = 10;
score[5] = 50;

2.4.2 通过下标获取元素内容

int num2 = score[2];
System.out.println("num2="+num2);

for(int i = 0;i<score.length;i++) {System.out.print(score[i]+"\t");
}

2.5 注意事项

• Java 中应用关键字 new 创立数组对象
• 定义并用运算符 new 为之调配空间后，才能够援用数组中的每个元素；

• 数组元素的援用形式：数组名[数组元素下标]

  • 数组元素下标能够是整型常量或整型表达式。如 a[3] , b[i] , c[6*i];
  • 数组元素下标从 0 开始；长度为 n 的数组非法下标取值范畴: 0 – n-1；如 int a[]=new int[3]; 可援用的数组元素为 a[0]、a[1]、a[2]
• 每个数组都有一个属性 length 指明它的长度，例如：a.length 指明数组 a 的长度(元素个数)

三、遍历数组

遍历数组能够通过下标，或者加强 foreach 循环来进行元素的遍历

3.1 一般 for 循环

因为能够应用 arr[index] 形式拜访元素，所以咱们能够通过 arr.length 来循环获取不同索引的值；

然而留神: 索引的范畴是:0-(length-1), 不能大于等于 length 因为下标是从 0 开始计算。不然抛出数组越界异样

int score[] = {100,90,88,85,66};
for(int i = 0;i<score.length;i++) {System.out.println(score2[i]);
}

以上就是将 score 数组中所有的元素遍历了一次，并打印进去

3.2 加强 for 循环

Java 有一种性能很强的循环构造，能够用来顺次解决数组中的每个元素而不用为指定下标值而分心。
这种加强的 for 循环的语句格局为：

for(variable : arr)statement

例如：

int score[] = {100,90,88,85,66};
for(int ele:score){System.out.println(ele);
}

这种语法和下面一般的 for 循环达到的成果是一样的。这种 for each 循环语句显得更加简洁、更不易出错

四、数组拷贝

如果心愿将一个数组的所有值拷贝到一个新的数组中去，就要应用 Arrays 类的 copyOf 办法：

第 2 个参数是新数组的长度。这个办法通常用来减少数组的大小

int score[] = {100, 90, 88, 85, 66};

// 长度超过原数据的局部：应用默认 0 代替
int[] newArr01 = Arrays.copyOf(score, 10);

// 长度有余的，从前往后取对应的数据
int[] newArr02 = Arrays.copyOf(score, 3);

System.out.println("原数组 =" + Arrays.toString(score));
System.out.println("新数组 1 =" + Arrays.toString(newArr01));
System.out.println("新数组 2 =" + Arrays.toString(newArr02));

注意事项：

• 如果数组元素是数值型，那么多余的元素将被赋值为 0；
• 如果数组元素是布尔型，则将赋值为 false。
• 相同，如果长度小于原始数组的长度，则只拷贝最后面的数据元素。

五、数组排序

5.1 Arrays 工具类排序

java.util.Arrays：属于工具类，所以在应用之前，必须先导包

public static void main(String[] args) {int score [] = {99,89,78,88,69,70};
    String ch[] = {"B","C","A","F","D"};
    System.out.println("排序前:");
    for (int i = 0; i < ch.length; i++) {System.out.print(ch[i]+"\t");
    }
    System.out.println();

    // 进行排序
    //1. 只提供了升序排序 从小到大  没有提供降序。本人去实现
    //2. 也叫做天然程序。A(65) B(66) C(67) D(68)
    Arrays.sort(ch);

    System.out.println("排序后:");
    for (int i = 0; i < ch.length; i++) {System.out.print(ch[i]+"\t");
    }
}

4.2 通过算法实现排序(冒泡)

升序为例：

1. 将相邻的两个数，进行比拟，将大的数据往后挪动。顺次循环进行比拟，从而找到最大的数据
2. 因为每一次循环只能确定一个数据，所以须要屡次嵌套循环来实现最终的排序
3. 具体如下图

public static void main(String[] args) {int score [] = {99,89,78,88,69,70};
    //i=0 {89,78,88,69,70,99};
    //i=1 {78,88,69,70,89,99};
    //i=2 {78,69,70,88,89,99};

    System.out.println("第原始的后果:");
    for (int j = 0; j < score.length; j++) {System.out.print(score[j]+"\t");
    }
    System.out.println();

    // 排序：把后面几次排好了，最初一个主动确定了地位。少排序一次
    // 每次选一个最大的
    for (int i = 0; i < score.length-1; i++) {

        // 相邻的两个进行比拟，把大的往后移
        for (int j = 0; j < score.length-1-i; j++) {
            // 如果说 后面比前面的大，两者更换地位
            if(score[j]>score[j+1]) {
                // 两两调换，通过长期变量
                int temp = score[j];
                score[j] = score[j+1];
                score[j+1] = temp;
            }

        }
        System.out.println("第"+(i+1)+"次执行的后果:");
        for (int j = 0; j < score.length; j++) {System.out.print(score[j]+"\t");
        }
        System.out.println();}
}