7、数组知识点汇总

一、数组基本概念

程序=算法+数据结构

算法：解决程序的流程步骤
数据结构：将数据按照某种特定的结构来存储
设计良好的数据结构会导致良好的算法。
ArrayList、LinkedList

数组是最简单的数据结构。

1、数组：

数组：存放同一种类型数据的集合，在内存里面是开辟一块连续的区域。

int num = 3;
int[]  array = new int[4];

1、存放整数类型的数组
2、长度是4 （数组缺点长度固定，ArrayList解决长度固定的问题）
3、只能存放int类型

2、数组的访问：数组名[下标]

在这里插入图片描述

元素类型[] 数组名 = new 元素类型[长度];

int[] array1 = new int[3];
double[] array2 = new double[3];
boolean[] array3 = new boolean[3];
char[] array4 = new char[3];
// Student[] array5 = new Student[3];

3、数组定义的方式：

静态初始化：在声明数组的同时，直接给出数组元素的初始值。适用于数组元素已知的情况。

int[] array = {32,5,7,87};
int[] array = new int[]{32,5,7,87};

动态初始化：在声明数组时，仅指定数组的长度，然后通过赋值语句逐个给数组元素赋值。适用于数组元素在声明时未知的情况。

int[] array = new int[4];
array[0] = 34;
@Test
public void test1() {
    int num = 3;
    int score1 = 84;
    int score2 = 54;
    int score3 = 64;
    //数组：存放同一种类型数据的集合，在内存里面是开辟一块连续的区域。
    int[] array = new int[4];
    System.out.println("length: " + array.length);//4
    array[0] = 33;
    array[1] = 2;
    array[2] = 45;
    array[3] = 19;
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
    System.out.println("-------------");
    for (int i = array.length - 1; i >= 0; i--) {
        System.out.println(array[i]);
    }

}

二、数组下标越界异常

java.lang.Array Index OutOf Bounds Exception: 4
数组下标越界异常

@Test
public void test45() {
    int[] array = new int[4];
    array[0] = 33;
    array[1] = 2;
    array[2] = 45;
    array[3] = 19;
    for (int i = 0; i <= array.length; i++) {
        //java.lang.ArrayIndexOutOfBoundsException: 4
        System.out.println(array[i]);
    }
}

三、数组累加和、最大值、最小值、冒泡排序

数组最重要操作就是遍历。

只要能遍历所有元素就可以求最大值、最小值、对数组排序

1、数组累加和

@Test
public void test189() {
    int[] array = new int[4];
    array[0] = 33;
    array[1] = 2;
    array[2] = 45;
    array[3] = 19;
    //array.fori   fori
    int sum = 0;
    for (int i = 0; i < array.length; i++) {
        sum = sum + array[i];
    }
    System.out.println("sum: " + sum);
}

2、最大值、最小值

//数组最重要操作就是遍历。
//只要能遍历所有元素：求最大值、最小值、排序。
@Test
public void test23(){
    int[] array = {23, 45, 67, 2, 12};
    int max = array[0];
    for (int i = 0; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    System.out.println("max: " + max);
}

@Test
public void test333() {
    int[] array = {23, 45, 67, 2, 12};
    int maxValue = getMax(array);
    System.out.println(maxValue);
}

//参数，形参
/**
 * 返回数组的最大值
 * @param array 传递过来的数组
 * @return 数组最大值
 */
public int getMax(int[] array) {
    int max = array[0];
    for (int i = 0; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    return max;
}

@Test
public void test24(){
    int[] array = {23, 45, 67, 2, 12};
    int min = array[0];
    for (int i = 0; i < array.length; i++) {
        if (array[i] < min) {
            min = array[i];
        }
    }
    System.out.println("min: " + min);
}

3、数组的排序：冒泡排序

int[] array = {40, 17, 21, 1}; // 1, 17,21,40
第一轮：40冒到最右边
17,40,21,1
17,21,40,1
17,21,1,40   -------   40 冒出来
第二轮：21冒出来
17,21,1,40
17,1,21,40  -------   21冒出来
第三轮：17冒出来
1,17,21,40  ------- 17冒出来

public void sort(int[] array) {
}

4个数只要比较3轮就可以，剩下那个数不要要排序就是最小的
第一轮：比较3次
第二轮：比较2次
第三轮：比较1次
i+j =4=array.length
j=array.length-i

@Test
public void test22() {
    //i=1   j=
    int[] array = {40, 17, 21, 1}; // 1, 17,21,40
    sort(array);
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
}

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

四、数组复制

1、System.arraycopy

这是标准且高效的方法，适用于复制数组的部分或全部。

int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(source, 0, dest, 0, source.length);

//数组.fori
/*for (int i = 0; i < dest.length; i++) {
    System.out.println(dest[i]);
}*/
//增强的for循环  数组.for
for (int num : dest) {
    System.out.print(num + " ");
}

参数说明：

1.source：源数组
2.0：源数组的起始位置
3.dest：目标数组
4.0：目标数组的起始位置
5.source.length：复制的元素个数

2、使用 Arrays.copyOf 方法

适合复制整个数组或调整大小时使用。

import java.util.Arrays;

int[] source = {1, 2, 3, 4, 5};
int[] copiedArray = Arrays.copyOf(source, source.length); // 复制整个数组

for (int num : copiedArray) {
    System.out.print(num + " ");
}

可以调整目标数组的大小：

int[] array = Arrays.copyOf(source, 10); // 创建长度为 10 的数组

3、使用 Arrays.copyOfRange 方法

复制数组的指定范围。

import java.util.Arrays;

int[] source = {1, 2, 3, 4, 5};
int[] array = Arrays.copyOfRange(source, 1, 4); // 复制索引 1 到 3 的元素

for (int num : array) {
    System.out.print(num + " ");
}

4、使用 clone 方法

适用于简单复制整个一维数组。

int[] source = {1, 2, 3, 4, 5};
int[] array = source.clone();

for (int num : array) {
    System.out.print(num + " ");
}

5、手动遍历赋值

当需要自定义复制逻辑时使用。

int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[source.length];

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

for (int num : dest) {
    System.out.print(num + " ");
}

6、对比

在这里插入图片描述

五、二维数组(了解）

二维数组里面又是个一位数组

Java数组支持规则数组和不规则数组：

在这里插入图片描述

1、二维数组的创建和初始化：

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

从最高维开始，分别为每一维分配空间：
int[][] array = new int[3][];
array[0] = new int[2];
array[1] = new int[2];
array[2] = new int[3];
array[0][0] = 1;
array[1][1] = 3;

在这里插入图片描述

两行互换：

int[] temp = array[0];
array[0] = array[1];
array[1] = temp;

直接为每一维分配空间：

int[][] array = new int[2][3];

在这里插入图片描述

@Test
public void test222() {
    int[][] array = new int[3][];
    array[0] = new int[2];
    array[1] = new int[2];
    array[2] = new int[3];
    array[0][0] = 23;
    array[0][1] = 12;
    array[1][0] = 22;
    array[1][1] = 22;
    array[2][0] = 21;
    array[2][1] = 22;
    array[2][2] = 23;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }
    }
}

六、作业

1、int[] scores={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};

求出上面数组中0-9分别出现的次数

@Test
public void test2() {
    int[] scores={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};
    int count0 = 0;
    int count1 = 0;
    int count2 = 0;
    int count3 = 0;
    for (int i = 0; i < scores.length; i++) {
        switch (scores[i]) {
            case 0:
                count0++;
                break;
            case 1:
                count1++;
                break;
            case 2:
                count2++;
                break;
            case 3:
                count3++;
                break;
        }
    }

    System.out.println("0出现"+count0+"次");
    System.out.println("1出现"+count1+"次");
    System.out.println("2出现"+count2+"次");
    System.out.println("3出现"+count3+"次");
}

@Test
public void test3() {
    int[] scores={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};
    int[] counts = new int[10];
    //int count0 = 0;  counts[0]
    //int count1 = 0;  counts[1]
    //int count2 = 0;  counts[2]
    //int count3 = 0;  counts[3]
    for (int i = 0; i < scores.length; i++) {
        counts[scores[i]]++;
    }

    //增强的for循环
    /*for (int count : counts) {
        System.out.println("1出现的3次");
    }*/
    for (int i = 0; i < counts.length; i++) {
        System.out.println(i + "出现的"+counts[i]+"次");
    }

}

2、int[] scores={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};

要求求出其中的奇数个数和偶数个数。

3、 0.6332的数据类型是（）

A float B double C Float D Double

4、 Java 中 main() 函数的返回值是什么 ?

A 、 String

B 、 int

C 、 char

D 、 void

5 、如下哪个字串在Java 中可作为自定义标识符？

A 、 $number

B 、 super

C 、 3number

D 、 #number

6 、下面的代码段中，执行之后 i 和 j 的值是什么 ?

int i = 1;

int j;

j = i++;

A 、 1, 1

B 、 1, 2

C 、 2, 1

D 、 2, 2

7 、下面哪个赋值语句不是合法的？

A 、 float a = 2.0

B 、 double b = 2.0

C 、 int c = 2

D 、 long d = 2

java中小数默认是double类型，整数的默认类型是int。
如果想把小数赋值给float类型，float f = 10.1f;

8 、下面哪个是 main() 函数的合法参数 ?

A 、 char args[]

B 、 char args[][]

C 、 String[] args

D 、 String args

argument

9 、已知表达式 int[] m = {0, 1, 2, 3, 4, 5, 6 };

下面哪个表达式的值与数组最大下标数相等？

A 、 m.length()

B 、 m.length-1

C 、 m.length()+1

D 、 m.length+1

10、在Java中，属于整数类型变量的是( )

A.single

B.double

C.byte

D.char

11．下列语句哪一个正确（）

A． Java程序经编译后会产生machine code

B． Java程序经编译后会产生byte code（字节码） .class

C． Java程序经编译后会产生DLL

D．以上都不正确

12、题目：一个任意一个字符串，判断它是不是回文。

“abcba”

char[] array = {‘a’ , ‘b’, ‘c’, ‘b’ , ‘a’};

在这里插入图片描述

i=0 j=array.length-1

i=1 j=array.length-2

i+j=array.length-1

j=array.length-i-1

array.length-i-1

public void test889() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入字符串： ");
        String str = scanner.next();
        //String str = "abcba";
        char[] array = str.toCharArray();
        //初始认为是回文，接下来遍历看能不能找到一个反例
        //最后遍历完了都没有找到反例，代表是回文
        //boolean flag = true;
        boolean isHuiWen = true;
        for (int i = 0; i < array.length / 2; i++) {
            if (array[i] != array[array.length - i - 1]) {
                isHuiWen = false;
                //找到一个反例，就证明一定不是回文，不需要再往后判断
                break;
            }
        }
        
         //初始认为是回文，遍历完了，没有找到任何一个反例，这个字符串就是回文
        if (isHuiWen) {
            System.out.println("是回文");
        } else {
            System.out.println("不是回文");
        }
    }

13、输入一行字符串，分别统计出其中英文字母、空格、数字和其它字符的个数。

@Test
    public void test78() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String str = scanner.nextLine();
        //"dsfhi 34**DSD [34"
        char[] array = str.toCharArray();
        int letterCount = 0;
        int spaceCount = 0;
        int digitCount = 0;
        int otherCount = 0;
        for (int i = 0; i < array.length; i++) {
            if ((array[i] >= 'A' && array[i] <= 'Z') || (array[i] >= 'a' && array[i] <= 'z')) {
                letterCount++;
            } else if (array[i] == ' ') {
                spaceCount++;
            } else if (array[i] >= '0' && array[i] <= '9') {
                digitCount++;
            } else {
                otherCount++;
            }
        }
        System.out.println("字母出现次数：" + letterCount);
        System.out.println("空格出现次数：" + spaceCount);
        System.out.println("数字出现次数：" + digitCount);
        System.out.println("其他出现次数：" + otherCount);
    }