数组基础知识

向右看齐 2022-09-24 11:24 239阅读 0赞

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);
        }
    }