java09数组的使用

 

/**
     * 求数组中的最大值
     */
    @Test
    public  void  test14(){
        //定义一个数组   参赛的选手
        int  [] nums={50,20,30,80,100,90};
        //定义一个擂主
        int max=0;
       //循环打擂
        for (int i = 0; i < nums.length; i++) {
            //如果发现 数组中的元素 大于 max  就让当前的元素的值给max
            if (nums[i]>max) {
                max=nums[i];
                System.out.println("历届的擂主：："+max);
            }
        }
        System.out.println("最终的擂主是："+max);
    }
    /**
     * 求数组中的最小值
     */
    @Test
    public  void  test15(){
        //定义一个数组   参赛的选手
        int  [] nums={50,200,30,80,100,90};
        //定义一个最小值  默认是 数组中的第一个元素
        int min=nums[0];
        //循环打擂
        for (int i = 0; i < nums.length; i++) {
            //如果发现数组中的元素小于min 把元素的值给min
            if (nums[i]<min) {
                min=nums[i];
            }
        }
        System.out.println("最小的数值是："+min);
    }
    

求数组的最大和最小值

public class Array01 {

    /**
     * 数组：一组相同数据类型的集合！  在内存中开辟一连串的空间！
     *   和String一样都是  引用数据类型！
     *
     *   数据类型 [] 数组名称;
     *
     *   数组的下标=数组的长度-1
     */
    public static void main(String[] args) {
        // 01.声明数组 创建了一个火车厢
        int[] nums;
        // 02.分配空间 给火车厢创建座位
        nums = new int[5];
        // 03.赋值 旅客入座
        nums[0] = 50;
        // 04.使用 nums.length（获取数组的长度）
        for (int i = 0; i < nums.length; i++) {
            System.out.println("数组nums的第" + (i + 1) + "个位置的数据是：" + nums[i]);
        }
    }

    // 声明数组的同时给数组赋值
    @Test
    public void test01() {
        /**
         * 给你说 创建车厢的同时,告诉你里面有多少个座位
         *
         * int  [] nums;
         * nums={ 1, 2, 3, 4, 5 };  这种写法是错误的！
         */
        int[] nums = { 1, 2, 3, 4, 5 };
        // 找到下标为3的数据
        System.out.println(nums[3]);
    }

    @Test
    public void test02() {
        // int[] nums = new int[5]; 可以 常用的方式
        int[] nums = new int[] { 1, 2, 3, 4, 5 };
        // 找到下标为3的数据
        System.out.println(nums[3]);
    }

    /**
     * 计算5位学生的平均分
     */
    @Test
    public void test03() {
        // 01.创建一个长度为5的double类型的数组 保存学生成绩
        double[] scores = new double[5];
        // 02.循环给学生成绩赋值
        Scanner scanner = new Scanner(System.in);
        double sum = 0; // 保存总成绩
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第" + (i + 1) + "位同学的成绩");
            scores[i] = scanner.nextDouble();
            // 每个学生成绩需要加到sum中
            sum += scores[i];
        }
        System.out.println("学生的总成绩是：" + sum);
        System.out.println("学生的平均分是：" + (sum / scores.length));
    }

    /**
     * 有一个数列：8,4,2,1,23,344,12
    循环输出数列的值
    求数列中所有数值的和
    猜数游戏：从键盘中任意输入一个数据,判断数列中是否包含此数
     */
    @Test
    public void test04() {
        // 01.创建int类型数组
        int nums[] = { 8, 4, 2, 1, 23, 344, 12 };
        // 定义变量保存总和
        int sum = 0;
        // 02.循环输出数列的值
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + ",");
            sum += nums[i];
        }
        System.out.println("\n数组中数值的总和：" + sum);
        // 猜数游戏：从键盘中任意输入一个数据,判断数列中是否包含此数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int num = scanner.nextInt();
        // 定义标记 来记录是否中奖
        boolean flag = false;
        for (int i = 0; i < nums.length; i++) {
            if (num == nums[i]) {
                flag = true;
                break;
            }
        }
        if (flag) { // 判断标记
            System.out.println("恭喜您！中大奖！");
        } else {
            System.out.println("没有找到......");
        }
    }

    /**
     * 以表格的形式输出5笔购物金额及总金额
     */
    @Test
    public void test05() {
        double[] pays = new double[5];
        double sum = 0; // 总金额
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入本月的消费记录：");
        for (int i = 0; i < pays.length; i++) {
            System.out.println("请输入" + (i + 1) + "次的消费金额：");
            pays[i] = scanner.nextDouble(); // 给数组中每一个元素赋值
            // 求和
            sum += pays[i];
        }
        // 输出消费详情 遍历（从集合中取得数据）
        System.out.println("序号\t\t金额");
        for (int i = 0; i < pays.length; i++) {
            System.out.println((i + 1) + "\t\t" + pays[i]);
        }
        System.out.println("总金额：" + sum);
    }

    /**
     * Arrays  ：数组的操作类
     */
    @Test
    public void test06() {
        double[] pays = new double[5];
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入本月的消费记录：");
        for (int i = 0; i < pays.length; i++) {
            System.out.println("请输入" + (i + 1) + "次的消费金额：");
            pays[i] = scanner.nextDouble(); // 给数组中每一个元素赋值
        }

        // 没有排序的遍历
        for (int i = 0; i < pays.length; i++) {
            System.out.println(pays[i]);
        }
        System.out.println("*************升序之后***************");
        Arrays.sort(pays);// 升序排列
        for (int i = 0; i < pays.length; i++) {
            System.out.println(pays[i]);
        }
    }

}

/**
 * 操作数组的工具类！
 *
 */
public class Arrays02 {

    // equals(arr1, arr2) :比较两个数组的内容和长度 是否一致
    @Test
    public void testEquals() {
        int[] nums1 = { 10, 20, 30, 50 };
        int[] nums2 = nums1;
        int[] nums3 = { 10, 20, 30 };
        System.out.println("nums1与nums2比较：" + Arrays.equals(nums1, nums2));
        System.out.println("nums1==nums2比较：" + (nums1 == nums2));
    }

    // sort（arr）:对数组中的元素进行升序的排列
    @Test
    public void testSort() {
        int[] nums = { 10, 50, 30, 20 };
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }

    /**
     *  toString ：把一个数组变成字符串
     *  [10, 50, 30, 20]   集合toString的结果！
     */
    @Test
    public void testToString() {
        int[] nums = { 10, 50, 30, 20 };
        System.out.println(Arrays.toString(nums));
    }

    /**
     * fill（arr,val）:将arr数组中的所有元素都赋值成了val
     */
    @Test
    public void testFill() {
        int[] nums = { 10, 50, 30, 20 };
        System.out.println(Arrays.toString(nums));
        Arrays.fill(nums, 100);
        System.out.println(Arrays.toString(nums));
    }

    /**
     * copyOf(arr,length):将数组arr复制成一个长度为length的新数组！
     */
    @Test
    public void testCopyOf() {
        int[] nums = { 10, 50, 30, 20 };
        int[] nums1 = Arrays.copyOf(nums, 3);
        System.out.println(Arrays.toString(nums1));
    }

    /**
     * binarySearch(arr,val):查询val在arr数组中的下标！
     * 必须先升序排列！  Arrays.sort(arr)!!!!
     */
    @Test
    public void testBinarySearch() {
        int[] nums = { 10, 50, 30, 20 };
        Arrays.sort(nums); // 10 20 30 50
        System.out.println(Arrays.binarySearch(nums, 50));
    }

}

// 打擂法 求数组中的最大值
    @Test
    public void test01() {
        int[] nums = { 10, 50, 30, 200 };
        // 默认的擂主
        int max = nums[0];
        // 让max依次和nums中的每一个元素进行比较
        for (int i = 0; i < nums.length; i++) {
            if (max < nums[i]) {
                max = nums[i];
            }
        }
        System.out.println("最大值：" + max);
    }

    /**
     * 插入算法
     */
    @Test
    public void test02() {
        // 先定义一个有序的数组
        int[] nums = new int[5];
        nums[0] = 100;
        nums[1] = 90;
        nums[2] = 80;
        nums[3] = 10;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请您输入一个插入的数据：");
        int num = scanner.nextInt();
        // 01.找到需要插入数据的位置
        int index = nums.length;
        // 02.循环找到位置
        for (int i = 0; i < nums.length; i++) {
            if (num > nums[i]) {
                index = i; // 下标
                break;
            }
        }
        // 03.元素后移
        for (int j = nums.length - 1; j > index; j--) {
            nums[j] = nums[j - 1]; // 依次后移
        }
        // 04.插入数据
        nums[index] = num;
        System.out.println("插入数据的下表是：" + index);
        System.out.println(Arrays.toString(nums));

    }

public class CharSort03 {

    /**
     * 字符的逆序输出
     */
    public static void main(String[] args) {
        char[] chars = { 'a', 'f', 'c', 'g', 'z', 'y' };
        // 升序
        Arrays.sort(chars);
        System.out.println("升序之后的字符===》" + Arrays.toString(chars));
        // 逆序
        System.out.println("逆序之后的字符====");
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.print(chars[i]);
        }
    }

    @Test
    public void test01() {
        // char类型的默认值： '\u0000'
        char[] chars = { 'a', 'c', 'f', 'g', 'y', 'z', '\u0000' }; // 必须有顺序

        System.out.println(chars.length);
        char c = 'x'; // 需要插入的字符
        int index = chars.length;
        // 找下标
        for (int i = 0; i < chars.length; i++) {
            if (c < chars[i]) {
                index = i;
                break;
            }
        }
        // 元素后移
        for (int j = chars.length - 1; j > index; j--) {
            chars[j] = chars[j - 1];
        }
        // 插入数据
        chars[index] = c;
        for (int i = 0; i < chars.length; i++) {
            System.out.print(chars[i]);
        }
    }
}

public class DoubleArray04 {

    public static void main(String[] args) {

        int[] clazz = new int[3]; // 保存班级
        int[] students = new int[5]; // 保存学生

    }

    @Test
    public void test01() { // 声明的同时开辟空间
        int[][] nums = new int[3][5]; // 3个班级各5名学生
    }

    @Test
    public void test02() { // 先声明 再 开辟空间
        int[][] nums;
        nums = new int[3][5]; // 3个班级各5名学生
    }

    @Test
    public void test03() { // 声明 开辟空间的同时赋值
        int[][] nums = { { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 },
                { 1, 2, 3, 4, 5 } };
        System.out.println(nums.length);// 3个班级各5名学生
    }

    @Test
    public void test04() {
        int[][] nums = new int[3][5]; // 3个班级各5名学生
        // 第二个班级的第三个学生
        nums[1][2] = 50;
    }

    @Test
    public void test05() {
        int[][] nums = { { 1, 2, 3 }, { 10, 20, 30 }, { 100, 200, 300 } };

        /**
         * nums.length   车厢数
         * nums[i].length 车厢中的座位数
         * 双重循环：
         *   外层循环执行一次，内存循环执行一遍！
         */
        for (int i = 0; i < nums.length; i++) {
            System.out.println("进入了第" + (i + 1) + "个车厢**********");
            if (i == 2) {
                break; // 跳出当前循环体
            }
            for (int j = 0; j < nums[i].length; j++) {
                if (j == 2) {
                    break; // 跳出当前循环体
                }
                System.out.println(nums[i][j]);
            }
        }
    }

    /**
     * 所有的引用数据类型如果没有实例化（开辟空间）！ 不能使用！
     * 因为引用数据类型的默认值 是  null！
     */
    @Test
    public void test06() {

        int[][] nums = new int[5][];
        System.out.println(nums.length);
        nums[0] = new int[5]; // 开辟空间
        nums[1] = new int[6];

        nums[0][0] = 50; // 使用
        nums[0][1] = 60;
        nums[0][2] = 70;
        nums[0][3] = 80;
        System.out.println(nums[0].length);
        System.out.println(nums[1].length);
    }

}

    /**
     * 冒泡排序 升序的排列
     */
@Test
public  void  test17(){
    int [] nums={1,5,8,2,3,5};
    /**
     * 外层循环控制轮数     数组的长度-1
     * 外层循环每执行一次， 内层循环执行一遍
     */
    for (int i = 0; i < nums.length-1; i++) {
        System.out.println("这是第"+(i+1)+"轮===================");
        //内层循环    数组的长度-1-i
        for (int j = 0; j < nums.length-i-1; j++) {
            System.out.println("比较了第"+(j+1)+"次");
        }
    }
}

/**
 * 冒泡排序 升序的排列
 */
@Test
public  void  test18(){
    int [] nums={10,5,8,2,3,50,5000,500,30,65,98};
    /**
     * 外层循环控制轮数     数组的长度-1
     * 外层循环每执行一次， 内层循环执行一遍
     *
     * 无论多少个数字相比
     * 都是相邻的两个数字进行比较，
     * 数值小的元素会交换前面的位置
     * 代码：
     * 外层循环 : 数组长度-1
     * 内层循环： 数组长度-1-i
     *
     */
    for (int i = 0; i < nums.length-1; i++) {
        //内层循环    数组的长度-1-i
        for (int j = 0; j < nums.length-i-1; j++) {
            if (nums[j]>nums[j+1]) { //相当于 第一个元素大于下一个元素 ，那么需要和下个元素换位置
                //等量转换
                int  temp=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=temp;
            }
        }
    }
    //遍历数组中的元素
    for (int i : nums) {
        System.out.println(i);
    }
}
    

冒泡排序

public class TestArrays {

    /**
     * Arrays.equals(数组1，数组2)
     * 01.首先比较的而是数组的长度是否一致
     * 02.比较数组中的元素
     */
    @Test
    public void  test01(){
        int nums1[]={10,20,30};
        int nums2[]={10,20,30};
        int nums3[]={10,30,20};
        System.out.println(nums1==nums2);  //比较内存地址  false
        //equals
        System.out.println(nums1.equals(nums2));   //底层还是比较内存地址  false
        System.out.println(Arrays.equals(nums1, nums2));  //true
        //System.out.println(Arrays.equals(nums1, nums3));  //false
    }

    /**
     * [L@4a7fca02  ：数组toString()的结果
     */
    @Test
    public void test02(){
        int nums1[]={10,20,30};
        System.out.println(nums1);
        //把数组转换成字符串
        System.out.println(Arrays.toString(nums1));
    }

    @Test
    public void test03(){
        int nums1[]={10,20,30};
        //把数组转换成字符串
        System.out.println(Arrays.toString(nums1));
        //copyOf(数组，长度)
        int[] nums2 = Arrays.copyOf(nums1, 10);
        System.out.println(Arrays.toString(nums2));
    }

    @Test
    public void test04(){
        int nums1[]={10,20,30};
        System.out.println("nums1之前的值："+Arrays.toString(nums1));
        //fill(数组，值)
        Arrays.fill(nums1, 500);
        System.out.println("nums1fill之后的值："+Arrays.toString(nums1));
    }

    /**
     * binarySearch(数组，值)
     * 查询值 在数组中下标的位置
     */
    @Test
    public void test05(){
        int nums1[]={100,200,10,20,30};
        //01.必须先排序   升序
        Arrays.sort(nums1);
        //02.查询20的下标    [10,20,30,100,200]
        System.out.println(Arrays.binarySearch(nums1, 300));
    }

}

Arrays工具类的使用

/**
     *
     * 二维数组： 数组中的元素 又是一个数组！
     */
    @Test
    public void test06(){
        //01.创建二维数组
        int[][] nums=new int[3][3]; //int [][] nums2={{1,2,3},{4,5,6},{7,8,9}};

        nums[0][0]=5;
        nums[0][1]=6;
        nums[0][2]=7;

        nums[1][0]=5;
        nums[1][1]=6;
        nums[1][2]=7;

        nums[2][0]=5;
        nums[2][1]=6;
        nums[2][2]=7;

    }

    @Test
    public void test07(){
        //01.创建二维数组
        int [][] nums={{1,2,3,4},{4,5,6},{7,8}};

        System.out.println(nums[0]);//{1,2,3}
        System.out.println(nums[0][1]);//
        System.out.println("nums的长度："+nums.length);
        System.out.println("第2个数组中下标是2的元素"+nums[1][2]);
    }

    /**
     * 循环打印出数组所有的元素
     */
    @Test
    public void test08(){
        //01.创建二维数组
        int [][] nums={{1,2,3,4},{4,5,6},{7,8}};
        for (int i = 0; i < nums.length; i++) {  //外层
            System.out.println("这是2维数组中的第"+(i+1)+"个数组");
            for (int j = 0; j < nums[i].length; j++) {//内层
                System.out.println("元素的值："+nums[i][j]);
            }
        }

    }

二维数组

    /**
     *
     * 已知有3个班级各3名学员，请使用
     *二维数组计算各个班级的总成绩
     */

    @Test
    public void test10(){
        //01.创建二维数组
        int [][] nums=new int[3][3];
        Scanner scanner=new Scanner(System.in);
        //定义一个数组变量 存储每个班级的成绩
        int  sum[]=new int[nums.length];
        //02.让用户循环给数组 赋值
        for (int i = 0; i < nums.length; i++) {
            System.out.println("请输入第"+(i+1)+"个班级的学生成绩：");
            for (int j = 0; j < nums[i].length; j++) {
                System.out.println("请输入第"+(j+1)+"个成绩：");
                nums[i][j]=scanner.nextInt();  //学生成绩赋值
                sum[i]+=nums[i][j];  //每个班级的总成绩
            }
        }
        System.out.println("学生的成绩***********************");

        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                System.out.println("第"+(i+1)+"个班级的第"+(j+1)+"个学生的成绩："+nums[i][j]);
            }
        }
        System.out.println("班级的成绩***********************");
        for (int i = 0; i < sum.length; i++) {
            System.out.println("第"+(i+1)+"个班级的总成绩是："+sum[i]);
        }
    }

    @Test
    public void test011() {
        //有3个班各3名学生某门课程的成绩，
        //01.定义一个2维数组
        int [][] scores=new int[3][3];
        Scanner scanner=new Scanner(System.in);
        //02.循环给学生赋值
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第"+(i+1)+"班级学生的成绩：===========");
            for (int j = 0; j < scores[i].length; j++) {
                System.out.println("请输入第"+(j+1)+"个学生的成绩：");
                scores[i][j]=scanner.nextInt();
            }
        }
        System.out.println("学生的成绩统计如下******************");
        // 如何计算3个班各自的总成绩？

        for (int i = 0; i < scores.length; i++) {
            // 每个班级都清零
            int sum = 0;
            for (int j = 0; j < scores[i].length; j++) {
                sum += scores[i][j];
            }
            System.out.println("第" + (i + 1) + "班级学生的成绩总和===" + sum);
        }

        }

二维数组小练习