基础不牢，地动山摇，20分钟拿下数组

举报
周棋洛 发表于 2022/05/25 23:17:32 2022/05/25
【摘要】 Java SE学习总结，第二部分，快来 get/set 吧 BiuBiu 🟢🔴🟡 文章目录 数组动态初始化1（直接声明和分配）动态初始化2（先声明再分配）静态初始化数组细节(⭐⭐⭐...

Java SE学习总结，第二部分，快来 get/set 吧 BiuBiu 🟢🔴🟡

在这里插入图片描述

文章目录

数组

引出数组
假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？
在这里插入图片描述

传统方法：

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/14:02
 */
public class demo21 {
    public static void main(String[] args) {
        //假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？
        int a = 112;
        int b = 122;
        int c = 212;
        int d = 212;
        int e = 312;
        int f = 142;
        System.out.println("总重量是："+(a+b+c+d+e+f)+"kg");
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    •

结果：总重量是：1112kg

思考：我们发现6只佩奇都是int类型的，而我们却要定义6个变量，有没有更好的处理方案呢–》引入数组

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

使用数组解决上面需求：

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/14:02
 */
public class demo21 {
    public static void main(String[] args) {
        //假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？
        int[] pig = {112,122,212,212,312,142};
        int sum = 0;
        for (int i = 0; i < pig.length; i++) {
            sum += pig[i];
        }
        System.out.println("总重量是："+sum+"kg");
    }
}


  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    •

动态初始化1（直接声明和分配）

在这里插入图片描述

数组的定义

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

int[] a = new int[5];

创建了一个数组，名字为a，存放5个int类型大小

数组的使用

数组名[下标名/索引/index]

访问数组a的第3个元素 a[2];

数组下标是从0开始计数的

import java.util.Scanner;

public class xunhuan {
    public static void main(String[] args) {
        //创建数组，double，大小5
        double[] scores = new double[5];
        //循环输入
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第"+(i+1)+"个数据的值");
            Scanner scanner = new Scanner(System.in);
            scores[i] = Double.parseDouble(scanner.nextLine());
        }
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum+=scores[i];
        }
        System.out.println("综合为："+sum+"    平均分是:"+sum/5);
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    •

动态初始化2（先声明再分配）

先声明数组

语法：数据类型[] 数组名； 或 数据类型 数组名[];

举例：int a[]; 或 int[] a;

创建数组

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

举例：a = new int[10];

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

  
 
    
  
  • 1
    • 
  
  • 2
    •

静态初始化

语法：数据类型 数组名[] = {元素值，元素值1，……};

举例：int a[] = {1,2,5,6,9,0};

如果知道数组有多少元素，具体的值就可以使用静态初始化

相当于：int a[] = new int[6];

a[0] = 1;

a[1] = 2;

a[2] = 5;

a[3] = 6;

a[4] = 9;

a[5] = 0;

数组细节(⭐⭐⭐)

  • 数组是多种相同类型数据的组合，实现对这些数据的统一管理
  • 数组中的元素可以创建任意的数据类型，包括基本类型和引用类型，但是不能混合使用
  • 数组创建后，如果没有赋值，有默认值，int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000, boolean flase,String null
  • 使用数组的步骤，1，声明数组并开辟空间 2，给数组各元素赋值 3，使用
  • 数组下标是从0开始的
  • 数组下标必须在指定的范围内使用。否则就会出现 数组下标越界的异常
  • 数组属于引用类型。数据类型是对象（object）

数组赋值机制(⭐⭐⭐)

在这里插入图片描述

基本数据类型赋值，值传递

public class demo14 {
    public static void main(String[] args) {
        int n1 = 10;
        int n2 = n1;
        
        n2 = 80;
        System.out.println("n1="+n1);
        System.out.println("n2="+n2);
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    •

值拷贝,n2不会影响n1

结果：

n1=10
n2=80

引用类型赋值传递的是地址

引用传递，是一个地址

public class demo14 {
    public static void main(String[] args) {

        int[] arr1 = {1,2,3};
        int[] arr2 = arr1;//把arr1赋值给arr2
        arr2[0] = 10;
        System.out.println(arr1[0]);
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    •

这里改变的是arr2的值，发现arr1的值也被改变
输出：10

打印数组最大值的下标

重点学习下标的获取，学会随着需求的驱动去定义变量，从而解决问题，体现在int maxIndex = 0; //记录下标

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/14:02
 */
public class demo21 {
    public static void main(String[] args) {
        //找出数组最大值的下标，并打印出来
        int[] arr = {1, 345, 45, 800, 666};
        int max = arr[0];//假定第一个元素是最大值
        int maxIndex = 0; //记录下标
        for (int i = 1; i < arr.length; i++) {//从下标 1 开始遍历 arr
            if (max < arr[i]) {//如果 max < 当前元素
                max = arr[i]; //把 max 设置成 当前元素
                maxIndex = i;
            }
        }
        System.out.println("最大值的下标为：" + maxIndex);
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    •

数组拷贝

在这里插入图片描述
编写代码 实现数组拷贝(内容复制)

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/15:28
 */
public class demo22 {
    //编写代码 实现数组拷贝(内容复制)
    public static void main(String[] args) {
        int arr1[] = {1,2,3,4,5};//原数组
        int arr2[] = new int[arr1.length];//新数组，赋值后的数组，长度为 arr1.length
        //这时的arr2数组，里有默认值0，通过循环把arr1中的每个元素赋值给arr2，即完成复制
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        //输出两个数组
        System.out.println("arr1====复制====arr2\n");
        for (int i = 0; i < arr1.length; i++) {
            System.out.print("arr1: "+arr1[i]+"\t\t");
            System.out.println("arr2: "+arr2[i]);
        }
        //改变arr1中元素的值，再输出
        System.out.println("\narr1====改变arr1后======arr2\n");
        arr1[2] = 100;
        for (int i = 0; i < arr1.length; i++) {
            System.out.print("arr1:  "+arr1[i]+"\t\t");
            System.out.println("arr2:  "+arr2[i]);
        }
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    • 
  
  • 24
    • 
  
  • 25
    • 
  
  • 26
    • 
  
  • 27
    • 
  
  • 28
    • 
  
  • 29
    •

数组反转

方案1：

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/16:28
 */
public class demo23 {
    //要求：把数组的元素内容反转
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5};
        int temp = 0;
        int len = arr.length;
        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.print(arr[i]);
        }
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    •

方案2：逆序赋值(⭐⭐⭐)

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/17:32
 */
public class demo24 {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[arr1.length];
        for (int i = arr1.length - 1, j = 0; i >= 0; i--, j++) {
            arr2[j] = arr1[i];
        }
        System.out.println("前arr1："+arr1.hashCode());
        System.out.println("前arr2："+arr2.hashCode());
        arr1 = arr2;
        System.out.println("后arr1："+arr1.hashCode());
        System.out.println("后arr2："+arr2.hashCode());
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr1[i]);
        }
    }
}


  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    •

输出：

前arr1：22307196
前arr2：10568834
后arr1：10568834
后arr2：10568834
5
4
3
2
1

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    •

数组添加/扩容

定义一个新数组，遍历原数组把原数组拷贝给新数组，处理新元素，将新数组的地址指向旧数组，即完成数组的扩容
在这里插入图片描述

import java.util.Scanner;

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/17:56
 */
public class demo25 {
    //数组扩容
    public static void main(String[] args) {
        String[] arr = {"唐三", "小舞", "唐浩", "阿银"};
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        do {
            System.out.print("输入要添加的名字：");
            String name = scanner.next();
            String[] strings = new String[arr.length + 1];
            for (int i = 0; i < arr.length; i++) {
                strings[i] = arr[i];
                strings[strings.length - 1] = name;
            }
            arr = strings;
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
            System.out.println("输入n退出");
            String k = scanner.next();
            if (k.equals("n")) {
                loop = false;
            }
        } while (loop);
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    • 
  
  • 24
    • 
  
  • 25
    • 
  
  • 26
    • 
  
  • 27
    • 
  
  • 28
    • 
  
  • 29
    • 
  
  • 30
    • 
  
  • 31
    • 
  
  • 32
    • 
  
  • 33
    •

冒泡排序

在这里插入图片描述
外层循环决定多少轮，一轮确定一个最大值或最小值，内层循环实现比较和调换

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/20:30
 */
public class demo26 {
    //冒泡排序
    public static void main(String[] args) {
        int[] arr = {23, 45, 11, 22, 89, 0, 76, 81};
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            System.out.print("  " + arr[i]);
        }
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] < arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("\n============冒泡排序后============");
        for (int i = 0; i < arr.length; i++) {
            System.out.print("  " + arr[i]);
        }
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    • 
  
  • 24
    • 
  
  • 25
    • 
  
  • 26
    • 
  
  • 27
    • 
  
  • 28
    •

顺序查找(⭐⭐⭐)

在这里插入图片描述

在 java 中，我们常用的查找有两：

  1. 顺序查找
  2. 二分查找

有一个数列，从键盘中任意输入一个名称，判断数列中是否包含此名称，要求: 如果找到了，就提示找到，并给出下标值。没有找到，提示

注意：这里的判断处理，技巧你 get 了吗？

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/20:59
 */
public class demo27 {
    //有一个数列,从键盘中任意输入一个名称,判断数列中是否包含此名称
    // 要求: 如果找到了，就提示找到，并给出下标值。没找到，提示
    public static void main(String[] args) {
        String name[] = {"小张","狗蛋","李白","王昭君","苏妲己","西施"};
        int index = -2;
        Scanner scanner = new Scanner(System.in);
        System.out.print("搜索：");
        String sName = scanner.next();
        for (int i = 0; i < name.length; i++) {
            if(sName.equals(name[i])){
                index = i;
                System.out.println("下标为："+i+"  "+name[i]);
                break;
            }
        }
        if(index == -2){
            System.out.println("没找到");
        }
    }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    • 
  
  • 24
    • 
  
  • 25
    • 
  
  • 26
    •

二维数组

就是套娃，数组的元素又是一个数组

用二维数组输出如下图形
1 0 0 0 0 0
0 2 0 0 0 0
0 2 3 0 0 0
0 0 0 4 0 0


  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
 
/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/21:27
 */
public class demo28 {
    public static void main(String[] args) {
        //二维数组定义
        int[][] arr = {
                {1, 0, 0, 0, 0, 0},
                {0, 2, 0, 0, 0, 0},
                {0, 2, 3, 0, 0, 0},
                {0, 0, 0, 4, 0, 0}};

        int[][] arr1 = new int[4][5];
        arr1[0][0] = 1;
        arr1[1][1] = 2;

        //二维数组打印
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("===============");
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j]+" ");
            }
            System.out.println();
        }
    }
}


  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    • 
  
  • 24
    • 
  
  • 25
    • 
  
  • 26
    • 
  
  • 27
    • 
  
  • 28
    • 
  
  • 29
    • 
  
  • 30
    • 
  
  • 31
    • 
  
  • 32
    • 
  
  • 33
    • 
  
  • 34
    • 
  
  • 35
    •

运行：

1 0 0 0 0 0 
0 2 0 0 0 0 
0 2 3 0 0 0 
0 0 0 4 0 0 
===============
1 0 0 0 0 
0 2 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    •

动态初始化

1) 语法: 类型[][] 数组名=new 类型[大小][大小]
2) 例子: int a[][]=new int[2][3]

  
 
    
  
  • 1
    • 
  
  • 2
    •

在这里插入图片描述

先声明：类型 数组名[][]; 
再定义(开辟空间) 数组名 = new 类型[大小][大小]
赋值(有默认值，比如 int 类型的就是 0

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    •

静态初始化

定义 类型 数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}}
使用即固定方式访问 

  
 
    
  
  • 1
    • 
  
  • 2
    •

细节

  1. 一维数组的声明方式有:int[] x 或者 int x[]
  2. 二维数组的声明方式有:int[][] y 或者 int[] y[] 或者 int y[][]
  3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如： map[][] 是一个二维数组int map [][] = {{1,2},{3,4,5}}由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，也称为列数不等的二维数组

在这里插入图片描述

文章来源: blog.csdn.net，作者：周棋洛ყ ᥱ ᥉，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/m0_53321320/article/details/120032235

【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
数据结构
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入