Java学习【知识点及代码5】

最新推荐文章于 2022-07-16 16:57:16 发布

huiyan_edu

最新推荐文章于 2022-07-16 16:57:16 发布

阅读量285

点赞数

本文链接：https://blog.csdn.net/huiyan_edu/article/details/70099543

版权

一：二维数组：其实二维数组其实就是一个元素为一维数组的数组。

1.1动态初始化方式一（指定有多少个长度相同的一维数组）：
    数据类型[][] 变量名 = new 数据类型[m][n];

    m表示这个二维数组有多少个一维数组
    n表示每一个一维数组的元素个数

需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
1.打印二维数组名称
2.打印每一个一维数组
3.不给元素赋值打印元素
4.赋值后打印元素

package day5.edu_01;

public class DoubleArrayDemo1 {
    public static void main(String[] args) {
//      需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
        int[][] arr = new int [3][2];
//      1.打印二维数组名称
        System.out.println(arr);
//      2.打印每一个一维数组
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
//      3.不给元素赋值打印元素
        //二维数组中的第一个一位数组的0号元素
        System.out.println(arr[0][0]);
        System.out.println(arr[1][1]);
//      4.赋值后打印元素
        arr[0][0]=20;
        arr[1][1]=10;
        System.out.println(arr[0][0]);
        System.out.println(arr[1][1]);
    }

}

1.2动态初始化方式二
（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：
    数据类型[][] 变量名 = new 数据类型[m][];

注意：
    m这个数据必须给出，后面的数据可以不给

需求：定义一个有3个一维数组的二维数组

1.给这个二维数组的每一个一维数组的元素赋值
    仅可用此种方式：
    arr[0] = new int[2];
    arr[0][0] = 1;
    arr[0][1] = 2;

    不能用此种方式：
    /*
    arr[0] = {1,2};
    arr[1] = {5,6,7};
    arr[2] = {4};
    */

package day5.edu_01;

public class DoubleArrayDemo2 {
    public static void main(String[] args) {
//  需求：定义一个有3个一维数组的二维数组,每一个一维数组的长度不固定
        int[][] arr = new int[3][];
//  打印二维数组中每一个一维数组的名称
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

//  给这个二维数组的每一个一维数组的元素赋值
//  arr[0] = {1,2,3};//在这里无法使用一维数组的静态初始化给二维数组中的每一个元素赋值
//  第一个一维数组有两个元素
        arr[0] = new int[2];
        arr[0][0] = 10;
        arr[0][1] = 20;

//  第二个一维数组，长度为3
        arr[1] = new int[3];
        arr[1][0] =30;
        arr[1][1] =40;
        arr[1][2] =50;

//  第三个一维数组，长度为2
        arr[2] = new int[2];
        arr[2][0] = 60;
        arr[2][1] = 70;

//  2.打印二维数组的名称
        System.out.println(arr);

//  3.打印二维数组中每一个一维数组的名称
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

//  4.打印二维数组中的每一个一位数组中的元素（手动打印几个即可）
        System.out.println(arr[1][1]);
        System.out.println(arr[2][1]);
    }
}

1.3 二维数组的静态初始化：
    静态初始化：
    数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

    简化格式：
        数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化）
需求：定义一个里面有3个长度不一样的一维数组的二维数组（使用静态初始化）

package day5.edu_01;

public class DoubleArrayDemo3 {
    public static void main(String[] args) {
        //需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化）
        int arr1[][] = new int[][]{{3,2},{5,4},{6,3}};

        //需求：定义一个里面有3个长度不一样的一维数组的二维数组（使用静态初始化）
        int arr2[][] = {{1,2,3},{4,5},{6,7,8,9}};

        System.out.println(arr1[2][1]); 
    }
}

1.4 二维数组的遍历：
需求：定义一个里面有3个长度不一样的一维数组的二维数组，并遍历

package day5.edu_01;
//二维数组的遍历：
//需求：定义一个里面有3个长度不一样的一维数组的二维数组，并遍历

public class DoubleArrayDemo4 {
    public static void main(String[] args) {
        //定义一个三个长度不意义样的一位数组的二维数组，并遍历
        int arr[][] = {{1,2},{3,4,5},{6,7,8,9}};

        //利用for循环遍历二维数组
        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();
        }
    }
}

1.5 二维数组的求和：
公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

package day5.edu_01;
public class DoubleArrayDemo5 {
    public static void main(String[] args) {
        //创建对应的二维数组
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

        //遍历二维数组并将每一个元素的值加起来
        int sum = 0;

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                //拿到每一个一维数组之后，遍历每一个一维数组，加起来
                sum+=arr[i][j];

            }

        }
        System.out.println(sum);        
    }
}

二：形式参数问题
看程序写结果

package com.edu_02;

public class ArgsDemo {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b); //10,20
        change(a,b);
        System.out.println("a:"+a+",b:"+b); //a:10,b:20

        int[] arr = {1,2,3,4,5};
        change(arr);
        System.out.println(arr[1]); //4
    }

    public static void change(int a,int b) { 
        System.out.println("a:"+a+",b:"+b); //10,20
        a = b; 
        b = a + b; 
        System.out.println("a:"+a+",b:"+b);//20,40
    }

    public static void change(int[] arr) { 
        for(int x=0; x<arr.length; x++) {
            //如果数组的元素值是偶数，就变为以前的2倍。
            if(arr[x]%2==0) {
                arr[x]*=2; 
            }
        }
    }

    /**
     * 基本数据类型：
     *      在传递参数的时候，基本数据类型的值不变
     * 
     * 引用数据类型：
     *      在传递参数的时候，方法会直接影响着一个引用数据类型的参数
     */
}

三 .数组的高级操作（冒泡排序，选择排序，数组工具类，练习）
【一】：冒泡排序

1.1 看视频得出结论：

1.2 冒泡排序基本概念是：
相邻的两个元素进行比较，小的放前面，大的放后面

1.3 画图讲解冒泡排序，int[] arr = { 24, 69, 80, 57, 13 };

1.4 文字分析比较过程
第一次比较：比较了4次，最大的值放到了最后
第二次比较：比较了3次，次大的值放到了倒数第二
。。。依次类推

package day5.edu_03;
//使用冒泡排序给数组int[] arr = { 24, 69, 80, 57, 13 };进行排序
public class ArraySortDemo {
    public static void main(String[] args) {
        //创建一个数组
        int[] arr = {24, 69, 80, 57, 13};
        //外层循环控制比较的次数
        for (int i = 0; i < arr.length-1; i++) {
            //-1是为了防止数组越界，-j是为了提高比较的效率
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    //找一个中间变量
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }

        }
        printArr(arr);
    }

    //写一个方法打印数组
    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");

        }
        System.out.println();
    }
}

【二】：选择排序：

2.1 选择排序概念：
  选择排序：
        从0索引开始，依次和后面的每一个元素进行比较
        第一次比较完毕，最小值出现在了最小索引处
        第二次比较完毕，次小值出现在了次小索引处
        ...
        完毕后，就排序了。

2.2 画图讲解选择排序规则

2.3 运用选择排序int[] arr = { 24, 69, 80, 57, 13 };进行排序

package com.edu_03;

public class ArraySortDemo2 {
    public static void main(String[] args) {
        //使用选择排序对数组进行排序：int[] arr = { 24, 69, 80, 57, 13 };
        int[] arr = { 24, 69, 80, 57, 13 };

/*      //第一次比较
        int x = 0;
        for (int i = x+1; i < arr.length; i++) {
            if (arr[x]>arr[i]) {
                int temp = arr[x];
                arr[x] = arr[i];
                arr[i] = temp;
            }

        }
        printArr(arr);


        //第二次比较
        x = 1;
        for (int i =  x+1; i < arr.length; i++) {
            if (arr[x]>arr[i]) {
                int temp = arr[x];
                arr[x] = arr[i];
                arr[i] = temp;
            }

        }
        printArr(arr);


        //第三次比较
        x = 2;
        for (int i =  x+1; i < arr.length; i++) {
            if (arr[x]>arr[i]) {
                int temp = arr[x];
                arr[x] = arr[i];
                arr[i] = temp;
            }

        }
        printArr(arr);


        //第四次比较
        x = 3;
        for (int i = x+1; i < arr.length; i++) {
            if (arr[x]>arr[i]) {
                int temp = arr[x];
                arr[x] = arr[i];
                arr[i] = temp;
            }

        }
        printArr(arr);*/

        System.out.println("--------------------------");
        //使用for循环改进上面的代码
        for (int j = 0; j < arr.length-1; j++) {
            for (int i = j+1; i < arr.length; i++) {
                if (arr[j]>arr[i]) {
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        printArr(arr);

    }

    //写一个方法打印数组
        public static void printArr(int[] arr){
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+"  ");
            }
            System.out.println();
        }

}

【三】：Arrays数组工具类

3.1 针对数组进行操作的工具类。提供了排序，转换等功能。

3.2 
  成员方法：
        public static String toString(int[] a):把数组转成字符串
        public static void sort(int[] a):对数组进行排序（有重载）

//把数组转成字符串
package day5.edu_04;
import java.util.Arrays;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //public static String toString(int[] a):把数组转成字符串
        int arr[] = {7,5,6,2,4};
        String arrstr = Arrays.toString(arr);
        //打印上面数组的字符串表示形式
        System.out.println(arrstr);

        System.out.println("======================");
        char[] chs = {'s','r','g','q'};
        String chsstr = Arrays.toString(chs);
        System.out.println(chsstr);
        }
    }

//对数组进行排序
package day5.edu_04;
import java.util.Arrays;
public class ArrrayDemo1 {
    public static void main(String[] args) {
        int[] arr = {1,5,2,9,7};
        Arrays.sort(arr);
        printArr(arr);

        char[] chs = {'s','c','f','w'};
        Arrays.sort(chs);
        printArr(chs);
    }

    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"    ");    
        }
        System.out.println();
    }

    public static void printArr(char[] chs){
        for (int i = 0; i < chs.length; i++) {
            System.out.print(chs[i]+"    ");
        }
        System.out.println();
    }
}

【四】：练习（运用冒泡排序和数组工具类两种方式实现）

  把字符串中的字符进行排序。
  举例：”dacgebf”
  结果：”abcdefg”

package day5.edu_05;

import java.lang.reflect.Array;
import java.util.Arrays;
public class StringSortDemo {
    public static void main(String[] args) {
        //使用冒泡排序
        String s = "asdefryj";
        //转换成字符数组
        char[] chs = s.toCharArray();
        //使用冒泡排序对字符根据ascii码表进行排序
//      for (int i = 0; i < chs.length-1; i++) {
//          for (int j = 0; j < chs.length-1-i; j++) {
//              if(chs[j]>chs[j+1]){
//                  char temp;
//                  temp = chs[j];
//                  chs[j] = chs[j+1];
//                  chs[j+1] = temp;
//              }
//              
//          }
//          
//      }
        //使用Arrays里面的sort()方法给字符数组进行排序  
        Arrays.sort(chs);
        //打印数组
        System.out.println(Arrays.toString(chs));   
    }
}

【五】作业
从键盘输入10个数字,用冒泡排序进行从小到大的排序

package com.edu_01;

import java.util.Arrays;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //从键盘输入10个数字,用冒泡排序进行从小到大的排序
        //创建键盘录入对象，并导包
        Scanner sc = new Scanner(System.in);
        //创建一个数组
        int[] arr = new int[10];
        for (int i = 1; i < 11; i++) {
            System.out.println("请输入第"+i+"个数字");
            //获取键盘录入对象
            int a = sc.nextInt();
            arr[i-1] = a;
        }

        //打印数组
        System.out.println(Arrays.toString(arr));

    }
}

huiyan_edu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习【知识点及代码5】

一：二维数组：其实二维数组其实就是一个元素为一维数组的数组。1.1动态初始化方式一（指定有多少个长度相同的一维数组）：数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 n表示每一个一维数组的元素个数需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。 1.打印二维数组名称 2.打印每一
复制链接

扫一扫