一维数组

数组的长度一但确定便不能更改！

数组的分类：按照维度：一维数组、二维数组……..

按照元素的数据类型：基本数据类型元素的数组、引用数据类型元素的数组

一维数组

一维数组的初始化和声明：例：

//这是静态初始化（数组的初始化和数组元素的赋值操作同时进行）一维数组的初始化和声明：例：
int[ ] ids;（声明数组元素的数据类型）
ids=new int[]{1001,1002,1003,1004};
//这是动态初始化（数组的初始化和数组元素的赋值操作分开）
String[ ] names=new String[5];
names[0]=lihua;
names[1]=liming;

调用数组指定位置的元素：names[0]=”张良”；

获取数组的长度：属性：length 例：System.out.println(names.length)

数组的内存解析：

栈（stack）：局部变量
堆（heap）:new出来的结构：对象、数组等

匿名数组

声明一个匿名数组

new int[] {17,19,23,29,31,37}

可以用这种语法重新初始化一个数组而无需创建新变量，例如

smallPrimes=new int[]{17,19,23,29,31,37};

在Java中允许有长度为0的数组

new elementType[0]
或
new elementType[]{}

注：长度为0的数组与null并不相同

访问数组元素

• 创建一个数字数组时，所有元素初始化为0
• boolean数组，初始化为false
• 对象数组，初始化为null。例如

  String[]names=new String[0];

想要获得数组中元素的个数，可以使用array.length

for each循环

语句格式为：for(variable:collection) statement

它定义一个变量暂时用来存储集合中每一个元素，并执行对应的语句。collection这一集合表达式必须是一个数组或者是一个实现了Iterable接口的类对象。例如：

for(int element:a)
    System.out.println(element)

这个循环是循环a中的每一个元素

调用Arrays.toString(a)，返回一个包含数组元素的字符串，这些元素包围在中括号内，并用逗号分

数组拷贝

在Java中允许将另一个数组变量拷贝到另一个数组变量。这时，两个变量将引用到同一个数组：

int[] luckyNumbers=smallPrimes;
luckyNumbers[5]=12;

如果希望将一个数组的所有值拷贝到一个新的数组去，就要用到Arrays类的copyOf方法：

int[] copideLuckyNumbers=Arrays.copyOf(luckyNumbers,luckyNumbers.length);

第二个参数是新数组的长度。这个方法常用来增加数组的大小

数组排序

Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，可以直接调用。

升序排序

用法1：

Arrays.sort(int[] a)

它是对数组的所有元素进行升序排序，即将数组中的元素按照从小到大进行排序。

代码实现：

import java.util.Arrays;
public class Exercise10 {
    public static void main(String[] args) {
        int[] data = {5,2,0,1,3,1,4};
        Arrays.sort(data);
        for (int temp:data) {
            System.out.print(temp + " ");
        }
        System.out.println();
    }
}

运行结果：

结果说明：output为数组data的升序排序。

用法2：

Arrays.sort(int[] a, int fromIndex, int toIndex)

它是对数组部分元素进行升序排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序—[fromIndex,toIndex)

注意：下标为toIndex的元素不参与排序！

代码实现：

import java.util.Arrays;
public class Exercise10 {
    public static void main(String[] args) {
        int[] data = {5,2,0,1,3,1,4};
        Arrays.sort(data,1,4);
        for (int temp:data) {
            System.out.print(temp + " ");
        }
        System.out.println();
    }
}

运行结果：

降序排序

public static void sort(T[] a, Comparator c)

注：根据指定的比较器引发的顺序对指定的对象数组进行排序

public static void sort(T[] a,int fromIndex,int toIndex, Comparator c)

注：根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序

import java.util.Arrays;
import java.util.Comparator;
public class Exercise10 {
    public static void main(String[] args) {
        //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
        //而要使用它们对应的类
        Integer[] data = {5,2,0,1,3,1,4};
        //new一个MyComparator的对象
        MyComparator myComparator = new MyComparator();
        Arrays.sort(data,myComparator);
        for (int temp:data) {
            System.out.print(temp + " ");
        }
        System.out.println();
    }
}
class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        //降序
        return o2 - o1;
    }
}

运行结果：

Math.random方法将返回一个0到1之间的随机浮点数

抽奖程序

package com.java;
import java.util.Arrays;
import java.util.Scanner;
public class random {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("How many numbers do you need to draw?");
        int k=in.nextInt();
        System.out.println("What is the highest number you can draw?");
        int n=in.nextInt();
        int[] numbers= new int[n];
        for (int i=0;i<numbers.length;i++){
            numbers[i]=i+1;
        }
        int[] result=new int[k];
        for(int i=0;i<result.length;i++){
            int r=(int)(Math.random()*n);
            result[i]=numbers[r];
            numbers[r]=numbers[n-1];
            n--;
        }
        Arrays.sort(result);
        for (int r:result
             ) {
            System.out.println(r);
        }
    }
}