数组

  1. 什么是数组

    1. 数组是相同类型数据的有序集合; 访问使用下标进行访问 默认下标为0

  2. 数组怎么定义

    1. 静态初始化

      1. 数据类型 [] 数组名 = {10,20,30};

    2. 动态初始化

      1. 数据类型 [] 数组名 = new 数组类型 [长度];

  3. 数组的特点

    1. 一旦被创建 长度是固定不可变的
    2. 数组的类型必须是相同的
    3. 数组的元素可以是任何数组类型 包括基本数据类型和引用

  4. 二维数组

    1. 二维数组是一个特殊的一维数组 特殊的一维数组每一个元素是一个一维数组

一维数组

数组的创建：

public class demo {
    public static void main(String[] args) {
        //数组类型 [] 数组名 = new 数据类型 [大小]
        int [] array = new int[5];

        //数据类型 [] 数组名 = new 数组类型 [长度]
        int [] arrays = {10,20,30,40};
    }
}

数组的遍历：

public class demo {
    public static void main(String[] args) {
        //数组类型 [] 数组名 = new 数据类型 [大小]
        int [] array = new int[5];

        //数据类型 [] 数组名 = new 数组类型 [长度]
        int [] arrays = {10,20,30,40};
        
        //遍历静态数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        //遍历动态数组
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
    }
}
public class demo {
    public static void main(String[] args) {
        //5个学生分别考了 85 95 67 92 89 使用数组进行求和

        int [] array = {85,95,67,92,89};
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            count += array[i];
        }
        System.out.println("和为：" + count);
    }
}

增强for遍历数组

增强for语法格式：

for (数据类型 变量名 : 数组名) {

​    //输出变量名
     //IDEA快捷键为iter

}
public class demo {
    public static void main(String[] args) {
        int [] array = {10,50,30,32,41,85};

        for (int arr : array) {
            System.out.println(arr);
        }

        String [] str = {"张三","李四","王五","赵六"};

        for (String s: str ) {
            System.out.println(s);
        }

        double [] d = {3.14,3.25,1.10,20.2};
        for (double dd : d) {
            System.out.println(dd);
        }
    }
}
public class demo1 {
    public static void main(String[] args) {
        //从键盘读入学生成绩  找出最高分
        Scanner scan = new Scanner(System.in);
        int max = 0;

        System.out.print("请输入学生人数：");
        int number = scan.nextInt();

        int [] arr = new int[number];

        System.out.println("请输入" + number + "个学生成绩:");

        for (int i = 0; i < arr.length; i++) {
            arr[i] = scan.nextInt();
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        System.out.println("最大的分数是：" + max);
    }
}

Arrays工具类

属性说明
toString(int[] a)返回指定数组的字符串表示形式，方法也同样适用于（byte,short.,long等）。
sort(int[] a)对数组中的元素进行升序排列，方法也同样适用于（byte,short.,long等）。
binarySearch(Object[] a, Object key)二分法查找给定值的索引，数组在调用之前必须是排序好的
equals(int[] a,int[]a1)两个指定int型数组彼此相等，则返回true，也就是两个数组以相同顺序包含相同的元素，方法适用于（byte,short.,long等）。
fill(int[] a,int val)将指定的int值分配给数组中的所有元素，方法也同样适用于（byte,short.,long等）。
copyof(int[] a,int newLength)返回指定数组的字符串表示形式，方法也同样适用于（byte,short.,long等）。
asList(int[] a,int[] b)返回由指定数组支持的固定大小的列表，方法也同样适用于（byte,short.,long等）

1.tostring方法打印数组

public class demo {
    public static void main(String[] args) {
        int [] arr = {10,20,30,40};
        System.out.println(Arrays.toString(arr)); // [10, 20, 30, 40]
    }
}

2.sort方法进行升序排序

public class demo {
    public static void main(String[] args) {
        int [] arr = {10,3,5,7,8,4,6,1,2};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5, 6, 7, 8, 10]
    }
}

3.binarySearch 查找索引

public class demo {
    public static void main(String[] args) {
        int[] arr = {10,15,1,3,4,6,7,8,9};

        //调用sort进行排序
        Arrays.sort(arr);

        //调用tostring 打印排序后的结果
        System.out.println(Arrays.toString(arr)); //[1, 3, 4, 6, 7, 8, 9, 10, 15]

        //排序后 调用二分法 查询3的索引
        int index = Arrays.binarySearch(arr,3);

        System.out.println(index); //1
    }
}

4.equals 比较数组

public class demo {
    public static void main(String[] args) {
        int [] arr = {1,2,3};
        int [] arr1 = {1,2,3};
        
        System.out.println(Arrays.equals(arr,arr1)); //true
    }
}

5.fill 填充数组元素

public class demo {
    public static void main(String[] args) {
        int [] arr = {10,20,30,40};
        
        //调用fill 将数组全部填充为2
        Arrays.fill(arr,2);

        System.out.println(Arrays.toString(arr)); //[2, 2, 2, 2]
    }
}

6.copyof 复制数组

public class demo {
    public static void main(String[] args) {
        int [] arr = {10,20,30,40};
        //复制一个新数组长度为5
        int[] copy = Arrays.copyOf(arr, 5);
        
        System.out.println(Arrays.toString(copy));// [10, 20, 30, 40, 0]

    }
}

7.aslist 将数组转换为集合

public class demo {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5,6};
        int[] b={23,34,23};
        
        // 将两个数组放进list集合中
        List<int[]> ints = Arrays.asList(a, b);
        for (int[] anInt : ints) {
            System.out.println(Arrays.toString(anInt));// [1,2,3,4,5,6][23,34,23]
        }
    }
}

二维数组

二维数组的创建：

public class demo1 {
    public static void main(String[] args) {
        //数组类型  [][] 数组名 = {{值0},{值1}};
        int [][] arr = {{1,2,3,4},{5,6,7,8}};

        //数组类型 [][] 数组名 = new 数组类型[长度][值];
        int [][] arr1 = new int[5][4];
        
    }
}

二维数组的遍历：

public class demo1 {
    public static void main(String[] args) {
        int[][] arry = {
                {10, 20, 30}, //0
                {40, 50, 60}, //1
                {70, 82, 90}, //2
        };
        System.out.println(arry[0][1]); //20
        System.out.println(arry[1][2]); //60
        System.out.println(arry[2][0]); //70

        //遍历数组
        for (int i = 0; i < arry.length; i++) {
            for (int j = 0; j < arry[i].length; j++) {
                System.out.println(arry[i][j]);
            }
            //使用换行 输出
            System.out.println();
        }

        
    }
}

数组案例：

public class demo1 {
    public static void main(String[] args) {
        //案例
        //找对象 谁会解开这个编程代码的联系方式就加
        int [] arr = {1,7,9,0,3,6};
        int [] qq = {2,1,1,4,5,0,3};
        String str = "";

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

        System.out.println("联系方式：" + str);
    }
}

冒泡排序

public class demo1 {
    public static void main(String[] args) {
        int tem;
        int [] age ={10,2,1,3,6,4,8};
        for (int i = age.length-1; i >= 0; i--) {
            for (int j = 0; j < i; j++) {
                if (age[j] > age[j+1]) {
                    /*
                     * 定义了一个盒子tem
                     * 如果5>1 那就交换
                     * */
                    tem = age[j];
                    age[j] = age[j + 1];
                    age[j + 1] = tem;
                }
            }
        }
        System.out.println(Arrays.toString(age));
    }
}

数组的查找

public class demo1 {
    public static void main(String[] args) {
        int [] arr = {10,60,30,40,50};

        for (int i = 0; i < arr.length ; i++) {
            if (arr[i] == 60) {
                System.out.println("下标是：" + i);
            }
        }
    }
}
Last modification：March 30, 2023
© Allow specification reprint
如果觉得我的文章对你有用，请随意赞赏