Java基础入门笔记04——方法调用，方法重载，命令行参数，可变参数，多维数组，Arrays类，冒泡排序，矩阵的压缩存储

全栈程序员站长

发布于 2022-09-21 08:20:18

9120

大家好，又见面了，我是你们的朋友全栈君。

方法

System.out.println()——类.对象.方法
out是标准输出对象，in是标准输入对象
方法是语句的集合，用于执行一个功能——类似C语言中的函数

public class Demo01 { 
   
    public static void main(String[] args) { 
   
        //main就是一个方法————由java虚拟机调用
        //void 是表示返回类型为空
        int sum = add(1, 2);              //1，2为实际参数
        System.out.println(sum);
    }
    public static int add(int a,int b){ 
      //a,b为形式参数
        return a+b;
    }
}

设计方法原则： 一个方法只完成一个功能——原子性
定义方法的格式：

修饰符+返回值类型+方法名（参数类型参数名）{ 方法体 return }

return——不仅可以用于返回相应值，也可以用于终止方法

修饰符 ——告诉编译器如何调用该方法，定义了该方法的访问类型

main方法——一般要保持简洁干净，尽量把一些公共模块放到main外面

方法调用

按住ctrl点击方法名可以看到原码

方法有返回值时，方法调用需要用一个对应变量接收 eg. int maxNum=max(a,b);
方法没有返回值时，方法调用是一条语句,比如System.out.println();

区分值传递和引用传递——Java中只有值传递——核心思想是：拷贝生成一份新的

[等待：下来再了解补充]

方法重载

一般情况：写几个名字一样的方法（方法名必须相同），让它们的参数类型不同（一定不同），参数个数可以不同，参数顺序可以不同，方法体也可以不同。

在调用方法时，根据用户的输入的参数个数类型，调用对应的方法。

方法名必须相同，参数列表必须不同

命令行参数

在一个程序运行时才给他传递消息（动态传参），要靠传递命令行参数给main（）方法实现。

public class Demo02 { 
   
    public static void main(String[] args) { 
   
        
        for (int i =0;i<args.length;i++){ 
   
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}

此处命令行参数——String[ ] args 就是一个String类型的数组，args是数组名字，arguments的缩写，就是参数的意思。

命令行窗口操作如下 1.在命令行窗口进入文件所在目录进行编译（javac） javac 文件名.java 2.运行时要退回到src目录传递参数（cd… 可以返回上一级目录） java 文件名(带路径) 参数

F:\重新认识计算机\JavaSe\基础语法\src\methodStudy>javac Demo02.java
F:\重新认识计算机\JavaSe\基础语法\ src >java methodStudy.Demo02 this is kk

输出结果： args[0]:this args[1]:is args[2]:kk

可变参数——不定向参数

作用：避免方法重载太多次

public class Demo03 { 
   
    public static void main(String[] args) { 
   
        Demo03 demo03 = new Demo03();  //新建一个本类对象
		//test方法的参数列表是可变的，所以可以传任意个参数
          demo03.test(1,2,3); 
// demo03.test(5);
// demo03.test();
    }

    public void test(int... i){ 
   
        System.out.println(i[0]);
        System.out.println(i[1]);
    }
}

notes：

可变参数格式：

参数列表中只用最后一个参数可以是可变参数。在参数类型后面加省略号即可…（三个点）
任何普通参数要放在可变参数之前
在给可变参数传值时候类型要保持一致

递归——重思想

递归头：什么时候退出递归！如果没有头，将陷入死循环

递归体：一些指定操作+调用自身

public class Demo04 { 
   
    public static void main(String[] args) { 
   
   //阶乘
        System.out.println(fac(5));
    }
    public static int fac(int n){ 
   
        if (n==1) return 1;//———————————递归头
        else return n*fac(n-1);
    }
}

notes：

递归效率比较低。java使用栈机制，不合理使用递归会导致溢出，内存崩溃，所以程序中尽量不使用递归。

数组

相同类型数据的有序集合

下标从0开始
Java数组的两种声明(也可以同时声明和创建，写在后面)

类型[ ] + 名字 ——————java首选方法
类型 + 名字[ ] ——————方便c的程序员

   //数组类型[] 数组名 = 值
    int[] nums; // ——————首选
    int nums2[];

使用数组前必须先定义
java中使用 new 操作符来创建数组

nums = new int[10];

获取数组长度 nums.length 获取字符串的长度s.length（）

数组赋值

不赋值默认所有元素为0

声明和创建同时

int[] nums= new int[10]; ( 在IDEA中可以只写new int[10]按住alt+回车自动补全前面 )

数组初始化

内存分析
- 栈（放引用）存放new出来的对象和数组（声明数组时，将数组名放入栈）
- 堆（放实际值）放具体的值（创建数组时，在堆中开辟了对应个数的内存空间——用于下一步给数组赋值时）
- 方法区

此处出现的常见错误：访问数组下标越界 java.lang.ArrayIndexOutOfBoundsException

静态初始化
动态初始化
默认初始化

public class ArrayDemo02 { 
   
    public static void main(String[] args) { 
   
    	//静态初始化——创建+赋值
        int[] a ={ 
   5,6,7,8};   //定义后，长度不可变
        // 引用类型的数组，数组里放的是对象
        Man[] mans={ 
   new Man(),new Man()};  
        
        //动态初始化 (包含了默认初始化)
        int[] b = new int[10]; //创建后所有默认值为0，需要赋值
        b[0]=10;
    }
}
class Man{ 
    }

notes：

数组是引用类型，它的元素相当于类的实例变量，因此数组分配空间以后，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
数组中的元素类型要统一，不能混合
数组的元素类型可以是基本类型和引用类型（对象）
数组变量属于引用类型。可以把数组看成java的一个类，新建数组可以看成数组类的实例对象，数组中的每个元素相当于该对象的成员变量。由于新建的这个数组可以看做一个实例对象，而java中的对象是在堆中的，因此数组无论保存原始类型还是其他类型，数组对象本身是在堆中的。

边界问题

数组下标的合法区间是[0,length-1]

单行快速注释 ctrl+/

模块注释：选中，然后ctrl+shift+/

数组的使用

回顾一下增强for——数组遍历

int[] arrays={ 
   1,2,3,4,5};
for (int array : arrays) { 
   
// 临时变量 ： 需要遍历的数组
    System.out.println(array);

}

将数组作为参数传入方法

 public class ArrayDemo03 { 
   
     public static void main(String[] args)
     { 
   
         int[] arrays={ 
   1,2,3,4,5};
         printArray(arrays);
     }
         //方法——打印数组 参数是数组
         public static void printArray(int[] arrays)
         { 
   
             for (int i=0;i<arrays.length;i++)
             { 
   
                 System.out.print(arrays[i]+" ");
             }
         }
 }

数组作为返回值

package methodStudy;

public class ArrayDemo03 { 
   

    public static void main(String[] args){ 
   
        int[] arrays={ 
   1,2,3,4,5};
        int[] reverse= reverse(arrays);
        printArray(reverse);
        }
        //方法——打印数组 参数就是数组
        public static void printArray(int[] arrays){ 
   
            for (int i=0;i<arrays.length;i++){ 
   
                System.out.print(arrays[i]+" ");
            }

        }
        //反转数组的方法
    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; //返回翻转后的新数组
    }
 }

多维数组

数组里边是数组

public static void main(String[] args) { 
   

    int[][] array={ 
   { 
   1,2},{ 
   1,3},{ 
   2,5},{ 
   53,6}};
    System.out.println(array.length);     //输出4
    System.out.println(array[0].length);  //输出2
    
    //遍历几维数组就，需要几重循环
    for (int i = 0; i <array.length ; i++) { 
   
        for (int j = 0; j < array[i].length; j++) { 
   
            System.out.print(array[i][j]+" ");
        }
    }
}

Arrays类

来源 java.util.Arrays

//Arrays类的一些常用方法
public class Demo05 { 
   
    public static void main(String[] args) { 
   
        int[] a={ 
   1,5,3,48,6,9656,65,6};
        System.out.println(a);
        //直接打印数组a，是返回一个hashcode——[I@1b6d3586

        //打印输出数组——列表形式
        System.out.println(Arrays.toString(a));
        //给数组排序
        Arrays.sort(a);//升序
        System.out.println(Arrays.toString(a));

        //填充覆盖数组
        Arrays.fill(a,0); //将数组a中的元素全部覆盖为0
        System.out.println(Arrays.toString(a));
        //指定范围的填充
        Arrays.fill(a,2,5,0);
        //将数组a中的2-5位置填充为0（不包含又边界，即a[5]）
        System.out.println(Arrays.toString(a));

    }
}

冒泡排序——O(n^2)

原理： （升序冒泡）每一轮选出一个最大的，两层循环，外层冒泡轮数，里层依次比较

步骤：

从左边开始，比较数组相邻两位，如果第一个数比第二个数大，就交换位置，否则不变，继续比较第二个和第三个，第三个和第四个…
一轮下来，最右边的一定是最大的，这样就确定了最右边位置的数
如果一共6个数第一轮会比较5次，确定最后一个位置的数第二轮会比较4次，确定倒数第二个位置的数第三轮会比较3次… 直到结束…

import java.util.Arrays;

public class Demo06 { 
   
    public static void main(String[] args) { 
   
        int[] a ={ 
   50,3,65,35,85,43,1};
        int[] sort=bubbleSort(a);
        System.out.println(Arrays.toString(sort));
    }

    public static int[] bubbleSort(int[] array){ 
   
        int temp=0;
        //外层循环，判断要走多少次
        for (int i = 0; i <array.length-1 ; i++) { 
   
            //为什么array.length要-1？因为如果有六个数
            //只要确定后五个数位置，第一个数也就确定了

            //内层循环：比较————调换位置
            for (int j = 0; j <array.length-1-i ; j++) { 
   
                //为什么array.length-1还要再减去i？
                // 因为在第i轮时，说明后面已经有i个位置已经确定了
                //比如在第0轮，没有位置被确定，就是-0
                //第0轮结束后，在第1轮时有1个位置被确定，所以-1
                if(array[j]>array[j+1]){ 
   
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }

}

提问：如果原序列本来就是有序的，那每一轮的比较都是在浪费时间，如何优化呢？这就涉及到了八大排序算法问题。后续总结。

稀疏数组——压缩存储

对于一个空数据较多的矩阵，需要压缩存储节省空间

步骤：

记录数组几行几列，有多少个不同的值，假设有n个不同的数。
稀疏数组只有3列，n+1行（第一行放原数组的行数，列数，不同值个数）后面的n行放，n个不同数值的具体位置和值

package methodStudy;

public class Demo08 { 
   
    public static void main(String[] args) { 
   
// 创建二维压缩数组11*11
// 0:没有棋子 1：黑棋 2：白棋
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
    
        System.out.println("原始数组如下：");
        for (int[] ints : array1) { 
     //遍历二维数组第一层
            for (int anInt : ints) { 
   //遍历二维数组第二层
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
// 转换为稀疏数组
        //1.获取有效值的个数
        System.out.println("=================================");
        int count=0;
        for (int i = 0; i <11 ; i++) { 
   
            for (int j = 0; j <11 ; j++) { 
   
                if (array1[i][j]!=0) count++;
            }
        }
        System.out.println("有效值个数为："+count);
        //2.创建稀疏数组
        int[][] array2=new int[count+1][3];
        //设置第一行元素
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=count;

        //3.遍历原数组，找到有值的元素，把其位置信息和值赋给稀疏数组
        int count2=0;
        for (int i = 0; i <11 ; i++) { 
   
            for (int j = 0; j <11 ; j++) { 
   
                if (array1[i][j]!=0) { 
   
                    count2++;
                    array2[count2][0]=i;
                    array2[count2][1]=j;
                    array2[count2][2]=array1[i][j];

                };
            }
        }
        //4.输出稀疏数组

        for (int[] ints : array2) { 
   
            for (int anInt : ints) { 
   
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

// 由稀疏数组还原成原数组
        System.out.println("=================================");
        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.打印还原后的数组array3
        for (int i = 0; i <array3.length ; i++) { 
   
            for (int j = 0; j < array3[i].length; j++) { 
   
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }

    }
}

输出结果：

输出原始数组

0 0 0 0 0 0 0 0 0 0 0

0 0 1 0 0 0 0 0 0 0 0

0 0 0 2 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0

=================================

有效值个数为：2

11 11 2

1 2 1

2 3 2

=================================

还原数组为：

0 0 0 0 0 0 0 0 0 0 0

0 0 1 0 0 0 0 0 0 0 0

0 0 0 2 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/168487.html原文链接：https://javaforall.cn

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

如有侵权请联系 cloudcommunity@tencent.com 删除

java

编程算法

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

java

编程算法

登录后参与评论

0 条评论

热度