数组——初阶

数组

  • 数组是多个相同类型数据的组合，实现对这些数据的统一管理

  • 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型

  • 数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量

 

一维数组的声明方式：

type var[] 或 type[] var；

例如：

 

int a[];

int[] a1;

double b[];

Mydate[] c; //对象数组

Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

 

随机数组
/*
    数组 : 一组相同类型的数据的组合, 实现对这些数据的统一处理.
    数组是通过for循环来实现统一处理的.
    数组 == 循环.
    
    任意数据类型都可以创建数组, 包括基本数据类型和引用数据类型.
    
    数组声明 :
        元素数据类型[] 数组名;
    数组创建 : 
        数组名 = new 元素数据类型[元素个数];
    
    数组元素的访问 :
        数组名[偏移量]; // 底层操作是一个加法运算, 首地址+偏移量 
    偏移量也称为下标或索引或脚标
    
    数组只要创建成功了, 它的每个元素都会自动的拥有缺省值0
        
    局部变量(保存在栈中的变量) : 没有隐式初始化值, 因为它速度太快
    数组元素(保存在堆中的变量) : JVM会自动隐式初始化, 初始化为0. 因为这里的数据最重要.
    
    数组下标从0开始到length - 1, 其他的下标都是越界. 
    
    数组一旦创建, 它的长度绝不允许修改, 元素类型也绝不能改变. 所以数组是一个非常稳定的数据结构.
    
    因为它的所有元素都是连续排列, 所以称它为顺序表.
    
*/
​
class ArrayTest3{
    
    public static void main(String[] args) {
        int [] arr = new int [8];
        for (int i = 0;i < arr.length; i ++) {
            arr [i] = (int) (Math.random() * 20);
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        int avg = sum / arr.length;
        System.out.println("avg: " + avg);
    }
}
​
class ArrayTest8 {
    
    public static void main(String[] args) {
        int[] arr = new int[8];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * 20);
        }
        // 遍历 
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        //0 1  2 3  4 5 6 7  
        //9 18 1 12 7 4 7 8
        //求所有能被7整除的数的平均值
        int sum = 0; // 求和 
        int count = 0; // 计数
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 7 == 0) { // 判断的依据不是循环因子, 而是元素值
                sum += arr[i]; // 有条件 求和 
                count++; // 有条件计数
            }
        }
        
        if (count == 0) {
            System.out.println("没有能被7整除的数");
        } else {
            int avg = sum / count; // 小心 : 0 / 0 
            System.out.println("能被7整除的数的平均值 : " + avg);
        }
        
    }
}
​

 

class ArrayTest8 {
    
    public static void main(String[] args) {
        int[] arr = new int[8];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * 20);
        }
        // 遍历 
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        //0 1  2 3  4 5 6 7  
        //9 18 1 12 7 4 7 8
        //求所有能被7整除的数的平均值
        int sum = 0; // 求和 
        int count = 0; // 计数
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 7 == 0) { // 判断的依据不是循环因子, 而是元素值
                sum += arr[i]; // 有条件 求和 
                count++; // 有条件计数
            }
        }
        
        if (count == 0) {
            System.out.println("没有能被7整除的数");
        } else {
            int avg = sum / count; // 小心 : 0 / 0 
            System.out.println("能被7整除的数的平均值 : " + avg);
        }
        
    }
}
数组元素的默认初始化

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：

 

public class Test {

public static void main(String argv[]){

int a[]= new int[5];

System.out.println(a[3]); //a[3]的默认值为0

}

}

  • 对于基本数据类型而言，默认初始化值各有不同

  • 对于引用数据类型而言，默认初始化值为null(注意与0不同！)

数组元素的引用

  • 定义并用运算符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的长度(元素个数)

  • 数组一旦初始化，其长度是不可变的

实例应用
public class Homework {
​
    public static void main(String[] args) {
     /*冒泡排序
        创建数组，遍历；
        冒泡排序，外循环控制比较趟数，内循环控制每趟的比较交换；
        遍历
      */
     int arr[] = new int[10];
     for (int i = 0; i < arr.length; i++) {
         arr[i] = (int) (Math.random() * 100);
         System.out.print(arr[i] + " ");
     }
        System.out.println();
     for (int i = 0; i < arr.length - 1; i++) {
         for (int j = 0; j < arr.length - i - 1; j++) {
             if (arr[j] > arr[j + 1]) {
                 int tmp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = tmp;
             }
         }
     }
     for (int i = 0; i < arr.length; i++) {
         System.out.print(arr[i] + " ");
     }
    }
​
    public static void main07(String[] args) {
        /*用下标找出能被3整除的最大值
        创建数组，遍历；
        以下标的方式找特定数据的最大值；
        非法下标，第一个满足条件的数据，无条件刷新maxIndex3；
        后面其他的满足条件的数据；
        分情况输出，没有能被3整除的数，有能被3整除的数，输出最大值；
         */
        int arr[] = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        int maxIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 3 == 0) {
                if (maxIndex == -1) {
                    maxIndex = i;
                }else{
                    if (arr[i] > arr[maxIndex]) {
                        maxIndex = i;
                    }
                }
            }
        }
        if (maxIndex == -1) {
            System.out.println("没有能被3整除的整数");
        }else{
            System.out.println("能被3整除的最大整数是" + arr[maxIndex]);
        }
    }
​
    public static void main06(String[] args) {
        /*交换位置
        交换i 和 length-i-1 的位置
        创建数组，遍历；
        tmp；
        遍历
         */
        int arr[] = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        for (int i = 0; i < (arr.length / 2) ; i++) {
            int tmp = arr[i];
           arr[i] =  arr[arr.length - 1 - i];
           arr[arr.length - 1 - i] = tmp;
​
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
​
    public static void main05(String[] args) {
        /*找出最大值的下标，最小值下标
        创建数组，遍历
        找出最大值下标，假定0下标位置的值最大，更换最大值，记录下标；
        找出最小值下标...
         */
        int arr[] = new int[10];
        for (int i = 0; i < arr.length; i  ++) {
            arr[i] = (int) (Math.random() * 100);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        int maxIndex = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i;
            }
        }
        System.out.println("最大值是" + arr[maxIndex]);
        int minIndex = 0;
        for  (int i = 0; i < arr.length; i++) {
            if (arr[i] < arr[minIndex]) {
                minIndex = i;
            }
        }
        System.out.println("最小值是" + arr[minIndex]);
    }
​
​
    public static void main04(String[] args) {
        /*
    找出能被3整除的数的最大值
    创建数组，遍历；
    max 初始化，找出能被3整除的数的最大值；
    分情况输出，数组内没有被三整除的数，else...
     */
        int arr[] = new int[10];
        for (int i = 0; i < arr.length; i ++) {
            arr[i] = (int) (Math.random() * 100);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        int max = 0x80000000;
        for (int i = 0; i < arr.length; i ++) {
            if (arr[i] % 3 == 0){
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
        }
        if (max == 0x80000000) {
            System.out.println("没有能被3整除的数" );
        }else{
            System.out.println("能被3整除的数的最大值：" + max);
        }
    }
​
    public static void main03(String[] args) {
/*
找出最大值，最小值
max、min初始化，赋值，遍历，找出最大值，最小值
*/
    int[] arr = new int[8];
    for (int i = 0; i < arr.length; i ++) {
        arr[i] = (int) (Math.random() * 100) ;
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    int max = 0x80000000;
    for (int i = 0;i < arr.length; i ++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
        System.out.println("最大值：" + max);
    int min = 0x7FFFFFFF;
    for (int i = 0; i < arr.length; i ++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
        System.out.println("最小值：" + min);
    }
​
​
    public static void main02(String[] args) {
        int[] arr = new int[8];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
        }
            // 遍历
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            //找出最大值
         System.out.println();
            /*
            假定第一个元素的值最大；遍历；让所有元素再比较如果数组中的
            某个元素的值比max还大，把最大值再刷新为最大的值
             */
            int max = arr[0];
            for (int i = 0; i < arr.length; i ++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
​
            }
        System.out.println(max);
​
​
​
    }
​
    public static void main01(String[] args) {
        int[] arr = new int[8];
        for (int i = 0; i < arr.length; i ++) {
            arr[i] = (int) (Math.random() * 100);
        }
        for (int i = 0; i < arr.length;i ++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        int sum = 0;
        int count = 0;
        for (int i = 0; i < arr.length; i ++) {
            if (arr[i] % 10 == 0)  {
                sum += arr[i];
                count++;
            }
        }
        if (count != 0) {
            int avg = sum / count;
            System.out.println("avg = " + avg);
        }else{
            System.out.println("没有能被10整除的数");
        }
    }
    

 

递归

public class Test {

// 求n的阶乘 n!
// n * (n-1)!, 问题可以分解成一个小问题和相同类型的子问题.
// 递归的思维方式 是告诉计算机做什么
// 递归方法100%必须要有参数, 因为要通过参数的变化, 让它变成有限的递归.
public static int test(int n) {
    //return test(n); // 方法调用自身称为递归调用, 这种写法的递归会导致栈溢出. 无限递归(死归)
    if (n == 1) { // 递归中必须要有中止条件, 否则会死归
        return 1;
    }
    return n * test(n - 1); // 递归时必须要让参数变化, 趋于中止条件.
}
​
public static void main(String[] args) {
    System.out.println(test(5));
    // for循环的思维是告诉计算机怎么做
    int result = 1;
    for (int i = 1; i <= 5; i++) {
        result *= i;
    }
    System.out.println(result);
}
 
posted @ 2022-04-21 15:33  叶舞  阅读(84)  评论(0)    收藏  举报