Java基础入门笔记04——方法调用，方法重载，命令行参数，可变参数，多维数组，Arrays类，冒泡排序，矩阵的压缩存储
2023-06-13 09:13:00 时间
大家好，又见面了，我是你们的朋友全栈君。
方法
- 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
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 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
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 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
相关文章
- java double转decimal_Java中Double与BigDecimal的相互转换
- Java解析XML(4种方法)「建议收藏」
- java生成时间戳类型_Java获取当前时间戳的方法有哪些
- java dom4j 添加节点_Java dom4j获取，添加，删除，查找，设置Element节点方法「建议收藏」
- 浅析Java多态_JAVA多态
- java验证手机号正则表达式_Java使用正则表达式验证手机号和电话号码的方法「建议收藏」
- java 文件上传到服务器_Java上传文件到服务器端的方法「建议收藏」
- java——调用方法交换两个数的值
- java查找字符的方法_Java字符串查找（3种方法）
- java解释器虚拟机-【Java解释器和编译器】解释器和编译器的深入理解
- java作用域-我是这样理解JavaScript中作用域
- 在Linux中查看Java线程：一种方法（linux查看java线程）
- Java ftp上传文件方法效率对比详解编程语言
- 实现使用Java实现Redis消息队列（redis消息队列java）
- 构建Java应用程序中Redis集群的方法（java连redis集群）
- 程序Oracle调用Java程序的实现方法（oracle调用java）
- 进程Linux下创建多个Java进程的简易方法（linux 多个java）
- Java开发与Linux运维的高效协作（java与linux运维）
- 使用Java连接MySQL数据库的具体操作方法（java连接mysql代码）
- Java连接Oracle实现简单快捷的数据传输（java联结oracle）
- Java完美判断中文字符的方法
- Java实现软件运行时启动信息窗口的方法