Java—08—数组

数组定义

数组是一种数据结构，用于存储一组相同类型的数据元素，这些数据元素按照一定的顺序排列，并且可以通过一个公共的下标来访问和操作其中的元素。数组的定义通常包含以下几个要素：

1. 数据类型：数组中存储的数据元素的类型，可以是任何合法的数据类型，比如整型、字符型、浮点型等。

2. 数组名：数组的名称，用于标识数组，可以由字母、数字和下划线组成，但必须以字母或下划线开头。

3. 数组长度：数组中存储的元素的个数，通常用非负整数表示。

4. 元素类型：数组中每个元素的数据类型，和数组的数据类型相同。

数组的定义可以采用以下格式：

<数据类型> <数组名>[<数组长度>];

其中，方括号中的数字表示数组的长度，可以是字面量或变量。例如，定义一个包含10个整数的数组可以如下所示：

int nums[10];

这样就定义了一个名为nums的数组，它可以存储10个整数，每个元素的类型为int。数组中的元素可以通过下标来访问和操作，第一个元素的下标为0，最后一个元素的下标为n-1，其中n为数组长度。

数组的声明和创建

public class Demo01{
    public static void main(String[] args){
        int[] nums;//1.声明一个数组,操作在栈中
        nums = new int[10];//2.创建一个数组，操作在堆中
        //3.给数组元素赋值
        nums[0]  = 1;
        nums[1] = 2;
        //计算所有元素的和
        int sum =0;
        //获取数组长度：arrays.length
        for (int i = 0; i < nums.length; i++){
            sum = sum +nums[i];
        }
        System.out.println("总和"+sum);


        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5,6};
        System.out.println(a[0]);

        //动态初始化：包含默认初始化，在定义个数内初始化为0，超过数组长度报错
        int[] b = new int[10];
        b[0]=10;
        b[4]=17;

        System.out.println(b[0]);
        System.out.println(b[2]);

    }
}

数组的使用

public class Demo01{
   public static void main(String[] args){
       int[] arrays = {1,2,3,4,5};
       
       //打印全部的数组
       for (int i = 0; i < arrays.length; i++){
           System.out.println(arrays[i]);
       }
       System.out.println("============");
       //计算所有元素的和
       int sum =0;
       for( int i = 0; i< arrays.length;i++){
           sum += arrays[i];
       }
       System.out.println("总和"+sum);

       System.out.println("============");
       //查找最大元素
       int max = arrays[0];
       for (int i =0; i <arrays.length;i++){
           if(arrays[i] > max){
               max = arrays[i];
           }
       }
       System.out.println("最大值"+max);

       //JDK1.5以后遍历数组没有下标
       for(int array:arrays){
           System.out.println(array);
       }



   }
   //反转数组
   public static int[] reverse(int[] arrays){
       int[] result = new int[arrays.length];

       //反转的操作
       for(int i = 0,j=result.length-1; i <arrays.length; i++,j--){
           result[j] = arrays[i];
       }
       return result;

   }

}

多维数组

Java中的多维数组指的是数组中包含其他数组。Java中支持二维数组和三维数组。

二维数组

在Java中，我们可以使用如下语法声明和初始化一个二维数组：

int[][] arrayName = new int[rows][columns];

其中，rows 表示行数，columns 表示列数。例如：

int[][] myArray = new int[2][3];
myArray[0][0] = 1;
myArray[0][1] = 2;
myArray[0][2] = 3;
myArray[1][0] = 4;
myArray[1][1] = 5;
myArray[1][2] = 6;

我们也可以在声明时初始化数组，如下所示：

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

三维数组

在Java中，我们也可以声明和初始化一个三维数组：

int[][][] myArray = new int[x][y][z];

其中，x 表示第一维数组大小，y 表示第二维数组大小，z 表示第三维数组大小。例如：

int[][][] myArray = new int[2][3][2];
myArray[0][0][0] = 1;
myArray[0][0][1] = 2;
myArray[0][1][0] = 3;
myArray[0][1][1] = 4;
myArray[0][2][0] = 5;
myArray[0][2][1] = 6;
myArray[1][0][0] = 7;
myArray[1][0][1] = 8;
myArray[1][1][0] = 9;
myArray[1][1][1] = 10;
myArray[1][2][0] = 11;
myArray[1][2][1] = 12;

我们也可以在声明时初始化数组，如下所示：

int[][][] myArray = {{{1,2},{3,4},{5,6}},{{7,8},{9,10},{11,12}}};

冒泡排序

public class Demo01{
    public static void main(String[] args){
        int[] nums = {5, 3, 8, 4, 2};
        int temp = 0;

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

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

在这个例子中，使用一个嵌套的for循环来实现冒泡排序。第一个for循环用来控制排序的次数，第二个for循环用来比较相邻的两个元素并交换它们的位置。最后，我们再次遍历数组，按顺序输出排好序的元素。

这个例子中使用的是int类型的数组，但是冒泡排序同样适用于其他类型的数据。只需要将比较大小的方式修改为相应的比较方法即可。

稀疏数组

public class Demo01{
    public static void main(String[] args){
        //1.创建一个二维数组11*11    0:没有棋子  1:黑棋   2:白棋
        int[][] array1 = new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");

        for(int[] nits :array1){
            for(int a: nits){
                System.out.print( a +"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for(int i = 0; i<11;i++){
            for(int j=0;j<11;j++){
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }




        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非0的值，存放稀疏数组中
        int count =0;
        for(int i =0; i<array1.length; i++){
            for(int j=0; j<array1[i].length;j++){
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");

        for(int i = 0;i< array2.length;i++){
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }



        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原他的位置
        for(int i = 1;i< array2.length;i++){
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.打印
        System.out.println("输出还原的数据：");
        for (int[] ints : array3){
            for(int anoint : ints){
                System.out.print(anoint+"\t");
            }
            System.out.println( );
        }

    }
}

将文件批量移动到另一文件夹下

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class Demo01 {
    public static void main(String[] args) {
        // 指定目录和目标文件夹路径
        String directoryPath = "G:\\zjy\\MTFAP\\first\\R";
        String targetFolderPath = "G:\\zjy\\MTFAP\\first\\SVG";

        // 创建目标文件夹
        File targetFolder = new File(targetFolderPath);
        targetFolder.mkdirs();

        // 遍历目录下的文件夹
        File directory = new File(directoryPath);
        File[] subDirectories = directory.listFiles(File::isDirectory);
        if (subDirectories != null) {
            for (File subDirectory : subDirectories) {
                // 遍历文件夹中的文件
                File[] files = subDirectory.listFiles();
                if (files != null) {
                    for (File file : files) {
                        if (file.isFile() && file.getName().endsWith(".svg")) {
                            try {
                                // 移动文件到目标文件夹
                                Path sourceFile = file.toPath();
                                Path targetFile = targetFolder.toPath().resolve(file.getName());
                                Files.move(sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING);
                                System.out.println("Moved file: " + file.getName());
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }
}