数组基础知识

1.数组定义
多个相同类型的数据的组合。
数组的作用：实现对这些数据的统一管理，解决数据的批量存储问题。
（将同种类型的数据进行封装，抽象成一个对象，直接用对象实现对这些数据的统一管理，符合面向对象的思想）
核心：数组就是一个对象，数组中的元素是对象的成员变量。

2.数组的使用

1)声明和创建
**元素类型[] 数组名（本质，数组类型的引用变量） = new 元素类型[数组长度];**
数组中元素的类型可以是任意类型（基本类型和引用类型）

2)数组的初始化
    动态初始化：数组声明且为数组元素分配空间与赋值的操作可以分开。

    基本类型：

        int[] arr = new int[3];
        arr[0] = 3;
        arr[1] = 9;
        arr[2]  = 8;
    引用类型：
        MyDate dates[];

        dates = new MyDate[3];

        dates[0] = new MyDate(22, 7, 1964);

        dates[1] = new MyDate(1, 1, 2000);

        dates[2] = new MyDate(22, 12, 1964)     ;

静态初始化：在定义数组的同时就为数组元素分配空间，并进行赋值。     

       基本类型：
              两种写法：int[] a= new int[] {3,9,8};
                      int[] a = {3,9,8}; 数组定义和赋值必须在同一行。
      引用类型：
            MyDate dates[] = {
                        new MyDate(22, 7, 1964),
                        new MyDate(1, 1, 2000),
                        new MyDate(22, 12, 1964)}

3.数组和for循环
数组中保存的是同种类型的元素，无论在做什么操作的时候都有可能是一个循环的过程。

利用for循环给数组进行赋值
利用for循环遍历数组

代码分析：

1.数组创建，创建时要关注数组的长度，使用for循环创建和遍历数组要避免数组越界，越界会报异常。
体会for循环和数组下标之间的关系。
for循环为数组赋值和遍历数组分开做。

class ArrayTest1 {

    public static void main(String[] args) {
        int[] arr = new int[5]; // 有效下标是0~长度-1 
        for (int i = 0; i < 5; i++) { // 数组和循环是在一起
            // 0~4
            arr[i] = (i + 1) * 10;
        }

        // 数组的遍历(迭代)
        for (int i = 0; i < 5; i++) {
            System.out.println(arr[i]);
        }
    }
}

2.创建一个奇数数组

/**
    创建一个数组，保存10个奇数，遍历数组打印输出
*/
class ArrayTest2 {

    public static void main(String[] args) {

        int[] oddArr = new int[10];
        //1 3 5 7 9
        for(int i = 0; i < 10; i++) {
            //将奇数保存
            oddArr[i] = 2 * i + 1;
        }

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

class ArrayTest3 {

    public static void main(String[] args) {
        int[] arr = new int[50]; // 数组对象一旦创建,长度就是固定的,不可改变
        System.out.println("数组长度:" + arr.length);
        //arr.length = 10; arr.length是一个常量, 固定不变

        for (int i = 0; i < arr.length; i++) { // 数组和循环是在一起
            // 0~4
            arr[i] = (i + 1) * 10;
        }

        // 数组的遍历(迭代)
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

3.char型数组

/**
    1)创建26个元素的字符数组，保存26个小写字母，遍历打印输出
    2)创建36个元素的字符数组，前26个保存小写字母，后10个保存10个数字字符
    3)创建6个元素的数组，保存你的生日和今天的日期，最后打印输出
    4)创建一个数组，保存所有汉字，打印输出
*/
public class CharArrayTest {

    public static void main(String[] args) {
        /*
            1)创建26个元素的字符数组，保存26个小写字母，遍历打印输出
        */
        //声明长度为26的字符串数组cArr
        char[] cArr = new char[26];
        //利用循环给每个元素进行赋值
        for(int i = 0; i < cArr.length; i++) {
            cArr[i] = (char)('a' + i);
        }
        //利用循环打印输出数组中的每个元素
        for(int i = 0; i < cArr.length; i++) {
            System.out.print(cArr[i] + " ");
        }

        System.out.println("\n" + "----------------------------------------------------");
        /*
            2)创建36个元素的字符数组，前26个保存小写字母，后10个保存10个数字字符
        */
        char[] cArr2 = new char[36];

        for(int i = 0; i < cArr2.length; i++) {

            if(i < 26) {
                cArr2[i] = (char)('a' + i);
            }else {
                cArr2[i] = (char)('0' + i - 26);
            }
        }

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

        System.out.println("\n" + "----------------------------------------------------");

        /*
            3)创建6个元素的数组，保存你的生日和今天的日期，最后打印输出
        */
        //声明长度为6的int[] 型数组，并将数组对象的地址写入引用变量iArr中
        int[] iArr = new int[6];
        //对数组中的每个元素进行赋值
        iArr[0] = 1993;
        iArr[1] = 11;
        iArr[2] = 11;
        iArr[3] = 2016;
        iArr[4] = 7;
        iArr[5] = 27;
        //打印输出生日
        for(int i = 0; i < 3; i++) {
            System.out.print(iArr[i] + ".");
        }
        System.out.println(" ");
        //打印输出今天的日期
        for(int i = 3; i < iArr.length; i++) {
            System.out.print(iArr[i] + ".");
        }

        System.out.println("\n" + "----------------------------------------------------");
        /*
            4)创建一个数组，保存所有汉字，打印输出
            汉字的Unicode码值 4e00 ~ 9fa5
            unicode码对每一个字符用4位16进制数表示
            parseInt(String s, int radix)
        */
        String start = "\\u4e00";
        String end = "\\u9fa5";
        //将unicode码转换成int型判断个数
        int s = Integer.parseInt(start.substring(2,start.length()),16);
        int e = Integer.parseInt(end.substring(2,end.length()),16);
        //定义一个长度为所有汉字总个数的 char[] 数组
        char[] cArr3 = new char[e - s];
        //存储所有汉字到字符数组中
        for(int i = 0; i < cArr3.length; i++) {
            cArr3[i] = ((char)(s + i));
        }
        //遍历数组
        for(int i = 0; i < cArr3.length; i++) {
            System.out.print(cArr3[i] + " ");
        }
    }
}

4.main方法中的(String[] args)
有关命令行参数的练习

/*
    从命令行接收8个(有效)分数值，如果分数值大于等于90，打印优，
    大于60小于等于90，打印及格，小于60打印不及格
    使用命令行参数的练习
*/
class Exer2 {

    public static void main(String[] args) {

        for(int i = 0; i < args.length; i++) {

            int score = Integer.parseInt(args[i]);
            if (score >= 90) {
                System.out.println(args[i] + ":优");

            }else if(score >= 60){
                System.out.println(args[i] + ":及格");
            }else {
                System.out.println(args[i] + ":不及格");
            }
        }
    }
}

5.引用类型数组

/*
    字符串数组
*/
class Exer1{

    public static void main(String[] args) {
        //声明数组的简单写法,这种写法声明和初始化必须在同一行 
        //静态初始化:在定义数组的同时就为数组元素分配空间并赋值。
        String[] strArr = {"小明", "小红", "黎明"};
        String[] strArr1 = new String[]{"小明", "小红", "黎明"};
        //声明数组的简单写法，这种写法声明和初始化可以分开 动态初始化
        //初始化(为数组分配空间并赋值)
        //动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
        String[] strArr2;
        strArr2 = new String[]{"小明", "小红", "黎明"};

        for(int i = 0; i < strArr.length; i++) {
            System.out.print(strArr[i] + " ");
        }
        System.out.println();
        for(int i = 0; i < strArr1.length; i++) {
            System.out.print(strArr1[i] + " ");
        }
        System.out.println();
        for(int i = 0; i < strArr2.length; i++) {
            System.out.print(strArr1[i] + " ");
        }
    }
}

/*
    创建引用类型的数组(对象)
    创建一个MyDate型的数组，保存两个MyDate类的对象，一个是你的生日，一个是今天的日期
*/
class Exer2 {

    public static void main(String[] args) {
        //声明一个MyDate型数组对象，创建数组，并将数组对象的地址写入md引用变量中
        MyDate[] md = new MyDate[2];
        md[0] = new MyDate(1993,11,11);
        md[1] = new MyDate(2016,7,28);
        //若是数组中具有空洞，此时还调用成员方法，就会抛出空指针异常
        for(int i = 0; i < md.length; i++) {
            System.out.println(md[i].say());
        }
    }
}
/*
    从命令行给MyDate对象赋值
*/
class Exer3 {

    public static void main(String[] args) {

        MyDate md = new MyDate( Integer.parseInt(args[0]),
                                Integer.parseInt(args[1]),
                                Integer.parseInt(args[2]));
        System.out.println(md.say());
    }
}

MyDate类

/**
    创建一个MyDate类
*/
public class MyDate {

    private int year;
    private int month;
    private int day;

    public MyDate() {

    }
    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void setYear(int year) {
        this.year = year;
    }
    public int getYear() {
        return year;
    }

    public void setMonth(int month) {
        this.month = month;
    }
    public int getMonth() {
        return month;
    }

    public void setDay(int day) {
        this.day = day;
    }
    public int getDay() {
        return day;
    }

    public String say() {
        return year + "年" + month + "月" + day + "日";
    }
}

6.随机数的生成

/**
    在指定范围内生成随机数
*/
//5个[10-30)随机整数
public class ArrayTest2 {
    public static void main(String[] args) {

        for(int i =0; i < 5; i++) {
            System.out.println ((int)(Math.random() * 20 + 10));
        }
    }
}
/*
    生成一个随机小数[0~1)
    生成一个随机小数[0~101)
    生成一个随机整数[0~50)
*/
class RondomDate {

    public static void main(String[] args) {
        //生成一个随机小数[0~1)
        double d = Math.random();
        System.out.println(d);
        //生成一个随机小数[0~101)
        double d2 = Math.random() * 101;
        System.out.println(d2);
        //生成一个随机整数[0~50)
        int i  = (int)(Math.random() * 50);
        System.out.println(i);
    }
}
// 生成5个[10~30)的随机整数
class RondomDate1 {

    public static void main(String[] args) {
        //声明一个int型长度为5的数组对象，并将数组对象的地址写入iArr
        int[] iArr = new int[5];
        //使用循环给数组中的元素进行赋值
        for(int i = 0; i < 5; i++) {

            iArr[i] = (int)(Math.random() * 20 + 10);
        }
        //for循环遍历数组iArr
        for(int i = 0; i < 5; i++) {
            System.out.print(iArr[i] + " ");
        }
    } 
}

7.数组for随机数的综合使用

/*
    创建一个int型数组，保存8个元素，这些元素范围[0~20)
    对这些数进行求和
    对这些数求平均数
    对这些数求max min
*/
class Exer4 {

    public static void main(String[] args) {

        int[] iArr = new int[8];
        //利用for循环给数组赋值
        for(int i = 0; i < iArr.length; i++) {
            iArr[i] = (int)(Math.random() * 20);
        }
        for(int i = 0; i < iArr.length; i++) {
            System.out.print(iArr[i] + " ");
        }
        System.out.println();
        //遍历，在遍历的时候求和 求max，min
        /*
            先假定下标为0的元素是最大值或者最小值，然后进行比较
        */
        int maxDate = iArr[0];
        int minDate = iArr[0];
        int sumDate = 0;
        for(int i = 0; i < iArr.length; i++) {
            if(iArr[i] > maxDate) {
                maxDate = iArr[i];
            }
            if(iArr[i] < minDate) {
                minDate = iArr[i];
            }
            sumDate += iArr[i]; 
        }
        int avg = sumDate / iArr.length;
        System.out.println("这些数的和是:" + sumDate);
        System.out.println("这些数中的max:" + maxDate);
        System.out.println("这些数中的min:" + minDate);
        System.out.println("这些数的平均数是:" + avg);
    }
}