Java学习-详述main方法、可变参数、数组的工具类、二维数组

2024-04-19 06:44
文章标签 java 工具 参数 数组 学习 方法 main 二维 可变 详述

本文主要是介绍Java学习-详述main方法、可变参数、数组的工具类、二维数组，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

详述main方法

【1】main方法：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口

【2】main方法格式严格要求：

public static void main(String[] args){}

public static --->修饰符 ，暂时用这个 -->面向对象一章

void --->代表方法没有返回值 对应的类型void

main --->见名知意名字

String[] args  --->形参  ---》不确定因素

【3】问题：程序中是否可以有其他的方法也叫main方法？

可以，构成了方法的重载。

  1. public class TestArray10{
  2.     public static void main(String[] args){
  3.                 
  4.         }
  5.         public static void main(String str){
  6.                 
  7.         }
  8. }

【4】形参为String[] 那么实参到底是什么？

  1. public class TestArray10{
  2.     public static void main(String[] args){
  3.                 //从侧面验证：
  4.                 //int[] arr1; //如果对数组只声明，没有后续操作，那么相当于 白定义了。
  5.                 //int[] arr2 = null;
  6.                 //System.out.println(arr2.length);//Exception in thread "main" java.lang.NullPointerException
  7.                 //int[] arr3 = new int[0];
  8.                 //System.out.println(arr3.length);
  9.                 //int[] arr4 = new int[4];
  10.                 //System.out.println(arr4.length);
  11.                
  12.                 //System.out.println(args.length);//0
  13.                 //从这个结果证明，参数是String[],实参是  new String[0]
  14.                 //默认情况下，虚拟机在调用main方法的时候就是传入了一个长度为0的数组
  15.                
  16.                 System.out.println(args.length);
  17.                 for(String str:args){
  18.                         System.out.println(str);
  19.                 }
  20.         }
  21. }

手动传入实参：

有特殊符号的时候可以加上“”

没有特殊符号用空格隔开即可：

可变参数
  1. public class TestArray12{
  2.         /*
  3.         1.可变参数：作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
  4.         int...num
  5.         double...num
  6.         boolean...num
  7.         
  8.         
  9.         2.可变参数在JDK1.5之后加入的新特性
  10.         3.方法的内部对可变参数的处理跟数组是一样
  11.         4.可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
  12.         5.我们自己在写代码的时候，建议不要使用可变参数。
  13.         */
  14.     public static void main(String[] args){
  15.                 //method01(10);
  16.                 //method01();
  17.                 //method01(20,30,40);
  18.                 method01(30,40,50,60,70);
  19.                 //method01(new int[]{11,22,33,44});
  20.         }
  21.         public static void method01(int num2,int...num){
  22.                 System.out.println("-----1");
  23.                 for(int i:num){
  24.                         System.out.print(i+"\t");
  25.                 }
  26.                 System.out.println();
  27.                
  28.                 System.out.println(num2);
  29.         }
  30. }

Arrays工具类

为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。

  1. import java.util.Arrays;
  2. public class TestArray13{
  3.         public static void main(String[] args){
  4.                 //给定一个数组：
  5.                 int[] arr = {1,3,7,2,4,8};
  6.                 //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
  7.                 System.out.println(Arrays.toString(arr));
  8.                 
  9.                 //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
  10.                 //这个方法的使用前提：一定要查看的是一个有序的数组：
  11.                 //sort：排序 -->升序
  12.                 Arrays.sort(arr);
  13.                 System.out.println(Arrays.toString(arr));
  14.                 System.out.println(Arrays.binarySearch(arr,4));
  15.                
  16.                 int[] arr2 = {1,3,7,2,4,8};
  17.                 //copyOf:完成数组的复制：
  18.                 int[] newArr = Arrays.copyOf(arr2,4);
  19.                 System.out.println(Arrays.toString(newArr));
  20.                
  21.                 //copyOfRange:区间复制：
  22.                 int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
  23.                 System.out.println(Arrays.toString(newArr2));
  24.                
  25.                 //equals:比较两个数组的值是否一样：
  26.                 int[] arr3 = {1,3,7,2,4,8};
  27.                 int[] arr4 = {1,3,7,2,4,8};
  28.                 System.out.println(Arrays.equals(arr3,arr4));//true
  29.                 System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
  30.                
  31.                 //fill：数组的填充：
  32.                 int[] arr5 = {1,3,7,2,4,8};
  33.                 Arrays.fill(arr5,10);
  34.                 System.out.println(Arrays.toString(arr5));
  35.         }
  36. }

数组的复制操作

原理：

代码：

  1. import java.util.Arrays;
  2. public class TestArray14{
  3.         public static void main(String[] args){
  4.                 //给一个源数组：
  5.                 int[] srcArr = {11,22,33,44,55,66,77,88};
  6.                 //给一个目标数组：
  7.                 int[] destArr = new int[10];
  8.                 
  9.                 //复制：
  10.                 System.arraycopy(srcArr,1,destArr,3,3);
  11.                 //遍历查看目标数组：
  12.                 System.out.println(Arrays.toString(destArr));
  13.         }
  14.        
  15. }

结果：

二维数组

【1】引入：本质上全部都是一维数组：

【2】基本代码：

  1. public class TestArray15{
  2.         public static void main(String[] args){
  3.                 //定义一个二维数组：
  4.                 int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
  5.                 
  6.                 int[] a1 = {1,2,3};
  7.                 arr[0] = a1;
  8.                 
  9.                 arr[1] = new int[]{4,5,6,7};
  10.                
  11.                 arr[2] = new int[]{9,10};
  13.         }
  14. }

对应内存：

【3】四种遍历方式：

  1. public class TestArray15{
  2.         public static void main(String[] args){
  3.                 //定义一个二维数组：
  4.                 int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
  5.                 
  6.                 int[] a1 = {1,2,3};
  7.                 arr[0] = a1;
  8.                 
  9.                 arr[1] = new int[]{4,5,6,7};
  10.                
  11.                 arr[2] = new int[]{9,10};
  12.                
  13.                 //读取6这个元素：
  14.                 //System.out.println(arr[1][2]);
  15.                
  16.                 //对二维数组遍历：
  17.                 //方式1：外层普通for循环+内层普通for循环：
  18.                 for(int i=0;i<arr.length;i++){
  19.                         for(int j=0;j<arr[i].length;j++){
  20.                                 System.out.print(arr[i][j]+"\t");
  21.                         }
  22.                         System.out.println();
  23.                 }
  24.                
  25.                 //方式2：外层普通for循环+内层增强for循环：
  26.                 for(int i=0;i<arr.length;i++){
  27.                         for(int num:arr[i]){
  28.                                 System.out.print(num+"\t");
  29.                         }
  30.                         System.out.println();
  31.                 }
  32.                 
  33.                 //方式3：外层增强for循环+内层增强for循环：
  34.                 for(int[] a:arr){
  35.                         for(int num:a){
  36.                                 System.out.print(num+"\t");
  37.                         }
  38.                         System.out.println();
  39.                 }
  40.                
  41.                 //方式4：外层增强for循环+内层普通for循环：
  42.                 for(int[] a:arr){
  43.                         for(int i=0;i<a.length;i++){
  44.                                 System.out.print(a[i]+"\t");
  45.                         }
  46.                         System.out.println();
  47.                 }
  49.         }
  50. }

二维数组的初始化方式

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

  • 静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

eg:

int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

  • 动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

eg:

int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组

arr[0] = new int[]{1,2};

arr[1] = new int[]{3,4,5,6};

arr[2] = new int[]{34,45,56};

eg:

int[][] arr = new int[3][2]; 

public class TestArray16{

        public static void main(String[] args){

                int[][] arr = new int[3][2];

                //本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：

                arr[1] = new int[]{1,2,3,4};

                //数组遍历：

                for(int[] a:arr){

                        for(int num:a){

                                        System.out.print(num+"\t");

                        }

                        System.out.println();

                }

        }

}

  • 默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

这篇关于Java学习-详述main方法、可变参数、数组的工具类、二维数组的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/916829。

相关文章

springboot健康检查监控全过程

springboot健康检查监控全过程

《springboot健康检查监控全过程》文章介绍了SpringBoot如何使用Actuator和Micrometer进行健康检查和监控,通过配置和自定义健康指示器,开发者可以实时监控应用组件的状态,... 目录1. 引言重要性2. 配置Spring Boot ActuatorSpring Boot Act
阅读更多...
使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)

使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)

《使用Java解析JSON数据并提取特定字段的实现步骤(以提取mailNo为例)》在现代软件开发中,处理JSON数据是一项非常常见的任务,无论是从API接口获取数据,还是将数据存储为JSON格式,解析... 目录1. 背景介绍1.1 jsON简介1.2 实际案例2. 准备工作2.1 环境搭建2.1.1 添加
阅读更多...
Java实现任务管理器性能网络监控数据的方法详解

Java实现任务管理器性能网络监控数据的方法详解

《Java实现任务管理器性能网络监控数据的方法详解》在现代操作系统中,任务管理器是一个非常重要的工具,用于监控和管理计算机的运行状态,包括CPU使用率、内存占用等,对于开发者和系统管理员来说,了解这些... 目录引言一、背景知识二、准备工作1. Maven依赖2. Gradle依赖三、代码实现四、代码详解五
阅读更多...
java如何分布式锁实现和选型

java如何分布式锁实现和选型

《java如何分布式锁实现和选型》文章介绍了分布式锁的重要性以及在分布式系统中常见的问题和需求,它详细阐述了如何使用分布式锁来确保数据的一致性和系统的高可用性,文章还提供了基于数据库、Redis和Zo... 目录引言：分布式锁的重要性与分布式系统中的常见问题和需求分布式锁的重要性分布式系统中常见的问题和需求
阅读更多...
SpringBoot基于MyBatis-Plus实现Lambda Query查询的示例代码

SpringBoot基于MyBatis-Plus实现Lambda Query查询的示例代码

《SpringBoot基于MyBatis-Plus实现LambdaQuery查询的示例代码》MyBatis-Plus是MyBatis的增强工具,简化了数据库操作,并提高了开发效率,它提供了多种查询方... 目录引言基础环境配置依赖配置（Maven）application.yml 配置表结构设计demo_st
阅读更多...
在Ubuntu上部署SpringBoot应用的操作步骤

在Ubuntu上部署SpringBoot应用的操作步骤

《在Ubuntu上部署SpringBoot应用的操作步骤》随着云计算和容器化技术的普及,Linux服务器已成为部署Web应用程序的主流平台之一,Java作为一种跨平台的编程语言,具有广泛的应用场景,本... 目录一、部署准备二、安装 Java 环境1. 安装 JDK2. 验证 Java 安装三、安装 mys
阅读更多...
Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

《Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单》：本文主要介绍Springboot的ThreadPoolTaskScheduler线... 目录ThreadPoolTaskScheduler线程池实现15分钟不操作自动取消订单概要1，创建订单后
阅读更多...
JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

《JAVA中整型数组、字符串数组、整型数和字符串的创建与转换的方法》本文介绍了Java中字符串、字符数组和整型数组的创建方法,以及它们之间的转换方法,还详细讲解了字符串中的一些常用方法,如index... 目录一、字符串、字符数组和整型数组的创建1、字符串的创建方法1.1 通过引用字符数组来创建字符串1.2
阅读更多...
SpringCloud集成AlloyDB的示例代码

SpringCloud集成AlloyDB的示例代码

《SpringCloud集成AlloyDB的示例代码》AlloyDB是GoogleCloud提供的一种高度可扩展、强性能的关系型数据库服务,它兼容PostgreSQL,并提供了更快的查询性能... 目录1.AlloyDBjavascript是什么？AlloyDB 的工作原理2.搭建测试环境3.代码工程1.
阅读更多...
Java调用Python代码的几种方法小结

Java调用Python代码的几种方法小结

《Java调用Python代码的几种方法小结》Python语言有丰富的系统管理、数据处理、统计类软件包,因此从java应用中调用Python代码的需求很常见、实用,本文介绍几种方法从java调用Pyt... 目录引言Java core使用ProcessBuilder使用Java脚本引擎总结引言python
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2