2021-06-09 数组

最新推荐文章于 2023-01-25 20:37:21 发布

原创最新推荐文章于 2023-01-25 20:37:21 发布 · 502 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了Java中的数组，包括数组的动态初始化、静态初始化、使用注意事项和细节，以及数组的引用、赋值机制、拷贝、反转、添加、缩减和排序。还特别讲解了冒泡排序的实现原理。

数组介绍

数组可以存放多个同一类型的数据数组也是一种是数据类型是引用类型

即: 数组就是一组数据

double[] hens ={3,5,1,3.4,2,50}

double[] 表示是double类型的数组
数组名字hens
{}中表示数组的元素依次表示数组的第几个元素
遍历数组得到数组所有元素的和使用for
我们可以通过hens[下标] 来访问数组的元素
- 下标是从0开始编号的
通过for就可以循环的访问数组的元素/值
使用一个变量totalWeight将哥哥元素累计

        double[] hens={3,5,1,3.4,2,50};

        for (int i = 0; i < hens.length; i++) {
            System.out.println("第"+(i+1)+"个元素="+hens[i]);
        }

        double totalWeight=0;
        for (int i = 0; i < hens.length; i++) {
            totalWeight += hens[i];
        }
        System.out.println("总体重="+totalWeight);
        System.out.println("平均体重="+totalWeight/hens.length);

数组的使用

使用方式1-动态初始化

数组的定义

数据类型[] 数组名 =new 数据类型[大小]

int[] a = new int[5]; //创建了一个数组名字a 存放5个int

数组的引用(使用/访问/获取)

数组名[下标/索引/index] //比如你要使用a数组的第三个元素 a[2]

        double[] scores = new double[5];

        Scanner myScanner = new Scanner(System.in);

        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第"+(i+1)+"个元素的值");
            scores[i] = myScanner.nextDouble();
        }

        System.out.println("当前数组的元素有以下");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("第"+(i+1)+"个元素的值="+scores[i]);
        }

使用方式2-动态初始化

先声明数组

语法: 数据类型[] 数组名 ; 也可以数据类型数组名[]

int[] a; 或者 int a[];

创建数组

语法: 数组名 = new 数据类型[大小];

a= new int[10]

double scores[];    //声明数组 这时scores 是null
scores=new double[5];   //分配内存空间 可以存放数据

使用方式3-静态初始化

初始化数组

语法 : 数据类型数组名[] ={元素值,元素值…}

int a[]={2,5,6,7,8,89}

数组使用注意事项和细节

ArrayDetail.java

数组是多个相同类型数据的组合,实现对这些数据的同一管理
数组中的元素可以是任何数据类型,包括基本类型和引用类型,但是不能混用
数组创建后,如果没有赋值,有默认值

int 0
short 0
byte 0
long 0
float 0.0
double 0.0
char \u0000
boolean false
String null

使用数组的步骤

声明数组并开辟空间
给数组哥哥元素赋值
使用数组

数组的下标是从0开始的
数组下标必须在指定范围内使用否则报: 下标越界异常比如 int[] arr=new int[5] ; 则有效下标为0-4
数组属引用类型数组型数据对象是(object)

数组引用案例

/*
1 创建一个char类型的26个元素的数组 分别放置A-Z
  使用for循环访问所有元素并打印出来
  提示: char类型数据运算'A'+1 ->'b'
 */
public static void main(String[] args) {

    char arr[]= new char[26];

    for (int i = 0; i < arr.length; i++) {
        arr[i] = (char) ('A'+ i) ;  //'A'+1 是int 需要强转
    }

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

/*
请求出一个数组int[]的最大值{4,-1,9,10,23} 并得到对应的下标
 */
int arr[] = {4,-1,9,10,23};

int arrMax = arr[0] ;
int maxIndex = 0;

for (int i = 0; i < arr.length; i++) {
    if ( arr[i] > arrMax ) {
        arrMax = arr[i];
        maxIndex = i;
    }
}

System.out.println(arrMax);
System.out.println(maxIndex);

数组的赋值机制

基本数据类型赋值这个值就是具体的数据而且相互不影响

int n1 =2 ; int n2= n1;
数组在默认情况下是引用传递赋的值是地址

int[] arr1={1,2,3};

int[] arr2=arr1;

//基本数据类型赋值 赋值方式为值拷贝
//n2的变化 不会影响到n1的值
int n1=10;
int n2=n1;

n2=80;

System.out.println(n1); //10
System.out.println(n2); //80

//数组在默认情况下是引用传递 赋值是地址 赋值方式为引用赋值
//是一个地址 arr2变化会影响到 arr1
int[] arr1={1,2,3};
int[] arr2=arr1;    //把arr1赋给arr2

arr2[0]=10;

for (int i = 0; i < arr1.length; i++) {
    System.out.println(arr1[i]);         //10,2,3   
}

数组拷贝

//将 int[] arr1={10,20,30} 拷贝到arr2数组 要求数据空间是独立的

int[] arr1={10,20,30};

//创建一个新的 数组arr2 开辟新的数据空间

int[] arr2 = new int[arr1.length];

//遍历arr1 把每个元素拷贝到对应的位置

for (int i = 0; i < arr1.length; i++) {
    arr2[i] =arr1[i];
}

arr2[0]=100;

for (int i = 0; i < arr2.length; i++) {
    System.out.println(arr2[i]);    //100,20,30  arr1 10,20,30 不受影响
}

数组反转

//数组反转-不建新数组实现
int[] arr={11,22,33,44,55,66};
int len=arr.length;
int temp=0;

for (int i = 0; i < (len/2); i++) {
    temp=arr[len-1-i];
    arr[len-1-i] =arr[i];
    arr[i] = temp;
}

for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

//数组反转-新建数组
int[] arr1={11,22,33,44,55,66};

int[] arr2= new int[arr1.length];

for (int i = 0; i < arr1.length; i++) {
    arr2[(arr2.length-1)-i]=arr1[i];
}

for (int i = 0; i < arr2.length; i++) {
    System.out.println(arr2[i]);
}

数组添加

要求: 实现动态的给数组添加元素效果实现对数组扩容

原始数组使用静态分配 int[] arr ={1,2,3}
增加的元素直接放在数组的最后 arr={1,2,3,4}

        int[] arr={1,2,3};
        int[] arrNew=new int[arr.length+1];

        for (int i = 0; i < arr.length; i++) {
            arrNew[i]=arr[i];
        }

        arrNew[arrNew.length-1]=4;

        arr=arrNew;

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

Scanner myScanner = new Scanner(System.in);

int[] arr={1,2,3};

do{

    int[] arrNew=new int[arr.length+1];

    for (int i = 0; i < arr.length; i++) {
        arrNew[i]=arr[i];
    }

    System.out.println("添加的数字是多少");

    int addResult=myScanner.nextInt();

    arrNew[arrNew.length-1]= addResult;

    arr=arrNew;

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

    System.out.println("请问是否继续 y/n");

    char key= myScanner.next().charAt(0);

    if(key=='n'){
        break;
    }

}while (true);

System.out.println("退出循环");

数组缩减

Scanner myScanner = new Scanner(System.in);

int[] arr={1,2,3,4};

do{

    int[] arrNew=new int[arr.length-1];

    for (int i = 0; i < arrNew.length; i++) {
        arrNew[i]=arr[i];
    }

    arr=arrNew;

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

    if(arr.length==1){
        System.out.println("只剩最后一个元素");
        break;
    }

    System.out.println("是否继续缩减 y/n");
    String result= myScanner.next();


    if(result.equals("n")){
        break;
    }

}while (true);

System.out.println("退出");

排序的介绍

排序是将多个数据依指定的顺序进行排列的过程

排序的分类

内部排序

指将需要处理的所有数据都加载到内部存储器中进行排序包括(交换式排序法选择式排序法和插入式排序法)
外部排序法

数据量过大无法全部加载到内存中需要借助外部存储进行排序包括(合并排序法和直接合并排序法)

冒泡排序

通过对待排序序列从后向前(从下标较大的元素开始) 依次比较相邻元素的值若发现逆序则交换使值较大的元素逐渐从前移向后部就像水底下的气泡一样逐渐向上冒

int[] arr={24,69,80,57,13};

int temp=arr[0];

for(int j=0; j<arr.length-1;j++){
    for (int i = 0; i < arr.length-1-j; i++) {
        if(arr[i]>arr[i+1]){
            temp=arr[i];
            arr[i]=arr[i+1];
            arr[i+1]=temp;
        }
    }
}

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