07 Java数组与数组操作（定义+遍历+排序+增删改查）（上）-阿里云开发者社区

07 数组

7.1 概念

数组在内存中是一块连续的空间，可以保存相同类型多个数据的容器

7.1.1 数组的特点

数组中保存数据必须是相同的数据类型

数组是定长的(数组一旦定义不能改变长度)

7.2 数组的创建

public class Demo {
    public static void main(String[] args) {
        //1 数组的声明
        //方式1,推荐
        //int age;
        int[] nums1;
        double[] scores;
        String[] names;
        //方式2
        int nums2[];
        //2 数组的初始化
        //2.1 静态初始化
        //初始化时由程序员指定每个数组元素的初始值，由系统计算数组长度。
        nums1=new int[]{10,15,12,5,8};
        scores=new double[]{99.5,80.5,92.5};
        names=new String[]{"面向对象","数组","方法","大恐龙","小洋葱"};
        int[] nums3=new int[]{100,200,300,400,500};
        //静态初始化简写方式,必须是一条语句完成
        int[] nums4={22,18,19,25,32};
 
        //2.2 动态初始化
        //初始化时只指定数组长度【大于等于0整数】，由系统为数组元素分配默认值。
        int[] nums5=new int[5]; // byte short int long  默认值0
        double[] score2=new double[100];  // float double 默认值 0.0
        char[] cs=new char[5]; //char 默认值 '\u0000'
        boolean[] bs=new boolean[5]; //boolean 默认值 false
        String[] cities=new String[10]; // String 引用类型的默认值都是null
 
        //注意：静态初始化和动态初始化不能同时使用
        int[] arr=new int[]{20,22,18,15,32};
 
    }
}

7.2.1 动态初始化

语法1: 数据类型[] 数组名 = new 数据类型[长度];

语法2: 数据类型数组名[] = new 数据类型[长度];

int[] arr = new int[3];

//存数据
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;

//取数据
System.out.println("第二个元素为："+arr[1]);
System.out.println("第三个元素为："+arr[2]);

//获取数据的长度
System.out.println(arr.length);

//错误：数组下标越界
System.out.println(arr[3]);

7.2.2 静态初始化

语法1：数据类型[] 数组名 = {数据1,数据2,…};

语法2：数据类型数组名[] = {数据1,数据2,…};

语法3：数据类型[] 数组名 = new 数据类型[]{数据1,数据2,…};

String[] names = new String[]{"张三","李四","王五","赵六"};
// [Ljava.lang.String;@15db9742      如果直接打印数组，输出的是内存地址
// System.out.println(names);

//操作数组

//存数据
names[0] = "cxk";
names[1] = "尼古拉斯";

//取数据
System.out.println("第二个元素"+names[1]);
System.out.println("第四个元素"+names[3]);

//获取数组的长度
System.out.println("数组的长度："+names.length);

7.2.3 数组的细节

数组中的每一个数据称之为数组元素
数组中的每一个元素都对应有一个下标
数组中的下标范围0~数组的长度-1
数组的长度通过数组名.length获取
数组的长度如果超出的边界会报错（ArrayIndexOutOfBoundsException数组下标越界异常）

7.3 数组的遍历

遍历：获取、保存数据中每一个元素(循环)

//定义一个数组
int[] arr1 = {10,9,17,18,22,34};

//遍历输出数组中的元素
for(int i = 0; i < arr1.length; i++) {
    //arr1[i]表示数组中的每一个元素
    System.out.println(arr1[i]);
}
System.out.println("=============给数组的元素赋值====================");
Scanner sc = new Scanner(System.in);

int[] arr2 = new int[4];
//遍历数组给数组中的元素赋值
for (int i = 0; i < arr2.length; i++) {
    System.out.println("请输入第"+(i+1)+"个元素");
    arr2[i] = sc.nextInt();
}

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

完整示例：

public class Demo {
    public static void main(String[] args) {
        //数组的遍历
        int[] nums=new int[]{20,18,22,15,28};
        double[] scores=new double[]{99,98,100,95,90};
        //使用for循环
        for (int i = 0; i < nums.length; i++) {
            System.out.println(i+"\t"+nums[i]);
        }
        System.out.println("----------------");
        for (int i = 0; i < scores.length; i++) {
            System.out.println(i+"\t"+scores[i]);
        }
        System.out.println("JDK1.5可以使用增强for遍历数组");
        for(int n : nums){ // n 数组中每个元素
            System.out.println(n);
        }
        System.out.println("-------------");
        for(double n : scores){
            System.out.println(n);
        }
        //增强for模板 数组.iter
        for (int num : nums) {
 
        }
        for (double score : scores) {
 
        }
    }
}

增强for模板数组.iter

练习

import java.util.Scanner;
 
/**
 * @author wgy
 * @version 1.0
 * @date 2023/1/6 14:23
 * @poject day09
 */
public class Demo {
    public static void main(String[] args) {
        //printAvg();
        //show();
        printCity();
    }
    //1 给定一个整型数组，统计数组中所有元素的平均值。
    public static void printAvg(){
        int[] nums=new int[]{90,95,92,100,93,80,85,86,78,75};
        //遍历数组   数组名.fori   数组名.iter
        int sum=0;
//        for (int i = 0; i < nums.length; i++) {
//            sum+=nums[i];//求和
//        }
        for (int n : nums) {
            sum+=n;
        }
        double avg=(double)sum/nums.length;
//        System.out.println("平均数："+avg);
        System.out.printf("%.2f",avg);
    }
 
    //2 给定一个整型数组，输入一个整数n，如果n在数组中存在，输出下标，不存在则输出-1。
    public static void show(){
        int[] nums={10,8,5,6,12,15,5,20,5,22};
        Scanner input=new Scanner(System.in);
        System.out.println("请输入一个数字");
        int n=input.nextInt();
        //遍历
        boolean flag=false;
        for (int i = 0; i < nums.length; i++) {
            if(n==nums[i]){
                flag=true;
                System.out.println("下标是:"+i);
            }
        }
        if(!flag){
            System.out.println(-1);
        }
    }
 
    //3 控制台输入5个城市的名称，使用数组保存，并遍历输出。
    public static void printCity(){
        //创建数组
        String[] cities=new String[5];
        Scanner input=new Scanner(System.in);
        //给数组的元素赋值
        for (int i = 0; i < cities.length; i++) {
            System.out.println("请输入第"+(i+1)+"个城市");
            String c=input.next();
            //把c 放入数组中
            cities[i]=c;
        }
        System.out.println("---------遍历------------");
        for (String city : cities) {
            System.out.println(city);
        }
    }
}

7.4 数组的默认值

整数型数组默认值：0

浮点型数组默认值：0.0

布尔类型数组默认值：false
字符型数组默认值：0 或者’ '或者 ‘\u0000’

引用类型数组默认值：null

null是一种特殊的值，表示当前对象在内存中没有指向任何地址。

""表示空字符串，在内存中有对应的内存地址

7.5 数组的应用

案例：

从键盘录入五个名字到数组中，遍历数组输出这五个名字
给定一个数组，求数组的最大值
给定一个数组，求数组的最小值
给定一个数组，求数组的平均值
给定一个数组，传入一个数字，如果在数组中存在这个数字，输出这个数字在数组中的下标，否则输出-1

public class Demo { 
  public static void main(String[] args) {
    String[] names = makeNames();
    for (int i = 0; i < names.length; i++) {
      System.out.println(names[i]);
    }
  } 
  //1、从键盘录入五个名字到数组中，遍历数组输出这五个名字
  public static String[] makeNames() {
    Scanner sc = new Scanner(System.in);
    String[] names = new String[5];
    for (int i = 0; i < names.length; i++) {
      System.out.println("请输入第"+(i+1)+"个人的名字");
      names[i] = sc.next();
    }
    return names;
  }
}

public class Demo {
  public static void main(String[] args) {
    int[] arr = {2,3,4,5,6,6,22,33};
    System.out.println(max(arr));
    System.out.println(min(arr));
    System.out.println(avg(arr));
  }
  //2、给定一个数组，求数组的最大值
  public static int max(int[] arr) {
    //假设一个最大值
    int max = arr[0];
    //遍历数组
    for (int i = 0; i < arr.length; i++) {
      if(max < arr[i]) {
        max = arr[i];
      }
    }
    return max;
  }
  //3、给定一个数组，求数组的最小值
  public static int min(int[] arr) {
    //假设一个最小值
    int min = arr[0];
    //遍历数组
    for (int i = 0; i < arr.length; i++) {
      if(min > arr[i]) {
        min = arr[i];
      }
    }
    return min;
  }
  //4、给定一个数组，求数组的平均值
  public static double avg(int[] arr) {
    double sum = 0;
    for (int i = 0; i < arr.length; i++) {
      sum = sum + arr[i];
    }
    return sum/arr.length;
  } 
}

public class Demo {
  public static void main(String[] args) {
    int[] arr = {2,3,4,5,6,6,22,33};
    System.out.println(getIndex(arr, 6));
  }
  //5、给定一个数组，传入一个数字，如果在数组中存在这个数字，输出这个数字在数组中的下标，否则输出-1
  public static int getIndex(int[] arr,int num) {
    for (int i = 0; i < arr.length; i++) {
      if(num == arr[i]) {
        return i;
      }
    }
    return -1;
  }
}

7.6 数组的扩容

7.6.1 数组扩容和缩容

数组的扩容和缩容

步骤1：定义一个新数组，然后新数组的长度比原数组增加或者是减小

步骤2：将原来数组的元素拷贝到新数组中

步骤3：将原数组的变量指向新数组

数组扩容示例

//定义原数组
int[] arr1 = {1,3,46,22,11};

//1、定义新数组   扩容
int[] arr2 = new int[arr1.length+1];

//将原来数组的元素拷贝到新数组中
//arr2[i] = arr1[i]

//2、数组的拷贝
for (int i = 0; i < arr1.length; i++) {
    arr2[i] = arr1[i];
}

//3、将原数组的变量指向新数组
arr1 = arr2;

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

数组缩容

//定义原数组
int[] arr1 = {1,3,46,22,11};

//1、定义新数组
int[] arr2 = new int[arr1.length-1];

//2、数组拷贝
for (int i = 0; i < arr2.length; i++) {
    arr2[i] = arr1[i];
}

//3、将原数组的变量指向新数组
arr1 = arr2;

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

7.6.2 数组拷贝

数组的拷贝有三种方式：

通过自定义循环将原数组中的元素拷贝到新数组中

System类提供数组拷贝方法

Arrays类提供数组拷贝方法

//1、System类提供数组拷贝方法
int[] arr1 = {1,3,46,22,11};

//定义目标数组
int[] arr2 = new int[arr1.length + 5];

/**
* src:原数组
* srcPos：原数组的起始位置
* dest：目标数组
* destPos：目标数组的起始位置
* length：拷贝的长度
*/
System.arraycopy(arr1, 1, arr2, 3, 4);

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

使用Arrays工具类

//2、Arrays类提供数组拷贝方法
int[] arr1 = {1,3,46,22,11};

/**
 * original：原数组
 * newLength：新数组的长度
 * 返回值：返回新数组 
 */

arr1 = Arrays.copyOf(arr1, arr1.length+1);
for (int i = 0; i < arr1.length; i++) {
    System.out.print(arr1[i]+"\t");
}

7.7 数组排序

7.7.1 冒泡排序

冒泡排序升序思想：

1、将相邻的两个元素进行比较，如果前面一个元素比后面的大，就交换位置(一轮比较)

2、将上面的操作循环（比较n-1轮）

冒泡排序原理分析

//冒泡排序关系
public class newArray {
    public static void main(String[] args) {
        int[] nums = {10,5,12,6,8,3};
        bubbleSort(nums);

    }
    public static void bubbleSort(int[] arr){
        //内层循环 控制比较的次数
        for (int i = 0; i < arr.length-1; i++) {
            System.out.print("第"+i+"轮\t\t");
            //内层循环 控制比较的次数
            for (int j = 0; j <arr.length-1-i ; j++) {
                System.out.print("第"+j+"次\t");
            }
            System.out.println();
        }
    }
}
//第0轮   第0次 第1次 第2次 第3次 第4次 
//第1轮   第0次 第1次 第2次 第3次 
//第2轮   第0次 第1次 第2次 
//第3轮   第0次 第1次 
//第4轮   第0次

总结

public class newArray {
    public static void main(String[] args) {
        int[] nums={10,5,12,8,6};
        selectSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+"\t");
        }
    }
    //冒泡排序 口诀：N个数字来排列，两两比较小de靠前，外层循环n-1 ,内层循环n-1-i
    public static void bubbleSort(int[] arr){
        //外层循环控制轮数
        for (int i = 0; i < arr.length-1; i++) {
            //内层循环 控制比较的次数
            for (int j = 0; j < arr.length-1-i; j++) {
                // j和j+1 交换
                if(arr[j]>arr[j+1]) {    //arr[j]<arr[j+1] 从大到小
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
    }
}

冒泡排序基本实现与优化

//基本实现
public static int[] sort1(int[] arr) {
    for (int j = 0; j < arr.length; j++) {
        for (int i = 0; i < arr.length - 1; i++) {
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
    }
    return arr;
}

优化1：次数优化

public static int[] sort2(int[] arr) {
    for (int j = 0; j < arr.length; j++) {   //轮数
        for (int i = 0; i < arr.length - 1 - j; i++) {//每一轮的次数
            if(arr[i] > arr[i+1]) {
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
    }
    return arr;
}

优化2：轮数优化

public static int[] sort3(int[] arr) {
    for (int j = 0; j < arr.length - 1; j++) { //轮数
        //假设这一轮已经拍好序了
        boolean flag = true;
        for (int i = 0; i < arr.length - 1 - j; i++) {//每一轮次数
            if(arr[i] > arr[i+1]) {
                flag = false;
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        if(flag) {
            break;
        }
    }
    return arr;
}

07 Java数组与数组操作（定义+遍历+排序+增删改查）（下）：https://developer.aliyun.com/article/1580202

07 Java数组与数组操作（定义+遍历+排序+增删改查）（上）

07 数组

7.1 概念

7.1.1 数组的特点

7.2 数组的创建

7.2.1 动态初始化

7.2.2 静态初始化

7.2.3 数组的细节

7.3 数组的遍历

7.4 数组的默认值

7.5 数组的应用

7.6 数组的扩容

7.6.1 数组扩容和缩容

7.6.2 数组拷贝

7.7 数组排序

7.7.1 冒泡排序

冒泡排序原理分析

冒泡排序基本实现与优化

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

07 Java数组与数组操作（定义+遍历+排序+增删改查）（上）

07 数组

7.1 概念

7.1.1 数组的特点

7.2 数组的创建

7.2.1 动态初始化

7.2.2 静态初始化

7.2.3 数组的细节

7.3 数组的遍历

7.4 数组的默认值

7.5 数组的应用

7.6 数组的扩容

7.6.1 数组扩容和缩容

7.6.2 数组拷贝

7.7 数组排序

7.7.1 冒泡排序

冒泡排序原理分析

冒泡排序基本实现与优化

热门文章

最新文章

相关课程

相关电子书

相关实验场景